v0.12.0

Signed-off-by: MiaoWoo <admin@yumc.pw>

lerna.json

@@ -1,5 +1,5 @@
 {
-    "version": "0.9.9",
+    "version": "0.12.0",
     "useWorkspaces": true,
     "npmClient": "yarn",
     "packages": [

packages/amqp/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/amqp",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript amqp package",
     "keywords": [
         "miaoscript",
@@ -19,17 +19,17 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/common": "^0.9.8",
-        "@ccms/container": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/common": "^0.12.0",
+        "@ccms/container": "^0.12.0"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.9.8",
+        "@ccms/nashorn": "^0.12.0",
         "@javatypes/amqp-client": "^0.0.3",
         "@javatypes/spring-amqp": "^0.0.3",
         "@javatypes/spring-rabbit": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     }
 }

packages/api/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/api",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -19,16 +19,16 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "dependencies": {
-        "@ccms/common": "^0.9.8",
-        "@ccms/container": "^0.9.9",
-        "@ccms/ployfill": "^0.9.8",
-        "base64-js": "^1.3.1",
+        "@ccms/common": "^0.12.0",
+        "@ccms/container": "^0.12.0",
+        "@ccms/ployfill": "^0.12.0",
+        "base64-js": "^1.5.1",
         "source-map-builder": "^0.0.7"
     },
     "devDependencies": {
         "@types/base64-js": "^1.3.0",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     }
 }

packages/api/src/command.ts

@@ -1,6 +1,6 @@
 import i18n from '@ccms/i18n'
 import { injectable } from "@ccms/container"
-import { plugin } from './interfaces'
+import { plugin } from './plugin'
 
 export namespace command {
     @injectable()

packages/api/src/console.ts

@@ -27,7 +27,8 @@ export class MiaoScriptConsole implements Console {
     private _level: LogLevel = LogLevel.INFO
 
     protected logger: any
-    protected prefix: string = '§6[§bMiaoScript§6]§r '
+
+    public prefix: string = '§6[§bMiaoScript§6]§r '
 
     constructor(name?: string) {
         this.name = name
@@ -47,10 +48,10 @@ export class MiaoScriptConsole implements Console {
     set name(name: string) {
         if (name) {
             this._name = `[${name}] `
-            // noinspection JSUnusedGlobalSymbols
             this.prefix = `§6[§cMS§6][§b${name}§6]§r `
         }
     }
+
     log(...args: any[]): void {
         this.logger.info(this.name + args.join(' '))
     }
@@ -133,6 +134,7 @@ export class MiaoScriptConsole implements Console {
         }
     }
     stack(ex: Error, color: boolean = true): string[] {
+        if (!ex) return []
         let stack = ex.getStackTrace()
         let cache = [(color ? '§c' : '') + ex]
         //@ts-ignore
@@ -157,9 +159,11 @@ export class MiaoScriptConsole implements Console {
                     var { fileName, lineNumber } = this.readSourceMap(trace.fileName, trace.lineNumber)
                     if (fileName.startsWith(root)) { fileName = fileName.split(root)[1] }
                 } else {
-                    for (let prefix in ignoreLogPrefix) {
-                        if (className.startsWith(ignoreLogPrefix[prefix])) {
-                            return
+                    if (!global.debug) {
+                        for (let prefix in ignoreLogPrefix) {
+                            if (className.startsWith(ignoreLogPrefix[prefix])) {
+                                return
+                            }
                         }
                     }
                 }

packages/api/src/constants.ts

@@ -1,4 +1,14 @@
 export namespace constants {
+    export namespace ServiceIdentifier {
+        /**
+         * Runtime Server NettyPipeline
+         */
+        export const NettyPipeline = Symbol("NettyPipeline")
+        /**
+         * Runtime Server RootLogger
+         */
+        export const RootLogger = Symbol("RootLogger")
+    }
     export namespace Reflect {
         export const Method = {
             getServerConnection: [/*spigot 1.8.8*/'aq',/*spigot 1.12.2*/ 'an', /*spigot 1.14.4+*/'getServerConnection', /*catserver 1.12.2*/'func_147137_ag']

packages/api/src/index.ts

@@ -1,11 +1,16 @@
 import "@ccms/nashorn"
 
+export * from './web'
+export * from './amqp'
 export * from './chat'
 export * from './task'
 export * from './event'
 export * from './proxy'
+export * from './plugin'
+export * from './server'
 export * from './console'
 export * from './channel'
 export * from './command'
+export * from './database'
+export * from './particle'
 export * from './constants'
-export * from './interfaces'

packages/api/src/interfaces/index.ts

@@ -1,5 +0,0 @@
-export * from './web'
-export * from './amqp'
-export * from './plugin'
-export * from './server'
-export * from './database'

packages/api/src/interfaces/server/native_plugin.ts

@@ -1,6 +0,0 @@
-export interface NativePluginManager {
-    load(name: string): boolean;
-    unload(name: string): boolean;
-    reload(name: string): boolean;
-    delete(name: string): boolean;
-}

packages/api/src/particle.ts

@@ -0,0 +1,494 @@
+import { Autowired, injectable } from '@ccms/container'
+
+import { task, plugin } from './index'
+
+const UUID = Java.type('java.util.UUID')
+const Math = Java.type('java.lang.Math')
+
+export namespace particle {
+    /**
+     * 表示一个特效对象
+     *
+     * @author Zoyn
+     */
+    export abstract class Particle {
+        private spawner: ParticleSpawner
+        private readonly uuid: string
+
+        private particle: any /* Particle */
+        private count: number = 1;
+        private offsetX: number = 0;
+        private offsetY: number = 0;
+        private offsetZ: number = 0;
+        private extra: number = 0;
+        private data: Object = null;
+
+        constructor() {
+            this.uuid = UUID.randomUUID().toString()
+        }
+        abstract show(location: any)
+
+        getUUID() {
+            return this.uuid
+        }
+
+        getSpawner() {
+            return this.spawner
+        }
+
+        setSpawner(spawner: ParticleSpawner) {
+            this.spawner = spawner
+            return this
+        }
+
+        getParticle() {
+            return this.particle
+        }
+
+        setParticle(particle: any, data: any = null) {
+            this.particle = particle
+            this.data = data
+            return this
+        }
+
+        getCount() {
+            return this.count
+        }
+
+        setCount(count: number) {
+            this.count = count
+            return this
+        }
+
+        getOffsetX() {
+            return this.offsetX
+        }
+
+        setOffsetX(offsetX: number) {
+            this.offsetX = offsetX
+            return this
+        }
+
+        getOffsetY() {
+            return this.offsetY
+        }
+
+        setOffsetY(offsetY: number) {
+            this.offsetY = offsetY
+            return this
+        }
+
+        getOffsetZ() {
+            return this.offsetZ
+        }
+
+        setOffsetZ(offsetZ: number) {
+            this.offsetZ = offsetZ
+            return this
+        }
+
+        getExtra() {
+            return this.extra
+        }
+
+        setExtra(extra: number) {
+            this.extra = extra
+            return this
+        }
+
+        getData() {
+            return this.data
+        }
+
+        setData(data) {
+            this.data = data
+            return this
+        }
+
+        /**
+         * 通过给定一个坐标就可以使用已经指定的参数来播放粒子
+         *
+         * @param location 坐标
+         */
+        spawn(location: any) {
+            if (!this.spawner) throw new Error(`particle ${this.uuid} not set spawner can't spawn!`)
+            this.spawner.spawn(location, this)
+        }
+    }
+    /**
+     * 表示一条线
+     *
+     * @author Zoyn
+     */
+    export class Line extends Particle {
+        private vector: any
+        private start: any
+        private end: any
+        /**
+         * 步长
+         */
+        private step: number
+        /**
+         * 向量长度
+         */
+        private length: number
+
+        /**
+         * 构造一条线
+         *
+         * @param start 线的起点
+         * @param end   线的终点
+         */
+        constructor(start: any, end: any)
+        /**
+         * 构造一条线
+         *
+         * @param start  线的起点
+         * @param end    线的终点
+         * @param step   每个粒子之间的间隔 (也即步长)
+         */
+        constructor(start: any, end: any, step: number = 0.1) {
+            super()
+            this.start = start
+            this.end = end
+            this.step = step
+            // 对向量进行重置
+            this.resetVector()
+        }
+
+        show() {
+            for (let i = 0; i < this.length; i += this.step) {
+                let vectorTemp = this.vector.clone().multiply(i)
+                this.spawn(this.start.clone().add(vectorTemp))
+            }
+        }
+
+        /**
+         * 获取线的起始坐标
+         *
+         * @return {@link Location}
+         */
+        getStart() {
+            return this.start
+        }
+
+        /**
+         * 利用给定的坐标设置线的起始坐标
+         *
+         * @param start 起始坐标
+         * @return {@link Line}
+         */
+        setStart(start) {
+            this.start = start
+            this.resetVector()
+            return this
+        }
+
+        /**
+         * 获取线的终点坐标
+         *
+         * @return {@link Location}
+         */
+        getEnd() {
+            return this.end
+        }
+
+        /**
+         * 利用给定的坐标设置线的终点坐标
+         *
+         * @param end 终点
+         * @return {@link Line}
+         */
+        setEnd(end) {
+            this.end = end
+            this.resetVector()
+            return this
+        }
+
+        /**
+         * 获取每个粒子之间的间隔
+         *
+         * @return 也就是循环的步长
+         */
+        getStep() {
+            return this.step
+        }
+
+        /**
+         * 设置每个粒子之间的间隔
+         *
+         * @param step 间隔
+         * @return {@link Line}
+         */
+        setStep(step) {
+            this.step = step
+            this.resetVector()
+            return this
+        }
+
+        /**
+         * 手动重设线的向量
+         */
+        resetVector() {
+            this.vector = this.end.clone().subtract(this.start).toVector()
+            this.length = this.vector.length()
+            this.vector.normalize()
+        }
+
+        public static buildLine(locA: any, locB: any, step: number, particle: any) {
+            let vectorAB = locB.clone().subtract(locA).toVector()
+            let vectorLength = vectorAB.length()
+            vectorAB.normalize()
+            for (let i = 0; i < vectorLength; i += step) {
+                ParticleManager.globalSpawner.spawn(locA.clone().add(vectorAB.clone().multiply(i)), particle)
+            }
+        }
+    }
+    /**
+     * 表示一个弧
+     *
+     * @author Zoyn
+     */
+    export class Arc extends Particle {
+        private angle: number
+        private radius: number
+        private step: number
+
+        /**
+         * 构造一个弧
+         *
+         * @param origin 弧所在的圆的圆点
+         * @param angle  弧所占的角度
+         * @param radius 弧所在的圆的半径
+         * @param step   每个粒子的间隔(也即步长)
+         */
+        constructor(angle: number = 30, radius: number = 1, step: number = 1) {
+            super()
+            this.angle = angle
+            this.radius = radius
+            this.step = step
+        }
+
+        show(location: any) {
+            for (let i = 0; i < this.angle; i += this.step) {
+                let radians: number = Math.toRadians(i)
+                let x: number = this.radius * Math.cos(radians)
+                let z: number = this.radius * Math.sin(radians)
+
+                super.spawn(location.clone().add(x, 0, z))
+            }
+        }
+
+        getAngle(): number {
+            return this.angle
+        }
+
+        setAngle(angle: number): Arc {
+            this.angle = angle
+            return this
+        }
+
+        getRadius(): number {
+            return this.radius
+        }
+
+        setRadius(radius: number): Arc {
+            this.radius = radius
+            return this
+        }
+
+        getStep(): number {
+            return this.step
+        }
+
+        setStep(step: number): Arc {
+            this.step = step
+            return this
+        }
+    }
+    /**
+     * 表示一个圆
+     *
+     * @author Zoyn
+     */
+    export class Circle extends Arc {
+        constructor(radius: number)
+        constructor(radius: number, step: number)
+        /**
+         * 构造一个圆
+         *
+         * @param origin 圆的圆点
+         * @param radius 圆的半径
+         * @param step   每个粒子的间隔(也即步长)
+         * @param period 特效周期(如果需要可以使用)
+         */
+        constructor(radius: number = 1, step: number = 1) {
+            // Circle只需要控制这个fullArc就可以满足所有的要求
+            super(360, radius, step)
+        }
+    }
+    const AtomicInteger = Java.type("java.util.concurrent.atomic.AtomicInteger")
+
+    @injectable()
+    export abstract class ParticleManager {
+        public static globalSpawner: ParticleSpawner = undefined
+        @Autowired()
+        private taskManager: task.TaskManager
+
+        protected taskId: java.util.concurrent.atomic.AtomicInteger
+        protected cacheTasks = new Map<string, ParticleTask>()
+        protected pluginCacheTasks = new Map<string, Map<number, ParticleTask>>()
+
+        constructor() {
+            this.taskId = new AtomicInteger(0)
+        }
+
+        /**
+         * 获得自增的任务ID
+         */
+        public nextId() {
+            return this.taskId.incrementAndGet()
+        }
+
+        public getTaskManager() {
+            return this.taskManager
+        }
+
+        public create(particle: Particle, plugin?: plugin.Plugin) {
+            let uuid = particle.getUUID()
+            if (this.cacheTasks.has(uuid)) {
+                return this.cacheTasks.get(uuid)
+            }
+            let task = this.create0(plugin, particle)
+            this.cacheTasks.set(uuid, task)
+            if (plugin) {
+                if (!this.pluginCacheTasks.has(plugin.description.name)) {
+                    this.pluginCacheTasks.set(plugin.description.name, new Map())
+                }
+                this.pluginCacheTasks.get(plugin.description.name).set(task.getTaskId(), task)
+            }
+            return task
+        }
+
+        public cancel(particle: Particle) {
+            let uuid = particle.getUUID()
+            if (this.cacheTasks.has(uuid)) {
+                this.cacheTasks.get(uuid).cancel()
+                this.cacheTasks.delete(uuid)
+            } else {
+                throw new Error(`particle ${uuid} not found!`)
+            }
+        }
+
+        disable(plugin: plugin.Plugin) {
+            if (this.pluginCacheTasks.has(plugin.description.name)) {
+                this.pluginCacheTasks
+                    .get(plugin.description.name)
+                    .forEach((task) => task.cancel())
+                this.pluginCacheTasks.delete(plugin.description.name)
+            }
+        }
+        protected create0(owner: plugin.Plugin, particle: Particle): ParticleTask {
+            particle.setSpawner(this.getGlobalSpawner())
+            return new ParticleTask(owner, particle, this)
+        }
+        protected abstract getGlobalSpawner(): ParticleSpawner
+    }
+
+    export class ParticleTask {
+
+        private particle: Particle
+        private isAsync: boolean = false
+        private interval: number = 0
+        private _location: any
+        private _follow: any
+
+        private owner: plugin.Plugin
+        private taskId: number
+        private task: task.Task
+        private taskManager: task.TaskManager
+        protected particleManager: ParticleManager
+
+        constructor(owner: plugin.Plugin, particle: Particle, particleManager: ParticleManager) {
+            this.owner = owner
+            this.taskId = particleManager.nextId()
+            this.particle = particle
+            this.taskManager = particleManager.getTaskManager()
+            this.particleManager = particleManager
+        }
+
+        getOwner() {
+            return this.task.getOwner()
+        }
+
+        getTaskId() {
+            return this.taskId
+        }
+
+        getParticle() {
+            return this.particle
+        }
+
+        async(isAsync: boolean = true) {
+            this.isAsync = isAsync
+            return this
+        }
+
+        timer(tick: number) {
+            this.interval = tick
+            return this
+        }
+
+        follow(entity: { getLocation: () => any }) {
+            this._follow = entity
+            this._location = undefined
+            return this
+        }
+
+        location(location: any) {
+            this._location = location
+            this._follow = undefined
+            return this
+        }
+
+        submit() {
+            this.cancel()
+            if (this._follow && !this.interval) throw new Error(`enable follow entity but interval is ${this.interval}!`)
+            this.taskManager.create(() => {
+                this.task = this.taskManager
+                    .create(() => {
+                        try {
+                            if (this._follow) {
+                                if (!this._follow.isOnline()) return this.cancel()
+                                this.particle.show(this._follow.getLocation().clone().add(0, 1, 0))
+                            } else if (this._location) {
+                                this.particle.show(this._location)
+                            } else {
+                                console.warn(`ParticleTask ${this.taskId} particle ${this.particle.getUUID()} cancel because entity and location both undefined!`)
+                                this.task.cancel()
+                            }
+                        } catch (error) {
+                            console.error(`§6插件 §a${this.owner.description.name} §c播放粒子发送异常 §4粒子播放任务已终止!`)
+                            console.ex(error)
+                            this.cancel()
+                        }
+                    }, this.owner)
+                    .async(this.isAsync)
+                    .timer(this.interval)
+                    .submit()
+            }, this.owner).later(2).submit()
+            return this
+        }
+
+        cancel() {
+            if (this.task != null) {
+                this.task.cancel()
+            }
+        }
+    }
+
+    export abstract class ParticleSpawner {
+        abstract spawnParticle(location: any, particle: any, count: number)
+        abstract spawn(location: any, particle: Particle)
+    }
+}

packages/api/src/plugin.ts

@@ -78,7 +78,7 @@ export namespace plugin {
         scan(target: any): PluginLoadMetadata[]
         /**
          * 读取插件 返回插件加载元信息
-         * @param target 
+         * @param target
          */
         read(target: any): PluginLoadMetadata
         /**
@@ -162,6 +162,14 @@ export namespace plugin {
          * 插件作者 不填默认为 Unknow
          */
         author?: string | string[]
+        /**
+         * 脚本依赖
+         */
+        depends?: string[]
+        /**
+         * 插件依赖
+         */
+        nativeDepends?: string[]
         /**
          * 插件源文件 必须指定为 __filename
          */

packages/api/src/server.ts

@@ -1,10 +1,7 @@
 import * as reflect from '@ccms/common/dist/reflect'
-import { injectable, inject } from '@ccms/container'
+import { injectable, Autowired, ContainerInstance, Container, postConstruct } from '@ccms/container'
 
-import { NativePluginManager } from './native_plugin'
-import { constants } from '../../constants'
-
-export { NativePluginManager } from './native_plugin'
+import { constants } from './constants'
 
 export namespace server {
     /**
@@ -19,6 +16,30 @@ export namespace server {
      * Runtime Server Instance
      */
     export const ServerInstance = Symbol("ServerInstance")
+    @injectable()
+    export abstract class NativePluginManager {
+        list(): any[] {
+            throw new Error("Method not implemented.")
+        }
+        has(name: string): boolean {
+            return true
+        }
+        get(name: string): any {
+            throw new Error("Method not implemented.")
+        }
+        load(name: string): boolean {
+            throw new Error("Method not implemented.")
+        }
+        unload(name: string): boolean {
+            throw new Error("Method not implemented.")
+        }
+        reload(name: string): boolean {
+            throw new Error("Method not implemented.")
+        }
+        delete(name: string): boolean {
+            throw new Error("Method not implemented.")
+        }
+    }
     /**
      * MiaoScript Server
      */
@@ -48,9 +69,6 @@ export namespace server {
         getPluginsFolder(): string {
             throw new Error("Method not implemented.")
         }
-        getNativePluginManager(): NativePluginManager {
-            throw new Error("Method not implemented.")
-        }
         getDedicatedServer?(): any {
             throw new Error("Method not implemented.")
         }
@@ -63,8 +81,9 @@ export namespace server {
     }
     @injectable()
     export class ServerChecker {
-        @inject(ServerType)
+        @Autowired(ServerType)
         private serverType: string
+
         check(servers: string[]) {
             // Not set servers -> allow
             if (!servers || !servers.length) return true
@@ -80,14 +99,17 @@ export namespace server {
     }
     @injectable()
     export abstract class ReflectServer extends server.Server {
+        @Autowired(ContainerInstance)
+        private container: Container
+
         protected pipeline: any
         protected rootLogger: any
 
         constructor() {
             super()
-            this.reflect()
         }
 
+        @postConstruct()
         protected reflect() {
             try {
                 let consoleServer = this.getDedicatedServer()
@@ -107,7 +129,11 @@ export namespace server {
                     if (connection.class.name.indexOf('ServerConnection') !== -1
                         || connection.class.name.indexOf('NetworkSystem') !== -1) { break }
                     connection = undefined
-                } catch (error) { }
+                } catch (error) {
+                    if (global.debug) {
+                        console.ex(error)
+                    }
+                }
             }
             if (!connection) { console.error("Can't found ServerConnection!"); return }
             for (const field of constants.Reflect.Field.listeningChannels) {
@@ -115,16 +141,30 @@ export namespace server {
                     promise = reflect.on(connection).get(field).get().get(0)
                     if (promise.class.name.indexOf('Promise') !== -1) { break }
                     promise = undefined
-                } catch (error) { }
+                } catch (error) {
+                    if (global.debug) {
+                        console.ex(error)
+                    }
+                }
             }
             if (!promise) { console.error("Can't found listeningChannels!"); return }
             this.pipeline = reflect.on(promise).get('channel').get().pipeline()
+            this.container.bind(constants.ServiceIdentifier.NettyPipeline).toConstantValue(this.pipeline)
         }
         protected reflectRootLogger(consoleServer: any) {
             try {
                 this.rootLogger = reflect.on(consoleServer).get('LOGGER').get().parent
             } catch (error) {
-                try { this.rootLogger = reflect.on(consoleServer).get(0).get().parent } catch (error) { }
+                if (global.debug) {
+                    console.ex(error)
+                }
+                try {
+                    this.rootLogger = reflect.on(consoleServer).get(0).get().parent
+                } catch (error) {
+                    if (global.debug) {
+                        console.ex(error)
+                    }
+                }
             }
             if (this.rootLogger && this.rootLogger.class.name.indexOf('Logger') === -1) {
                 console.error('Error Logger Class: ' + this.rootLogger.class.name)
@@ -135,6 +175,7 @@ export namespace server {
                 this.rootLogger = this.rootLogger.parent
             }
             if (!this.rootLogger) { console.error("Can't found rootLogger!") }
+            this.container.bind(constants.ServiceIdentifier.RootLogger).toConstantValue(this.rootLogger)
         }
     }
 }

packages/api/src/task.ts

@@ -1,34 +1,66 @@
 import { plugin } from './index'
 import { injectable } from '@ccms/container'
 
+const AtomicInteger = Java.type("java.util.concurrent.atomic.AtomicInteger")
+
 export namespace task {
     @injectable()
     export abstract class TaskManager {
-        protected cacheTasks = new Map<string, task.Task[]>()
+        protected taskId: java.util.concurrent.atomic.AtomicInteger
+        protected cacheTasks = new Map<number, task.Task>()
+        protected pluginCacheTasks = new Map<string, Map<number, task.Task>>()
+
+        constructor() {
+            this.taskId = new AtomicInteger(0)
+            process.on('task.finish', (task: task.Task) => {
+                let taskId = task.getTaskId()
+                this.cacheTasks.delete(taskId)
+                let ownerName = task.getOwner()?.description.name
+                if (ownerName && this.pluginCacheTasks.has(ownerName)) {
+                    this.pluginCacheTasks.get(ownerName).delete(taskId)
+                }
+            })
+        }
 
         protected pluginCreate(plugin: plugin.Plugin, task: task.Task) {
-            if (!this.cacheTasks.has(plugin.description.name)) {
-                this.cacheTasks.set(plugin.description.name, [])
+            if (!this.pluginCacheTasks.has(plugin.description.name)) {
+                this.pluginCacheTasks.set(plugin.description.name, new Map())
             }
-            this.cacheTasks.get(plugin.description.name).push(task)
+            this.pluginCacheTasks.get(plugin.description.name).set(task.getTaskId(), task)
             return task
         }
+
         protected pluginDisable(plugin: plugin.Plugin) {
-            if (this.cacheTasks.has(plugin.description.name)) {
-                this.cacheTasks.get(plugin.description.name).forEach(task => task.cancel())
-                this.cacheTasks.delete(plugin.description.name)
+            if (this.pluginCacheTasks.has(plugin.description.name)) {
+                this.pluginCacheTasks.get(plugin.description.name).forEach((task) => {
+                    task.cancel()
+                })
+                this.pluginCacheTasks.delete(plugin.description.name)
             }
         }
+
+        /**
+         * 获得自增的任务ID
+         */
+        protected nextId() {
+            return this.taskId.incrementAndGet()
+        }
+
         /**
          * 创建任务
          * @param func 任务内容
          */
         create(func: Function, plugin?: plugin.Plugin): task.Task {
             if (Object.prototype.toString.call(func) !== "[object Function]") { throw TypeError('第一个参数 Task 必须为 function !') };
-            let task = this.create0(func)
+            let task = this.create0(plugin, func, this.nextId())
+            this.cacheTasks.set(task.getTaskId(), task)
             if (plugin) { return this.pluginCreate(plugin, task) }
             return task
         }
+        cancel(taskId: number) {
+            if (!this.cacheTasks.has(taskId)) { throw new Error(`Task ${taskId} not found!`) }
+            this.cacheTasks.get(taskId).cancel()
+        }
         /**
          * 在主线程执行代码
          * @param func 执行内容
@@ -41,22 +73,33 @@ export namespace task {
             if (plugin) { return this.pluginDisable(plugin) }
             this.disable0()
         }
-        protected abstract create0(func: Function): task.Task
+        protected abstract create0(owner: plugin.Plugin, func: Function, id: number): task.Task
         protected abstract disable0()
     }
     /**
      * 任务抽象
      */
-    export abstract class Task {
-        protected plugin: any
+    export abstract class Task implements Cancelable {
         protected func: Function
         protected isAsync: boolean = false;
         protected laterTime: number = 0;
         protected interval: number = 0;
+        protected owner: plugin.Plugin
+        protected taskId: number
+        protected innerTask: any
 
-        constructor(plugin: any, func: Function) {
-            this.plugin = plugin
+        constructor(owner: plugin.Plugin, func: Function, id: number) {
+            this.owner = owner
             this.func = func
+            this.taskId = id
+        }
+
+        getOwner() {
+            return this.owner
+        }
+
+        getTaskId() {
+            return this.taskId
         }
 
         /**
@@ -90,12 +133,15 @@ export namespace task {
          * 取消任务
          */
         cancel(): boolean {
-            throw new Error("Method not implemented.")
+            let result = this.cancel0()
+            process.emit('task.finish', this)
+            return result
         }
 
         protected run(...args: any[]): void {
             try {
                 this.func(...args)
+                !this.interval && process.emit('task.finish', this)
             } catch (ex) {
                 console.console('§4插件执行任务时发生错误', ex)
                 console.ex(ex)
@@ -106,17 +152,22 @@ export namespace task {
          * 提交任务
          * @param args 任务参数
          */
-        submit(...args: any[]): Cancelable {
-            let cancelable = this.submit0(...args)
-            this.cancel = cancelable.cancel
-            return cancelable
+        submit(...args: any[]): task.Task {
+            this.innerTask = this.submit0(...args)
+            return this
         }
 
         /**
          * 提交任务
          * @param args 任务参数
          */
-        protected abstract submit0(...args: any[]): Cancelable
+        protected abstract submit0(...args: any[]): any
+        /**
+         * 取消任务
+         */
+        protected cancel0(): boolean {
+            return this.innerTask?.cancel()
+        }
     }
     /**
      * 返可取消的对象

packages/bukkit/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/bukkit",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript bukkit package",
     "keywords": [
         "miaoscript",
@@ -22,11 +22,11 @@
         "@javatypes/spigot-api": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/common": "^0.9.8",
-        "@ccms/container": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/common": "^0.12.0",
+        "@ccms/container": "^0.12.0"
     }
 }

packages/bukkit/src/index.ts

@@ -8,9 +8,12 @@ import './chat'
 import './task'
 import './event'
 import './server'
+import { BukkitNativePluginManager } from './plugin'
 import './command'
 import './channel'
+import './particle'
 
 export default function BukkitImpl(container: Container) {
     container.bind(server.Console).toConstantValue(BukkitConsole)
+    container.rebind(server.NativePluginManager).toConstantValue(new BukkitNativePluginManager())
 }

packages/bukkit/src/particle.ts

@@ -0,0 +1,31 @@
+import { provideSingleton } from '@ccms/container'
+import { particle, plugin } from '@ccms/api'
+
+@provideSingleton(particle.ParticleManager)
+export class BukkitParticleManager extends particle.ParticleManager {
+    private globalSpawner = new BukkitParticleSpawner()
+    constructor() {
+        super()
+        particle.ParticleManager.globalSpawner = this.globalSpawner
+    }
+    protected getGlobalSpawner() {
+        return this.globalSpawner
+    }
+}
+export class BukkitParticleSpawner extends particle.ParticleSpawner {
+    spawnParticle(location: any, particle: any, count: number = 1) {
+        location.getWorld().spawnParticle(particle, location, count)
+    }
+    spawn(location: any, particle: particle.Particle) {
+        location.getWorld().spawnParticle(
+            particle.getParticle(),
+            location,
+            particle.getCount(),
+            particle.getOffsetX(),
+            particle.getOffsetY(),
+            particle.getOffsetZ(),
+            particle.getExtra(),
+            particle.getData()
+        )
+    }
+}

packages/bukkit/src/plugin.ts

@@ -0,0 +1,12 @@
+import { server } from '@ccms/api'
+
+const Bukkit = org.bukkit.Bukkit
+
+export class BukkitNativePluginManager extends server.NativePluginManager {
+    has(name: string) {
+        return !!this.get(name)
+    }
+    get(name: string) {
+        return Bukkit.getPluginManager().getPlugin(name)
+    }
+}

packages/bukkit/src/task.ts

@@ -7,17 +7,14 @@ const Callable = Java.type('java.util.concurrent.Callable')
 
 @provideSingleton(task.TaskManager)
 export class BukkitTaskManager extends task.TaskManager {
-    @inject(plugin.PluginInstance)
-    private pluginInstance: any
-
-    create0(func: Function): task.Task {
-        return new BukkitTask(this.pluginInstance, func)
+    create0(owner: plugin.Plugin, func: Function, id: number): task.Task {
+        return new BukkitTask(owner, func, id)
     }
     callSyncMethod(func: Function): any {
-        return Bukkit.getScheduler().callSyncMethod(this.pluginInstance, new Callable({ call: () => func() })).get()
+        return Bukkit.getScheduler().callSyncMethod(base.getInstance(), new Callable({ call: () => func() })).get()
     }
     disable0() {
-        Bukkit.getScheduler().cancelTasks(this.pluginInstance)
+        Bukkit.getScheduler().cancelTasks(base.getInstance())
     }
 }
 
@@ -26,9 +23,9 @@ export class BukkitTask extends task.Task {
         let run = new BukkitRunnable({ run: () => this.run(...args) })
         let funcName = `runTask${this.interval ? 'Timer' : 'Later'}${this.isAsync ? 'Asynchronously' : ''}`
         if (this.interval) {
-            return run[funcName](this.plugin, this.laterTime, this.interval)
+            return run[funcName](base.getInstance(), this.laterTime, this.interval)
         } else {
-            return run[funcName](this.plugin, this.laterTime)
+            return run[funcName](base.getInstance(), this.laterTime)
         }
     }
 }

packages/bungee/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/bungee",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript bungee package",
     "keywords": [
         "miaoscript",
@@ -22,11 +22,11 @@
         "@javatypes/bungee-api": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/common": "^0.9.8",
-        "@ccms/container": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/common": "^0.12.0",
+        "@ccms/container": "^0.12.0"
     }
 }

packages/bungee/src/index.ts

@@ -3,13 +3,15 @@
 import { server } from '@ccms/api'
 import { Container } from '@ccms/container'
 
-import { BungeeConsole } from './console';
-import './event';
-import './server';
-import './command';
-import './channel';
-import './task';
+import { BungeeConsole } from './console'
+import './task'
+import './event'
+import './server'
+import { BungeeNativePluginManager } from './plugin'
+import './command'
+import './channel'
 
 export default function BungeeImpl(container: Container) {
-    container.bind(server.Console).toConstantValue(BungeeConsole);
+    container.bind(server.Console).toConstantValue(BungeeConsole)
+    container.rebind(server.NativePluginManager).toConstantValue(new BungeeNativePluginManager())
 }

packages/bungee/src/plugin.ts

@@ -0,0 +1,12 @@
+import { server } from '@ccms/api'
+
+let Bungee: net.md_5.bungee.api.ProxyServer = base.getInstance().getProxy()
+
+export class BungeeNativePluginManager extends server.NativePluginManager {
+    has(name: string) {
+        return !!this.get(name)
+    }
+    get(name: string) {
+        return Bungee.getPluginManager().getPlugin(name)
+    }
+}

packages/bungee/src/task.ts

@@ -6,17 +6,14 @@ let TimeUnit = Java.type('java.util.concurrent.TimeUnit')
 
 @provideSingleton(task.TaskManager)
 export class BungeeTaskManager extends task.TaskManager {
-    @inject(plugin.PluginInstance)
-    private pluginInstance: any
-
-    create0(func: Function): task.Task {
-        return new BungeeTask(this.pluginInstance, func)
+    create0(owner: plugin.Plugin, func: Function, id: number): task.Task {
+        return new BungeeTask(owner, func, id)
     }
     callSyncMethod(func: Function): any {
         return func()
     }
     disable0() {
-        this.pluginInstance.getProxy().getScheduler().cancel(this.pluginInstance)
+        base.getInstance().getProxy().getScheduler().cancel(base.getInstance())
     }
 }
 
@@ -24,12 +21,12 @@ export class BungeeTask extends task.Task {
     submit0(...args: any[]): task.Cancelable {
         let run = new Runnable({ run: () => this.run(...args) })
         if (this.isAsync) {
-            return this.plugin.getProxy().getScheduler().runAsync(this.plugin, run)
+            return base.getInstance().getProxy().getScheduler().runAsync(base.getInstance(), run)
         }
         if (this.interval) {
-            return this.plugin.getProxy().getScheduler().schedule(this.plugin, run, this.laterTime * 50, this.interval * 50, TimeUnit.MILLISECONDS)
+            return base.getInstance().getProxy().getScheduler().schedule(base.getInstance(), run, this.laterTime * 50, this.interval * 50, TimeUnit.MILLISECONDS)
         } else {
-            return this.plugin.getProxy().getScheduler().schedule(this.plugin, run, this.laterTime * 50, TimeUnit.MILLISECONDS)
+            return base.getInstance().getProxy().getScheduler().schedule(base.getInstance(), run, this.laterTime * 50, TimeUnit.MILLISECONDS)
         }
     }
 }

packages/client/package.json

@@ -1,7 +1,7 @@
 {
     "private": true,
     "name": "@ccms/client",
-    "version": "0.9.4",
+    "version": "0.12.0",
     "description": "MiaoScript client package",
     "keywords": [
         "miaoscript",
@@ -22,10 +22,10 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "dependencies": {
-        "minecraft-protocol": "^1.16.0"
+        "minecraft-protocol": "^1.19.0"
     },
     "devDependencies": {
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     }
 }

packages/common/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/common",
-    "version": "0.9.8",
+    "version": "0.12.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -19,11 +19,11 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.9.8",
+        "@ccms/nashorn": "^0.12.0",
         "@javatypes/jdk": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "gitHead": "562e2d00175c9d3a99c8b672aa07e6d92706a027"
 }

packages/common/src/reflect.ts

@@ -1,14 +1,15 @@
 /// <reference types="@javatypes/jdk" />
 
+const JavaClass = Java.type('java.lang.Class')
+const JavaObject = Java.type('java.lang.Object')
+const NoSuchFieldException = Java.type('java.lang.NoSuchFieldException')
+const fieldCache = new Map<string, java.lang.reflect.Field>()
+const methodCache = new Map<string, java.lang.reflect.Method>()
+
 /**
  * 反射工具类
  * Created by MiaoWoo on 2017/2/9 0009.
  */
-const JavaClass = Java.type('java.lang.Class')
-const JavaObject = Java.type('java.lang.Object')
-const NoSuchFieldException = Java.type('java.lang.NoSuchFieldException')
-const methodCache = []
-
 class Reflect {
     private obj: java.lang.Object
     private class: java.lang.Class<any>
@@ -34,15 +35,26 @@ class Reflect {
         return Java.from(declaredMethods(this.class))
     }
 
-    field(name: string | java.lang.String): Reflect {
-        try {
-            // Try getting a public field
-            let field = this.class.getField(name)
-            return on(field.get(this.obj))
-        } catch (ex) {
-            // Try again, getting a non-public field
-            return on(accessible(declaredField(this.class, name)).get(this.obj))
+    field(nameOrIndex: string | java.lang.String | number, declared = false): java.lang.reflect.Field {
+        if (nameOrIndex == undefined || nameOrIndex == null) throw new Error(`reflect field name can't be ${nameOrIndex} from ${this.class.getName()}!`)
+        let key = this.class.getName() + ':' + nameOrIndex + ':' + declared
+        if (fieldCache.has(key)) {
+            return fieldCache.get(key)
         }
+        let field = null
+        if (typeof nameOrIndex == "number") {
+            field = this.fields(declared)[nameOrIndex]
+        } else {
+            try {
+                // Try getting a public field
+                field = this.class.getField(nameOrIndex)
+            } catch (ex) {
+                // Try again, getting a non-public field
+                field = declaredField(this.class, nameOrIndex)
+            }
+        }
+        if (!field) throw new Error(`can't reflect field ${typeof nameOrIndex == "number" ? 'index' : 'name'} ${nameOrIndex} from ${this.class.getName()}!`)
+        return accessible(field)
     }
 
     fields(declared = false): java.lang.reflect.Field[] {
@@ -50,7 +62,7 @@ class Reflect {
     }
 
     values(declared = false) {
-        return this.fields(declared).reduce((cache, field) => { return cache[field.getName()] = this.field(field.getName()).get() }, {}) as any
+        return this.fields(declared).reduce((cache, field) => { return cache[field.getName()] = this.get(field.getName()).get() }, {}) as any
     }
 
     call(...args: any[]): Reflect {
@@ -64,17 +76,12 @@ class Reflect {
     get(index: number, declared?: boolean): Reflect
     get(prop: string): Reflect
     get(param?: string | number, declared: boolean = true): Reflect | any {
-        if (param == undefined || param == null) return this.obj
-        if (typeof param == "number") {
-            return on(accessible(this.fields(declared)[param]).get(this.obj))
-        }
-        if (typeof param == "string") {
-            return this.field(param)
-        }
+        if (arguments.length === 0) return this.obj
+        return on(this.field(param, declared).get(this.obj))
     }
 
-    set(name: any, value: any): Reflect {
-        accessible(declaredField(this.class, name)).set(this.obj, value)
+    set(param: string | number, value: any, declared: boolean = true): Reflect {
+        this.field(param, declared).set(this.obj, value)
         return this
     }
 
@@ -136,64 +143,43 @@ function declaredField(clazz: java.lang.Class<any>, name: string | java.lang.Str
     return field
 }
 
-function declaredMethod(clazz: java.lang.Class<any>, name: string, ...clazzs: java.lang.Class<any>[]): java.lang.reflect.Method {
-    let key = clazz.getName() + '.' + name + ':' + (clazzs || []).join(':')
-    if (!methodCache[key]) {
+function declaredMethod(clazz: java.lang.Class<any>, nameOrIndex: string | number, ...clazzs: java.lang.Class<any>[]): java.lang.reflect.Method {
+    let key = clazz.getName() + '.' + nameOrIndex + ':' + (clazzs || []).map(c => c.getName()).join(':')
+    if (methodCache.has(key)) { return methodCache.get(key) }
+    if (typeof nameOrIndex === "number") {
+        methodCache.set(key, declaredMethods(clazz)[nameOrIndex])
+    } else {
         try {
-            // @ts-ignore
-            methodCache[key] = clazz.getMethod(name, clazzs)
+            methodCache.set(key, clazz.getMethod(nameOrIndex, clazzs as any))
         } catch (ex) {
             try {
-                methodCache[key] = clazz.getDeclaredMethod(name, clazzs as any)
+                methodCache.set(key, clazz.getDeclaredMethod(nameOrIndex, clazzs as any))
             } catch (ex) {
                 for (const m of Java.from(declaredMethods(clazz))) {
-                    if (m.getName() == name) {
-                        methodCache[key] = m
+                    if (m.getName() == nameOrIndex) {
+                        methodCache.set(key, m)
                         break
                     }
                 }
             }
         }
     }
-    return methodCache[key]
+    if (!methodCache.has(key)) throw new Error(`can't reflect method ${typeof nameOrIndex == "number" ? 'index' : 'name'} ${nameOrIndex} from ${clazz.getName()}!`)
+    return methodCache.get(key)
 }
 
 function declaredMethods(clazz: java.lang.Class<any>) {
     return clazz.getDeclaredMethods()
 }
 
-let classMethodsCache: any[] = []
-
 function mapToObject(javaObj) {
-    if (!javaObj || !javaObj.class) { throw new TypeError(`参数 ${javaObj} 不是一个Java对象!`) }
-    let target = {}
-    getJavaObjectMethods(javaObj).forEach(t => mapMethod(target, javaObj, t))
+    if (!Java.isJavaObject(javaObj)) { throw new TypeError(`参数 ${javaObj} 不是一个Java对象!`) }
+    let target = Proxy.newProxy(javaObj, {
+        apply: (target, name, args) => { return args ? javaObj[name](args) : javaObj[name]() }
+    })
     return target
 }
 
-function getJavaObjectMethods(javaObj) {
-    let className = javaObj.class.name
-    if (!classMethodsCache[className]) {
-        let names: any[] = []
-        let methods = javaObj.class.methods
-        for (let i in methods) {
-            names.push(methods[i].name)
-        }
-        classMethodsCache[className] = names
-    }
-    return classMethodsCache[className]
-}
-
-function mapMethod(target, source, name) {
-    target[name] = function __SimpleDynamicMethod__(...args) {
-        if (args.length > 0) {
-            return source[name](args)
-        } else {
-            return source[name]()
-        }
-    }
-}
-
 function on(obj) {
     // if (!obj || !obj.class) { throw new TypeError(`参数 ${obj} 不是一个Java对象!`) }
     return new Reflect(obj)

packages/compile/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/compile",
-    "version": "0.9.4",
+    "version": "0.12.0",
     "description": "MiaoScript compile package",
     "keywords": [
         "miaoscript",
@@ -21,6 +21,6 @@
     "devDependencies": {
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     }
 }

packages/container/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/container",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript container package",
     "keywords": [
         "miaoscript",
@@ -19,10 +19,10 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.9.8",
+        "@ccms/nashorn": "^0.12.0",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
         "inversify": "^5.0.1",

packages/core/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/core",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -21,11 +21,11 @@
     "devDependencies": {
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/container": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/container": "^0.12.0"
     },
     "gitHead": "781524f83e52cad26d7c480513e3c525df867121"
 }

packages/core/src/index.ts

@@ -1,25 +1,23 @@
 let containerStartTime = Date.now()
 console.i18n("ms.core.ioc.initialize", { scope: global.scope })
 import { plugin, server, task, constants } from '@ccms/api'
-import { DefaultContainer as container, inject, provideSingleton, ContainerInstance, buildProviderModule } from '@ccms/container'
+import { DefaultContainer as container, inject, provideSingleton, ContainerInstance, buildProviderModule, Autowired } from '@ccms/container'
 console.i18n("ms.core.ioc.completed", { scope: global.scope, time: (Date.now() - containerStartTime) / 1000 })
 import http from '@ccms/common/dist/http'
 
 @provideSingleton(MiaoScriptCore)
 class MiaoScriptCore {
-    @inject(server.Console)
+    @Autowired(server.Console)
     private Console: Console
-    @inject(task.TaskManager)
-    private taskManager: task.TaskManager
-    @inject(plugin.PluginFolder)
+    @Autowired(plugin.PluginFolder)
     private pluginFolder: string
-    @inject(plugin.PluginManager)
+    @Autowired()
+    private taskManager: task.TaskManager
+    @Autowired()
     private pluginManager: plugin.PluginManager
 
     enable() {
         this.loadServerConsole()
-        this.loadTaskFunction()
-        global.level = "TRACE"
         this.loadPlugins()
         return () => this.disable()
     }
@@ -29,15 +27,6 @@ class MiaoScriptCore {
         global.setGlobal('console', new this.Console(), { writable: false, configurable: false })
     }
 
-    loadTaskFunction() {
-        global.setGlobal('setTimeout', (func: Function, tick: number, ...args: any[]) => {
-            return this.taskManager.create(func).later(tick).submit(...args)
-        }, { writable: false, configurable: false })
-        global.setGlobal('setInterval', (func: Function, tick: number, ...args: any[]) => {
-            return this.taskManager.create(func).timer(tick).submit(...args)
-        }, { writable: false, configurable: false })
-    }
-
     loadPlugins() {
         let loadPluginStartTime = new Date().getTime()
         console.i18n("ms.core.plugin.initialize")
@@ -99,6 +88,7 @@ function initialize() {
         console.i18n("ms.core.initialize.detect", { scope: global.scope, type })
         container.bind(server.ServerType).toConstantValue(type)
         container.bind(server.ServerChecker).toSelf().inSingletonScope()
+        container.bind(server.NativePluginManager).toSelf().inSingletonScope()
         console.i18n("ms.core.package.initialize", { scope: global.scope, type })
         require(`${global.scope}/${type}`).default(container)
         require(`${global.scope}/plugin`)

packages/database/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/database",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript database package",
     "keywords": [
         "miaoscript",
@@ -22,10 +22,10 @@
         "@javatypes/spring-jdbc": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/container": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/container": "^0.12.0"
     }
 }

packages/i18n/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/i18n",
-    "version": "0.9.8",
+    "version": "0.12.0",
     "description": "MiaoScript i18n package",
     "keywords": [
         "miaoscript",
@@ -19,11 +19,11 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.9.8",
+        "@ccms/nashorn": "^0.12.0",
         "@types/js-yaml": "^3.12.5",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
         "js-yaml": "^3.14.0"

packages/i18n/src/index.ts

@@ -1,13 +1,13 @@
 /// <reference types="@ccms/nashorn" />
 import * as yaml from 'js-yaml'
 
-const File = Java.type("java.io.File");
-const separatorChar = File.separatorChar;
+const File = Java.type("java.io.File")
+const separatorChar = File.separatorChar
 type TranslateParam = { [key: string]: any }
 
 declare global {
     interface Console {
-        i18n(name: string, param?: TranslateParam);
+        i18n(name: string, param?: TranslateParam)
     }
 }
 
@@ -23,20 +23,20 @@ export class Translate {
 
     constructor(root: string | TranslateContent) {
         if (typeof root == 'string') {
-            this.root = root;
+            this.root = root
         } else {
-            this.langMap = root.langMap;
-            this.fallbackMap = root.fallbackMap || {};
+            this.langMap = root.langMap
+            this.fallbackMap = root.fallbackMap || {}
         }
     }
 
     translate(name: string, param?: TranslateParam) {
-        let langText: string = this.langMap[name] || this.fallbackMap[name];
+        let langText: string = this.langMap[name] || this.fallbackMap[name]
         if (!langText) { return '[WARN] @ccms/i18n miss lang translate: ' + name }
         for (const key in param) {
             langText = langText.replace(new RegExp("{" + key + "}", 'gm'), param[key])
         }
-        return langText;
+        return langText
     }
 
     initialize(lang: string = 'zh_cn', fallback: string = 'zh_cn') {
@@ -49,7 +49,7 @@ export class Translate {
     }
 
     readYamlFile(dir: string, name: string) {
-        let langFile = this.concat(dir, 'languages', name + '.yml');
+        let langFile = this.concat(dir, 'languages', name + '.yml')
         return this.exists(langFile) && yaml.safeLoad(base.read(langFile))
     }
 

packages/keyvalue/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/keyvalue",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript keyvalue package",
     "keywords": [
         "miaoscript",
@@ -19,18 +19,18 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/common": "^0.9.8",
-        "@ccms/container": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/common": "^0.12.0",
+        "@ccms/container": "^0.12.0"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.9.8",
+        "@ccms/nashorn": "^0.12.0",
         "@javatypes/amqp-client": "^0.0.3",
         "@javatypes/spring-amqp": "^0.0.3",
         "@javatypes/spring-rabbit": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "gitHead": "2589633069d24f646ac09261b1b2304c21d4ea75"
 }

packages/nashorn/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/nashorn",
-    "version": "0.9.8",
+    "version": "0.12.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -22,6 +22,6 @@
     "devDependencies": {
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     }
 }

packages/nashorn/src/index.ts

@@ -67,12 +67,14 @@ declare global {
     interface Core {
         getClass(name: String): any
         getProxyClass(): any
+        getJavaScriptTaskClass(): any
         getInstance(): any
         read(path: string): string
         save(path: string, content: string): void
         delete(path: string): void
     }
     interface Console {
+        prefix: string
         ex(err: Error): void
         stack(err: Error, color?: boolean): string[]
         sender(sender: any, ...args: any): void
@@ -81,8 +83,18 @@ declare global {
         i18n(name: string, ...params: any[]): void
     }
     interface ProxyConstructor {
-        newProxy<T extends object>(target: T, handler: ProxyHandler<T>): T
+        newProxy<T extends object>(target: T, handler: ProxyHandle<T>): T
     }
 }
-
+export interface ProxyHandle<T = any> extends ProxyHandler<any> {
+    setPrototypeOf?(target: T, v: any): any
+    // get: (target: any, name: string) => any
+    // set: (target: any, name: string, value: any) => boolean
+    // construct: (target: any, ...args: any[]) => any
+    // has: (target: any, name: string) => boolean
+    // ownKeys: (target: any) => string[]
+    values?: (target: T) => any[]
+    // call: (target: any, name: string, ...args: any[]) => any
+    // deleteProperty: (target: any, name: string) => boolean
+}
 export { }

packages/nodejs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/nodejs",
-    "version": "0.9.8",
+    "version": "0.12.0",
     "description": "MiaoScript nodejs package",
     "keywords": [
         "miaoscript",
@@ -19,10 +19,10 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.9.8",
+        "@ccms/nashorn": "^0.12.0",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "gitHead": "781524f83e52cad26d7c480513e3c525df867121"
 }

packages/nukkit/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/nukkit",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript nukkit package",
     "keywords": [
         "miaoscript",
@@ -22,11 +22,11 @@
         "@javatypes/nukkit-api": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/common": "^0.9.8",
-        "@ccms/container": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/common": "^0.12.0",
+        "@ccms/container": "^0.12.0"
     }
 }

packages/nukkit/src/console.ts

@@ -1,21 +1,25 @@
 import { MiaoScriptConsole } from '@ccms/api'
 
-let Nukkit = base.getInstance().getServer();
+let Nukkit = base.getInstance().getServer()
+let LogLevel = Java.type('cn.nukkit.utils.LogLevel')
 let CommandSender = Java.type('cn.nukkit.command.CommandSender')
 
 export class NukkitConsole extends MiaoScriptConsole {
     sender(sender, ...args) {
         if (!(sender instanceof CommandSender)) {
             this.error(`First parameter ${sender} not instanceof cn.nukkit.command.CommandSender can't send message!`)
-            return;
+            return
         }
         if (Object.prototype.toString.call(args[0]) === "[object Array]") {
             args[0].forEach(line => sender.sendMessage(this.prefix + line))
         } else {
-            sender.sendMessage(this.prefix + args.join(' '));
+            sender.sendMessage(this.prefix + args.join(' '))
         }
     }
     console(...args: string[]): void {
-        this.sender(Nukkit.getConsoleSender(), args.join(' '));
+        this.sender(Nukkit.getConsoleSender(), args.join(' '))
+    }
+    error(...args: any[]) {
+        this.logger.log(LogLevel.ERROR, this.name + args.join(' '))
     }
 }

packages/nukkit/src/index.ts

@@ -3,12 +3,14 @@
 import { server } from '@ccms/api'
 import { Container } from '@ccms/container'
 
-import { NukkitConsole } from './console';
-import './event';
-import './server';
-import './command';
-import './task';
+import { NukkitConsole } from './console'
+import './task'
+import './event'
+import './server'
+import { NukkitNativePluginManager } from './plugin'
+import './command'
 
 export default function NukkitImpl(container: Container) {
-    container.bind(server.Console).toConstantValue(NukkitConsole);
+    container.bind(server.Console).toConstantValue(NukkitConsole)
+    container.bind(server.NativePluginManager).toConstantValue(new NukkitNativePluginManager())
 }

packages/nukkit/src/plugin.ts

@@ -0,0 +1,12 @@
+import { server } from '@ccms/api'
+
+let Nukkit: cn.nukkit.Server = base.getInstance().getServer()
+
+export class NukkitNativePluginManager extends server.NativePluginManager {
+    has(name: string) {
+        return !!this.get(name)
+    }
+    get(name: string) {
+        return Nukkit.getPluginManager().getPlugin(name)
+    }
+}

packages/nukkit/src/task.ts

@@ -5,17 +5,14 @@ const NukkitRunnable = Java.type('cn.nukkit.scheduler.NukkitRunnable')
 
 @provideSingleton(task.TaskManager)
 export class NukkitTaskManager extends task.TaskManager {
-    @inject(plugin.PluginInstance)
-    private pluginInstance: any
-
-    create0(func: Function): task.Task {
-        return new NukkitTask(this.pluginInstance, func)
+    create0(owner: plugin.Plugin, func: Function, id: number): task.Task {
+        return new NukkitTask(owner, func, id)
     }
     callSyncMethod(func: Function): any {
         return func()
     }
     disable0() {
-        base.getInstance().getServer().getScheduler().cancelTask(this.pluginInstance)
+        base.getInstance().getServer().getScheduler().cancelTask(base.getInstance())
     }
 }
 
@@ -24,9 +21,9 @@ export class NukkitTask extends task.Task {
         let run = new NukkitRunnable({ run: () => this.run(...args) })
         let funcName = `runTask${this.interval ? 'Timer' : 'Later'}${this.isAsync ? 'Asynchronously' : ''}`
         if (this.interval) {
-            return run[funcName](this.plugin, this.laterTime, this.interval)
+            return run[funcName](base.getInstance(), this.laterTime, this.interval)
         } else {
-            return run[funcName](this.plugin, this.laterTime)
+            return run[funcName](base.getInstance(), this.laterTime)
         }
     }
 }

packages/ployfill/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/ployfill",
-    "version": "0.9.8",
+    "version": "0.12.0",
     "description": "MiaoScript ployfill package",
     "author": "MiaoWoo <admin@yumc.pw>",
     "homepage": "https://github.com/circlecloud/ms.git",
@@ -14,14 +14,14 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "dependencies": {
-        "@ccms/i18n": "^0.9.8",
-        "@ccms/nodejs": "^0.9.8",
-        "core-js": "^3.6.5"
+        "@ccms/i18n": "^0.12.0",
+        "@ccms/nodejs": "^0.12.0",
+        "core-js": "^3.7.0"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.9.8",
+        "@ccms/nashorn": "^0.12.0",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     }
 }

packages/ployfill/src/node-shim.ts

@@ -5,16 +5,18 @@ const ThreadGroup = Java.type("java.lang.ThreadGroup")
 const AtomicInteger = Java.type("java.util.concurrent.atomic.AtomicInteger")
 const ThreadPoolExecutor = Java.type('java.util.concurrent.ThreadPoolExecutor')
 const LinkedBlockingQueue = Java.type("java.util.concurrent.LinkedBlockingQueue")
+const TimeUnit = Java.type('java.util.concurrent.TimeUnit')
+const DelayQueue = Java.type('java.util.concurrent.DelayQueue')
+const JavaScriptTask = Java.type(base.getJavaScriptTaskClass().name)
 
 const threadCount = new AtomicInteger(0)
 const threadGroup = new ThreadGroup("@ccms/ployfill-micro-task")
 const microTaskPool = new ThreadPoolExecutor(
-    10, 100, 60, Packages.java.util.concurrent.TimeUnit.SECONDS,
-    new LinkedBlockingQueue(500),
+    100, 200, 60, Packages.java.util.concurrent.TimeUnit.SECONDS,
+    new LinkedBlockingQueue(300),
     (run: any) => new Thread(threadGroup, run, "@ccms/micro-task-" + threadCount.incrementAndGet()),
     new ThreadPoolExecutor.CallerRunsPolicy()
 )
-
 class Process extends EventEmitter {
     env = {
         __noSuchProperty__: (prop) => {
@@ -22,16 +24,120 @@ class Process extends EventEmitter {
         }
     }
     platform = Packages.java.lang.System.getProperty("os.name")
-    nextTick(func: Function) {
-        microTaskPool.execute(func)
+    on(event: string | symbol, listener: (...args: any[]) => void) {
+        return super.on(event, (...args) => {
+            try {
+                listener(...args)
+            } catch (error) {
+                try {
+                    super.emit('error', error)
+                } catch (error) {
+                    console.ex(error)
+                }
+            }
+        })
     }
-    queueMicrotask(func: Function) {
+    nextTick(func: Function) {
         microTaskPool.execute(func)
     }
     exit(code: number) {
         process.emit('exit', code)
-        microTaskPool.shutdown()
+        console.log(`process exit await microTaskPool termination! queueTask: ${microTaskPool.shutdownNow().size()} remainTask: ${threadGroup.activeCount()}`)
+        microTaskPool.awaitTermination(3000, TimeUnit.MILLISECONDS)
+    }
+}
+
+class EventLoop {
+    private eventLoopMainThread = undefined
+    private eventLoopTaskQueue = new DelayQueue()
+
+    constructor() {
+        this.eventLoopMainThread = new Thread(() => {
+            let task = undefined
+            try {
+                while ((task = this.eventLoopTaskQueue.take()) != undefined) {
+                    try {
+                        task.getTask()()
+                    } catch (error) {
+                        try {
+                            process.emit('error', error)
+                        } catch (error) {
+                            console.error(error)
+                            console.ex(error)
+                        }
+                    }
+                }
+            } catch (error) {
+                console.log(`EventLoop Thread isInterrupted exit! remainTask: ${this.eventLoopTaskQueue.size()}`)
+                this.eventLoopTaskQueue.clear()
+                this.eventLoopTaskQueue = undefined
+                this.timeoutCount = undefined
+                this.timeoutTasks = undefined
+                this.intervalCount = undefined
+                this.intervalTasks = undefined
+                this.eventLoopMainThread = undefined
+            }
+        }, "@ccms/node-shim/event-loop")
+        this.eventLoopMainThread.setDaemon(true)
+        process.on('exit', () => this.eventLoopMainThread.interrupt())
+    }
+
+    startEventLoop() {
+        this.eventLoopMainThread.start()
+    }
+
+    private putDelayTask(callback: Function, ms: number) {
+        this.eventLoopTaskQueue.put(new JavaScriptTask(callback, ms))
+    }
+
+    private timeoutCount = new AtomicInteger(0)
+    private timeoutTasks = []
+    setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]) {
+        let taskId = this.timeoutCount.incrementAndGet()
+        this.timeoutTasks[taskId] = callback
+        console.trace(`create setTimeout task ${taskId} => ${callback}`)
+        this.putDelayTask(() => {
+            if (this.timeoutTasks[taskId]) {
+                callback(...args)
+            } else {
+                console.trace(`ignore setTimeout ${ms}ms task ${taskId} because it's cancelled!`)
+            }
+        }, ms)
+        return taskId
+    }
+    clearTimeout(taskId: number) {
+        delete this.timeoutTasks[taskId]
+    }
+
+    private intervalCount = new AtomicInteger(0)
+    private intervalTasks = []
+    setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]) {
+        let taskId = this.intervalCount.incrementAndGet()
+        this.intervalTasks[taskId] = callback
+        console.trace(`create setInterval ${ms}ms task ${taskId} => ${callback}`)
+        let intervalTask = () => {
+            if (this.intervalTasks[taskId]) {
+                callback(...args)
+                this.putDelayTask(intervalTask, ms)
+            } else {
+                console.trace(`ignore setInterval task ${taskId} because it's cancelled!`)
+            }
+        }
+        this.putDelayTask(intervalTask, ms)
+        return taskId
+    }
+    clearInterval(taskId: number) {
+        delete this.intervalTasks[taskId]
     }
 }
 global.setGlobal('process', new Process(), {})
+const eventLoop = new EventLoop()
+global.setGlobal('eventLoop', eventLoop, {})
+eventLoop.startEventLoop()
 global.setGlobal('queueMicrotask', (func: any) => microTaskPool.execute(func), {})
+global.setGlobal('setTimeout', eventLoop.setTimeout.bind(eventLoop), {})
+global.setGlobal('clearTimeout', eventLoop.clearTimeout.bind(eventLoop), {})
+global.setGlobal('setImmediate', (callback: (...args: any[]) => void, ...args: any[]) => eventLoop.setTimeout(callback, 0, ...args), {})
+global.setGlobal('clearImmediate ', eventLoop.clearTimeout.bind(eventLoop), {})
+global.setGlobal('setInterval', eventLoop.setInterval.bind(eventLoop), {})
+global.setGlobal('clearInterval', eventLoop.clearInterval.bind(eventLoop), {})

packages/ployfill/src/proxy.ts

@@ -1,17 +1,9 @@
+import { ProxyHandle } from '@ccms/nashorn'
+
 // Nashorn JSAdapter See https://wiki.openjdk.java.net/display/Nashorn/Nashorn+extensions#Nashornextensions-JSAdapterconstructor
 let createProxy = eval(`
     function(handle){ return new JSAdapter(handle) }
 `)
-export interface ProxyHandle extends ProxyHandler<any> {
-    // get: (target: any, name: string) => any
-    // set: (target: any, name: string, value: any) => boolean
-    // construct: (target: any, ...args: any[]) => any
-    // has: (target: any, name: string) => boolean
-    // ownKeys: (target: any) => string[]
-    values: (target: any) => any[];
-    // call: (target: any, name: string, ...args: any[]) => any
-    // deleteProperty: (target: any, name: string) => boolean
-}
 export class Proxy {
     static newProxy(target: any, handle: Partial<ProxyHandle>): any {
         return new Proxy(target, handle)

packages/plugin/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/plugin",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -22,13 +22,13 @@
         "@types/js-yaml": "^3.12.5",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/common": "^0.9.8",
-        "@ccms/container": "^0.9.9",
-        "@ccms/i18n": "^0.9.8",
+        "@ccms/api": "^0.12.0",
+        "@ccms/common": "^0.12.0",
+        "@ccms/container": "^0.12.0",
+        "@ccms/i18n": "^0.12.0",
         "js-yaml": "^3.14.0"
     }
 }

packages/plugin/src/command.ts

@@ -1,5 +1,6 @@
 import { command, plugin, server } from '@ccms/api'
-import { provideSingleton, inject, Autowired } from '@ccms/container'
+import { provideSingleton, Autowired } from '@ccms/container'
+import { interfaces } from './interfaces'
 import { getPluginCommandMetadata, getPluginTabCompleterMetadata } from './utils'
 
 @provideSingleton(PluginCommandManager)
@@ -23,11 +24,10 @@ export class PluginCommandManager {
                 continue
             }
             for (let command of [cmd.name, ...cmd.alias]) {
+                let [cmdExecutor, cmdCompleter] = this.generateAutoMainCommand(pluginInstance, cmd, tabs.get(command))
                 this.CommandManager.on(pluginInstance, command, {
-                    cmd: pluginInstance[cmd.executor].bind(pluginInstance),
-                    tab: tabs.has(command) ?
-                        pluginInstance[tabs.get(command).executor].bind(pluginInstance) :
-                        console.debug(`[${pluginInstance.description.name}] command ${cmd.name} is not registry tabCompleter`)
+                    cmd: cmdExecutor.bind(pluginInstance),
+                    tab: cmdCompleter?.bind(pluginInstance)
                 })
             }
         }
@@ -35,8 +35,31 @@ export class PluginCommandManager {
 
     private unregistryCommand(pluginInstance: plugin.Plugin) {
         let cmds = getPluginCommandMetadata(pluginInstance)
-        cmds.forEach(cmd => {
-            this.CommandManager.off(pluginInstance, cmd.name)
-        })
+        cmds.forEach(cmd => this.CommandManager.off(pluginInstance, cmd.name))
+    }
+
+    private generateAutoMainCommand(pluginInstance: plugin.Plugin, cmd: interfaces.CommandMetadata, tab: interfaces.CommandMetadata) {
+        let cmdExecutor = pluginInstance[cmd.executor]
+        let cmdCompleter = tab ? pluginInstance[tab.executor] : undefined
+        let cmdSubCache = Object.keys(pluginInstance.constructor.prototype).filter(s => s.startsWith('cmd')).map(s => s.substring(3))
+        if (cmd.autoMain) {
+            cmdExecutor = (sender: any, command: string, args: string[]) => {
+                let subcommand = args[0] || 'help'
+                let cmdKey = 'cmd' + subcommand
+                if (!pluginInstance[cmdKey]) {
+                    console.sender(sender, '§4未知的子命令: §c' + subcommand)
+                    pluginInstance['cmdhelp'] && console.sender(sender, `§6请执行 §b/${command} §ahelp §6查看帮助!`)
+                    return
+                }
+                args.shift()
+                return pluginInstance[cmdKey].apply(pluginInstance, [sender, ...args])
+            }
+            let originCompleter = cmdCompleter
+            cmdCompleter = (sender: any, command: string, args: string[]) => {
+                return (args.length == 1 ? cmdSubCache : []).concat(originCompleter?.apply(pluginInstance, [sender, command, args]) || [])
+            }
+        }
+        if (!cmdCompleter) { console.warn(`[${pluginInstance.description.name}] command ${cmd.name} is not registry tabCompleter`) }
+        return [cmdExecutor, cmdCompleter]
     }
 }

packages/plugin/src/config.ts

@@ -69,7 +69,7 @@ export class PluginConfigManager {
     saveConfig(plugin: plugin.Plugin) {
         let configs = getPluginConfigMetadata(plugin)
         for (let [_, config] of configs) {
-            this.saveConfig0(plugin, config)
+            config.autosave && this.saveConfig0(plugin, config)
         }
     }
 
@@ -102,7 +102,6 @@ export class PluginConfigManager {
 
     private saveConfig0(plugin: plugin.Plugin, metadata: interfaces.ConfigMetadata) {
         try {
-            if (metadata.readonly) { console.debug(`[${plugin.description.name}] Skip Save Config ${metadata.variable} Because it's readonly!`) }
             metadata.file = fs.concat(fs.file(plugin.description.loadMetadata.file).parent, plugin.description.name, metadata.filename)
             let result = this.getConfigLoader(metadata.format).dump(plugin[metadata.variable])
             base.save(metadata.file, result)

packages/plugin/src/decorators.ts

@@ -77,6 +77,7 @@ export function config(metadata: interfaces.ConfigMetadata = {}) {
         metadata.variable = key
         metadata.version = metadata.version ?? 1
         metadata.format = metadata.format ?? 'yml'
+        metadata.autosave = metadata.autosave ?? false
         metadata.filename = metadata.filename ?? metadata.name + '.' + metadata.format
         let previousMetadata = getPluginConfigMetadata(target)
         previousMetadata.set(metadata.name, metadata)

packages/plugin/src/interfaces.ts

@@ -47,6 +47,10 @@ export namespace interfaces {
          * 参数列表
          */
         paramtypes?: string[]
+        /**
+         * 自动化主命令
+         */
+        autoMain?: boolean
     }
     export interface ListenerMetadata extends ExecMetadata {
         /**
@@ -72,9 +76,9 @@ export namespace interfaces {
          */
         format?: string
         /**
-         * 是否为只读(关闭时将不会自动保存)
+         * 自动保存 默认为 false
          */
-        readonly?: boolean
+        autosave?: boolean
         /**
          * 配置文件名称
          */

packages/plugin/src/manager.ts

@@ -1,6 +1,6 @@
 import i18n from '@ccms/i18n'
-import { plugin, server, event } from '@ccms/api'
-import { inject, provideSingleton, Container, ContainerInstance, Autowired } from '@ccms/container'
+import { plugin, server } from '@ccms/api'
+import { provideSingleton, Container, ContainerInstance, Autowired } from '@ccms/container'
 
 import './config'
 import { interfaces } from './interfaces'
@@ -13,15 +13,17 @@ const Thread = Java.type('java.lang.Thread')
 
 @provideSingleton(plugin.PluginManager)
 export class PluginManagerImpl implements plugin.PluginManager {
-    @inject(ContainerInstance)
+    @Autowired(ContainerInstance)
     private container: Container
-    @inject(plugin.PluginInstance)
+    @Autowired(plugin.PluginInstance)
     private pluginInstance: any
-    @inject(server.ServerType)
+    @Autowired(server.ServerType)
     private serverType: string
 
     @Autowired()
     private serverChecker: server.ServerChecker
+    @Autowired()
+    private nativePluginManager: server.NativePluginManager
 
     @Autowired()
     private taskManager: PluginTaskManager
@@ -224,15 +226,32 @@ export class PluginManagerImpl implements plugin.PluginManager {
             try {
                 this.buildPlugin(metadata)
             } catch (error) {
-                console.console(error)
+                console.console(`§4无法加载插件 §b${metadata.name} §4构建插件失败!`)
+                console.ex(error)
             }
         })
     }
 
+    private checkDepends(depends: string | string[]) {
+        if (!depends) return []
+        let loseDepends = []
+        for (const depend of depends) { if (!this.metadataMap.has(depend)) loseDepends.push(depend) }
+        return loseDepends
+    }
+    private checkNativeDepends(depends: string | string[]) {
+        if (!depends) return []
+        let loseDepends = []
+        for (const depend of depends) { if (!this.nativePluginManager.has(depend)) loseDepends.push(depend) }
+        return loseDepends
+    }
     private buildPlugin(metadata: plugin.PluginMetadata) {
-        if (!this.loaderMap.has(metadata.type)) { throw new Error(`§4无法加载插件 §c${metadata.name} §4请检查 §c${metadata.type} §4加载器是否正常启用!`) }
         if (this.instanceMap.has(metadata.name)) { throw new Error(`Plugin ${metadata.name} is already load from ${metadata.source}...`) }
+        if (!this.loaderMap.has(metadata.type)) { throw new Error(`§4无法加载插件 §b${metadata.name} §4请检查 §c${metadata.type} §4加载器是否正常启用!`) }
         if (!this.serverChecker.check(metadata.servers)) { throw new Error(`§6插件 §b${metadata.name} §c服务器类型不兼容(${metadata.servers.join(',')}) §6忽略加载...`) }
+        let loseDepends = this.checkDepends(metadata.depends) || []
+        if (loseDepends.length) { throw new Error(`§4无法加载插件 §b${metadata.name} §4请检查依赖 §3[${loseDepends.join(',')}] §4是否安装完整!`) }
+        let loseNativeDepends = this.checkNativeDepends(metadata.nativeDepends) || []
+        if (loseNativeDepends.length) { throw new Error(`§4无法加载插件 §b${metadata.name} §4请检查插件依赖 §3[${loseNativeDepends.join(',')}] §4是否安装完整!`) }
         let pluginInstance = this.loaderMap.get(metadata.type).build(metadata)
         if (!pluginInstance) { throw new Error(`§4加载器 §c${metadata.type} §4加载插件 §c${metadata.name} §4失败!`) }
         this.instanceMap.set(metadata.name, pluginInstance)

packages/plugin/src/task.ts

@@ -7,7 +7,7 @@ export class PluginTaskManager {
     private taskManager: task.TaskManager
 
     constructor() {
-        process.on('plugin.after.disable', (plugin: plugin.Plugin) => this.cancelTask(plugin))
+        process.on('plugin.after.disable', this.cancelTask.bind(this))
     }
 
     private cancelTask(pluginInstance: plugin.Plugin) {

packages/plugins/docs/MiaoBlockly.md

@@ -0,0 +1,67 @@
+# MiaoBlockly
+
+## 前言
+
+- 嗯 我又来了
+- 之前承诺的 MiaoScript 腐竹可以用的版本
+- 第一个 Demo 版本 MiaoBlockly 写完了
+
+### 什么是 MiaoBlockly
+
+#### ~~对于开发者~~(开发一般不会用这玩意儿)
+
+#### 对于腐竹
+- 可以在网页上开发一些简单的插件
+- 拖动方块就能实现了
+
+### 图片展示
+
+![image.png](https://i.loli.net/2020/10/22/R8nlf9WtVYDXoa3.png)
+
+### MiaoBlockly 的兼容性
+- 跨端兼容 Sponge Bukkit BungeeCord
+  - Bukkit 支持 1.12.2 +(由于1.12.2以下版本Netty版本过老需要适配 后续兼容到1.7.10)
+  - Sponge
+  - CatServer 1.12.2+
+  - BungeeCord
+
+### 安装教程
+- 安装 `MiaoConsole` [站内地址](https://www.mcbbs.net/thread-1129227-1-1.html) 没错 就是装 MiaoConsole
+- 因为 `MiaoBlockly` 底层还是运行的 js 只是用 `Blockly` 生成了代码而已
+- 需要 `MiaoConsole` 是因为需要和服务器通信
+
+### 使用教程
+- 查看启动日志 获取临时 `Token`
+  - 或者 执行 `mconsole token` 获得临时Token
+- 打开 `http://ms.yumc.pw/blockly.html`
+- 在地址栏输入服务器地址 需要带上端口
+- 在 Token 栏输入获取到的 Token
+- 点击链接即可
+
+### 编辑器使用
+- 默认界面有一个插件主体
+- 拖动积木 右侧会自动生成代码
+- 在代码界面 按下 `Ctrl + S` 代码会自动传送到服务器 并且重载插件
+- 更多功能还在开发
+
+### RoadMap
+- 开发聊天相关功能
+- 完善事件相关功能
+- 开发命令相关功能
+- 开发跨服相关功能
+- 统一各个端之间的事件(工作量较大 可能会咕咕咕)
+- 脚本商城 方便开发和腐竹之前的 PY 交易
+- 脚本打包成 Jar 方便部署
+
+### Miao系列插件
+
+- [[经济]MiaoReward —— 喵式奖励 让玩家看广告为服务器提供收入吧[1.7.10+全版本]](https://www.mcbbs.net/thread-1121423-1-1.html)
+- [[编程]MiaoBlockly —— 喵式积木 用简单的积木来写插件吧[1.12.2+全版本]](https://www.mcbbs.net/thread-1129411-1-1.html)
+- [[编程]MiaoConsole —— 喵式终端 通过MC端口直接控制服务器 调试插件[1.12.2+全版本]](https://www.mcbbs.net/thread-1129227-1-1.html)
+- [[管理]MiaoBind —— 喵式绑定 兼容SoulBound的绑定插件 支持自定义关键词[1.7+全版本]](https://www.mcbbs.net/thread-922072-1-1.html)
+- [[信息]MiaoBoard —— 喵式记分板 自定义动态记分板[1.7+全版本]](https://www.mcbbs.net/thread-631482-1-1.html)
+- [[聊天]MiaoChat —— 喵式聊天 多功能自定义聊天格式 新增支持跨服[1.7.10+全版本]](https://www.mcbbs.net/thread-631240-1-1.html)
+- [[菜单]MiaoMenu —— 喵式菜单 强大的自定义菜单 支持多种自定义操作[1.7+全版本]](https://www.mcbbs.net/thread-860047-1-1.html)
+- [[管理]YUM —— 全能的服务器插件管理工具 全自动安装插件 更新插件[1.7.2+全版本]](https://www.mcbbs.net/thread-701333-1-1.html)
+
+本插件所用所有代码均为原创,不存在借用/抄袭等行为

packages/plugins/docs/MiaoConsole.md

@@ -1,12 +1,24 @@
+# MiaoConsole
+
 ## 前言
 
 > 各位开发 在调试Minecraft插件的时候 是不是经常面临下列情况
 - 编译等半天 重启等半天 测试找不到问题
 - 后台 IDE SCP/FTP 来回切换
 
-### 什么是MiaoConsole
-- MiaoConsole 是 基于 MiaoScript 开发的 在线调试工具
-- 通过复用 Minecraft的Netty 通道 实现服务器端口 在线调试(并不是Java的调试哦)
+> 各位腐竹 在开服的时候 是不是经常遇到下列情况
+- 修改一个配置文件 经常格式错误
+- 各种报错看不懂 插件依赖找不到
+
+### 什么是 MiaoConsole
+
+#### 对于开发者
+- MiaoConsole 是 基于 `MiaoScript` 开发的 在线调试工具
+- 通过复用 Minecraft 的 Netty 通道 实现服务器端口 `MiaoScript` 在线调试
+
+#### 对于腐竹
+- 可以在网页上实时看到服务器日志
+- 共享 Token 给插件开发者 让其帮助调试服务器
 
 ### 工具动图
 
@@ -16,8 +28,8 @@
 ### MiaoConsole 有哪些功能
 - 无需编译 上传等步骤 实时在线debug
 - 实时转发服务端日志 无需来回切换
-- 基于Nashorn的动态脚本语言
-- 基于TypeScript的自动补全逻辑(以实现BungeeCord Sponge Bukkit的API全自动补全)
+- 基于 Nashorn 的动态脚本语言
+- 基于 TypeScript 的自动补全逻辑(以实现BungeeCord Sponge Bukkit的API全自动补全)
 
 ### MiaoConsole 的兼容性
 - 跨端兼容 Sponge Bukkit BungeeCord
@@ -27,25 +39,27 @@
   - BungeeCord ~~终端转发暂未兼容~~ 已经能兼容了
 
 ### 安装教程
-- 安装MiaoScript [下载地址](http://w.yumc.pw/free.html#MiaoScript-download)
-- 首次启动 等待加载基础环境类库
-- 执行 `mpm i MiaoConsole`
+- 安装 `MiaoScript` [站内地址](https://www.mcbbs.net/thread-774401-1-1.html)
+  - 如果你已经安装了 Yum 可以通过 Yum 快速安装 `/yum install MiaoScript`
+- 等待 MiaoScript 引擎启动完成(首次启动可能需要10-20秒 依赖于您的网络环境)
+- 执行 `mspm i MiaoConsole`
 
 ### 使用教程
-- 执行 `mconsole token` 获得临时Token
+- 查看启动日志 获取临时 `Token`
+  - 或者 执行 `mconsole token` 获得临时Token
 - 打开 `http://ms.yumc.pw/console.html`
 - 在地址栏输入服务器地址 需要带上端口
-- 在Token栏输入获取到的Token
+- 在 Token 栏输入获取到的 Token
 - 点击链接即可
 
 ### 终端使用
 - 支持实时传输服务器日志到终端
 - 直接在终端输入命令 会转发到服务器
-- 目前暂不支持命令自动补全
+- 支持命令自动补全
 - 支持命令历史
 
 ### 代码编辑器使用
-- 支持 Java 的 lang包和util包自动补全
+- 支持 Java 的类自动补全
 - 支持服务端所有代码补全
 - 注意 暂时不支持自动导入包 所以需要手动输入全类名
 - 快捷键说明(选中代码后 只会执行选中部分)
@@ -53,8 +67,27 @@
   - Ctrl + E 执行命令
   - Ctrl + Q 切换代码页
 
+## 插件源码
+
+- [MiaoScript包管理中心](https://git.yumc.pw/circlecloud/ms/src/branch/master/packages/plugins/src/MiaoConsole.ts)
+
 ### RoadMap
-- 支持命令自动补全
-- 支持常用的开发脚本
-- 支持快捷操作服务器数据
+- 支持 Java 类的自动补全
+- 支持命令自动补全(已完成)
+- 支持常用的开发脚本(开发中)
+- 支持快捷操作服务器数据(开发中)
 - 支持在线编辑服务器文件(开发了一半)
+- 配置文件格式效验(开发中)
+
+### Miao系列插件
+
+- [[经济]MiaoReward —— 喵式奖励 让玩家看广告为服务器提供收入吧[1.7.10+全版本]](https://www.mcbbs.net/thread-1121423-1-1.html)
+- [[编程]MiaoBlockly —— 喵式积木 用简单的积木来写插件吧[1.12.2+全版本]](https://www.mcbbs.net/thread-1129411-1-1.html)
+- [[编程]MiaoConsole —— 喵式终端 通过MC端口直接控制服务器 调试插件[1.12.2+全版本]](https://www.mcbbs.net/thread-1129227-1-1.html)
+- [[管理]MiaoBind —— 喵式绑定 兼容SoulBound的绑定插件 支持自定义关键词[1.7+全版本]](https://www.mcbbs.net/thread-922072-1-1.html)
+- [[信息]MiaoBoard —— 喵式记分板 自定义动态记分板[1.7+全版本]](https://www.mcbbs.net/thread-631482-1-1.html)
+- [[聊天]MiaoChat —— 喵式聊天 多功能自定义聊天格式 新增支持跨服[1.7.10+全版本]](https://www.mcbbs.net/thread-631240-1-1.html)
+- [[菜单]MiaoMenu —— 喵式菜单 强大的自定义菜单 支持多种自定义操作[1.7+全版本]](https://www.mcbbs.net/thread-860047-1-1.html)
+- [[管理]YUM —— 全能的服务器插件管理工具 全自动安装插件 更新插件[1.7.2+全版本]](https://www.mcbbs.net/thread-701333-1-1.html)
+
+本插件所用所有代码均为原创,不存在借用/抄袭等行为

packages/plugins/docs/MiaoPlugin.md

@@ -0,0 +1,24 @@
+### Miao系列插件
+
+- [[经济]MiaoReward —— 喵式奖励 让玩家看广告为服务器提供收入吧[1.7.10+全版本]](https://www.mcbbs.net/thread-1121423-1-1.html)
+- [[编程]MiaoBlockly —— 喵式积木 用简单的积木来写插件吧[1.12.2+全版本]](https://www.mcbbs.net/thread-1129411-1-1.html)
+- [[编程]MiaoConsole —— 喵式终端 通过MC端口直接控制服务器 调试插件[1.12.2+全版本]](https://www.mcbbs.net/thread-1129227-1-1.html)
+- [[管理]MiaoBind —— 喵式绑定 兼容SoulBound的绑定插件 支持自定义关键词[1.7+全版本]](https://www.mcbbs.net/thread-922072-1-1.html)
+- [[信息]MiaoBoard —— 喵式记分板 自定义动态记分板[1.7+全版本]](https://www.mcbbs.net/thread-631482-1-1.html)
+- [[聊天]MiaoChat —— 喵式聊天 多功能自定义聊天格式 新增支持跨服[1.7.10+全版本]](https://www.mcbbs.net/thread-631240-1-1.html)
+- [[菜单]MiaoMenu —— 喵式菜单 强大的自定义菜单 支持多种自定义操作[1.7+全版本]](https://www.mcbbs.net/thread-860047-1-1.html)
+- [[管理]YUM —— 全能的服务器插件管理工具 全自动安装插件 更新插件[1.7.2+全版本]](https://www.mcbbs.net/thread-701333-1-1.html)
+
+[size=20px][b]Miao系列插件[/b][/size]
+
+[size=16px][list]
+[*][url=https://www.mcbbs.net/thread-1121423-1-1.html][经济]MiaoReward —— 喵式奖励 让玩家看广告为服务器提供收入吧[1.7.10+全版本][/url]
+[*][url=https://www.mcbbs.net/thread-1129411-1-1.html][编程]MiaoBlockly —— 喵式积木 用简单的积木来写插件吧[1.12.2+全版本][/url]
+[*][url=https://www.mcbbs.net/thread-1129227-1-1.html][编程]MiaoConsole —— 喵式终端 通过MC端口直接控制服务器 调试插件[1.12.2+全版本][/url]
+[*][url=https://www.mcbbs.net/thread-922072-1-1.html][管理]MiaoBind —— 喵式绑定 兼容SoulBound的绑定插件 支持自定义关键词[1.7+全版本][/url]
+[*][url=https://www.mcbbs.net/thread-631482-1-1.html][信息]MiaoBoard —— 喵式记分板 自定义动态记分板[1.7+全版本][/url]
+[*][url=https://www.mcbbs.net/thread-631240-1-1.html][聊天]MiaoChat —— 喵式聊天 多功能自定义聊天格式 新增支持跨服[1.7.10+全版本][/url]
+[*][url=https://www.mcbbs.net/thread-860047-1-1.html][菜单]MiaoMenu —— 喵式菜单 强大的自定义菜单 支持多种自定义操作[1.7+全版本][/url]
+[*][url=https://www.mcbbs.net/thread-701333-1-1.html][管理]YUM —— 全能的服务器插件管理工具 全自动安装插件 更新插件[1.7.2+全版本][/url][/list][/size]
+
+[size=16px]本插件所用所有代码均为原创,不存在借用/抄袭等行为[/size]

packages/plugins/docs/MiaoReward.md

@@ -6,7 +6,16 @@
 - 快来接入 喵式奖励
 - 通过QQ小程序广告 增加服务器收入
 
+### 先来一张近期的服务器提现订单
+
+![image.png](https://i.loli.net/2020/10/16/LmXAklot43WOy1P.png)
+
 ## 插件展示
+
+> 多图预警 折叠了
+
+`[spoiler]`
+
 - 插件帮助![image.png](https://i.loli.net/2020/09/12/uNbwO2sCVriZzJx.png)
 - 扫码绑定![image.png](https://i.loli.net/2020/09/13/hOtyV8bP9kGeuCD.png)
 - 查看个人信息![image.png](https://i.loli.net/2020/09/12/bTLGjQC7eqxAUSi.png)
@@ -20,6 +29,9 @@
 - 玩家扫码兑换完成![image.png](https://i.loli.net/2020/09/24/JG2SBtgHLzNeaEO.png)
 - 腐竹扫码确认![image.png](https://i.loli.net/2020/09/24/c7sS18KJvQ3MRuZ.png)
 - 腐竹扫码完成![image.png](https://i.loli.net/2020/09/24/RtsoSdV7j6OmE8Q.png)
+
+`[/spoiler]`
+
 ## 插件命令
 ```
 >mrd
@@ -38,6 +50,8 @@
 [17:56:54 INFO]: [MS][MRD] 比如 设置了0.001 那就是 玩家至少 1000喵币 才能兑换!
 ```
 
+## 接下来就是赚钱的操作
+
 ## 插件安装/配置
 
 ### 基础准备工作
@@ -46,23 +60,25 @@
   - 个人中心 => 配置面板 => 圈云盒子客服群
   - 打开群详情 加群
 
-### 接下来就是赚钱的操作
+### 申请账号
+- 打开 [圈云盒子管理后台](https://reward.yumc.pw)
+- 扫码登录 并且加入客服群
+- 创建一个服务器 等待管理员审核通过
+
+`[hide]`
 
 ### 服务器准备工作
-- 打开 [圈云盒子管理后台](https://reward.yumc.pw)
-- 先安装 `MiaoScript` [站内地址](https://www.mcbbs.net/thread-774401-1-1.html)
-  - 可以通过 Yum 快速安装 `/yum install MiaoScript`
+- 安装 `MiaoScript` [站内地址](https://www.mcbbs.net/thread-774401-1-1.html)
+  - 如果你已经安装了 Yum 可以通过 Yum 快速安装 `/yum install MiaoScript`
 - 等待 MiaoScript 引擎启动完成(首次启动可能需要10-20秒 依赖于您的网络环境)
-- 执行 `/mspm install MiaoReward`
+- 执行 `/mspm install MiaoReward` 安装 MiaoReward 脚本插件
+- 完成安装
 
 ### 绑定服务器
-- 由于当前框架存在BUG 请先执行 `/mspm reload MiaoReward` 生成配置文件
 - 执行 `/mrd bind server`
-- 使用QQ扫码
-- 选择需要绑定的服务器
-- 完成绑定
+- 使用QQ扫码 => 选择需要绑定的服务器 => 完成绑定
 - 配置服务器兑换比例
-- 执行 `/mrd ratio 0.001` (最低为 1:0.0001)
+- 执行 `/mrd ratio <兑换比例>` (最低为 1:0.0001)
 - 执行兑换比例确认指令
 - 执行 `/mrd server` 查看服务器信息
 - 如果群组服需要绑定多台服务器(前提是每个服务器都有玩家在)
@@ -118,12 +134,18 @@ prefix: '§6[§b广告系统§6]§r'
 
 ## 插件源码
 
-- [MiaoScript包管理中心](http://ms.yumc.pw/api/plugin/download/name/MiaoReward)
+- [MiaoScript包管理中心](https://git.yumc.pw/circlecloud/ms/src/branch/master/packages/plugins/src/MiaoReward.ts)
+
+`[/hide]`
+
+## 更新日志
+- 2020-10-12 完成提现功能
+- 2020-10-06 使用发包的方式展示地图
 
 ## Roadmap
 - 绑定服务器(已完成)
 - 绑定玩家(已完成)
 - 兑换喵币(已完成)
-- 自助开通服务器(开发中)
-- 自助兑换RMB(开发中)
-- 自助提现(开发中)
+- [自助开通](https://reward.yumc.pw)服务器(已完成)
+- [自助兑换](https://reward.yumc.pw)RMB(已完成)
+- [自助提现](https://reward.yumc.pw)(已完成)

packages/plugins/package.json

@@ -1,7 +1,7 @@
 {
     "private": true,
     "name": "@ccms/plugins",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript plugins package",
     "keywords": [
         "miaoscript",
@@ -20,16 +20,19 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
+        "@javatypes/bukkit-api": "^0.0.3",
+        "@javatypes/bungee-api": "^0.0.3",
+        "@javatypes/sponge-api": "^0.0.3",
         "@javatypes/spring-data-redis": "^0.0.3",
         "@javatypes/spring-web": "^0.0.3",
         "@javatypes/tomcat": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/container": "^0.9.9",
-        "@ccms/plugin": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/container": "^0.12.0",
+        "@ccms/plugin": "^0.12.0"
     }
 }

packages/plugins/src/McbbsPlugin.ts

@@ -0,0 +1,78 @@
+/// <reference types="@javatypes/bungee-api" />
+/// <reference types="@javatypes/bukkit-api" />
+/// <reference types="@javatypes/sponge-api" />
+
+import { plugin, server } from '@ccms/api'
+import { Autowired } from '@ccms/container'
+import { Cmd, interfaces, JSPlugin, Tab } from '@ccms/plugin'
+import { Server as SocketIOServer, Socket as SocketIOSocket, Namespace } from '@ccms/websocket'
+
+import * as fs from '@ccms/common/dist/fs'
+
+const FileFilter = Java.type('java.io.FileFilter')
+const ByteArrayInputStream = java.io.ByteArrayInputStream
+const ByteArrayOutputStream = java.io.ByteArrayOutputStream
+const StandardCharsets = Java.type("java.nio.charset.StandardCharsets")
+const GZIPInputStream = Java.type('java.util.zip.GZIPInputStream')
+const ByteArray = Java.type("byte[]")
+
+@JSPlugin({ version: '1.0.0', author: 'MiaoWoo', source: __filename })
+export class McbbsPlugin extends interfaces.Plugin {
+    @Autowired()
+    private Server: server.Server
+    @Autowired()
+    private pluginManager: plugin.PluginManager
+
+    private namespace: any
+
+    load() {
+    }
+
+    enable() {
+        let consolePlugin: any = this.pluginManager.getPlugin('MiaoConsole')
+        if (consolePlugin.socketIOServer) {
+            this.startWebSocketServer(consolePlugin.socketIOServer)
+        } else {
+            process.on('websocket.create', (server: SocketIOServer) => {
+                this.startWebSocketServer(server)
+            })
+        }
+    }
+
+    private startWebSocketServer(server: SocketIOServer) {
+        this.namespace = server.of('/McbbsPlugin')
+        this.namespace.on('connect', (client: SocketIOSocket) => {
+            this.initWebSocketClient(client)
+            this.logger.console(`§6客户端 §b${client.id} §a新建连接...`)
+        })
+    }
+
+    disable() {
+        this.namespace.close()
+    }
+
+    private initWebSocketClient(client: SocketIOSocket) {
+        client.on('ungzip', (content) => {
+
+        })
+
+        client.on('error', (error) => {
+            this.logger.console(`§6客户端 §b${client.id} §c触发异常: ${error}`)
+            this.logger.error(error)
+        })
+        client.on('disconnect', () => {
+            this.logger.console(`§6客户端 §b${client.id} §c断开连接...`)
+        })
+    }
+
+    @Cmd()
+    msme(sender: any, command: string, args: string[]) {
+        this.logger.log(sender, command, args)
+        sender.sendMessage(JSON.stringify({ command, ...args }))
+    }
+
+    @Tab()
+    tabmsme(_sender: any, _command: string, _args: string[]) {
+        return ['world']
+    }
+}

packages/plugins/src/MiaoConsole.ts

@@ -1,8 +1,8 @@
 /// <reference types="@ccms/nashorn" />
 
 import { plugin as pluginApi, server, task, constants, command } from '@ccms/api'
-import { plugin, interfaces, cmd, tab, enable, config, disable } from '@ccms/plugin'
-import { inject, ContainerInstance, Container } from '@ccms/container'
+import { plugin, interfaces, cmd, tab, enable, config, disable, PluginConfig } from '@ccms/plugin'
+import { ContainerInstance, Container, Autowired } from '@ccms/container'
 import io, { Server as SocketIOServer, Socket as SocketIOSocket } from '@ccms/websocket'
 import * as fs from '@ccms/common/dist/fs'
 import * as reflect from '@ccms/common/dist/reflect'
@@ -19,22 +19,22 @@ let help = [
     '§6/mconsole §areload               §6-  §3重载插件',
 ]
 
-@plugin({ name: 'MiaoConsole', prefix: 'Console', version: '1.0.0', author: 'MiaoWoo', servers: ['!nukkit'], source: __filename })
+@plugin({ prefix: 'Console', version: '1.0.0', author: 'MiaoWoo', servers: ['!nukkit'], source: __filename })
 export class MiaoConsole extends interfaces.Plugin {
-    @inject(ContainerInstance)
+    @Autowired(ContainerInstance)
     private container: Container
-    @inject(server.ServerType)
+    @Autowired(server.ServerType)
     private serverType: string
-    @inject(server.Server)
-    private server: server.Server
-    @inject(command.Command)
-    private command: command.Command
-    @inject(task.TaskManager)
-    private task: task.TaskManager
-    @inject(pluginApi.PluginManager)
-    private pluginManager: pluginApi.PluginManager
-    @inject(pluginApi.PluginFolder)
+    @Autowired(pluginApi.PluginFolder)
     private pluginFolder: string
+    @Autowired()
+    private server: server.Server
+    @Autowired()
+    private command: command.Command
+    @Autowired()
+    private task: task.TaskManager
+    @Autowired()
+    private pluginManager: pluginApi.PluginManager
 
     private token: string
     private instance: any
@@ -46,7 +46,7 @@ export class MiaoConsole extends interfaces.Plugin {
     private logCache: string[] = []
 
     @config()
-    private secret = { token: undefined }
+    private secret: PluginConfig = { token: undefined }
 
     load() {
         if (this.secret.token) {
@@ -90,6 +90,7 @@ export class MiaoConsole extends interfaces.Plugin {
     cmdtoken(sender: any, sub: string, token: string) {
         if (sub == "set") {
             this.secret.token = this.token = token
+            this.secret.save()
             this.logger.sender(sender, '§a已保存§6服务器登录Token:§3', this.token, '§4请勿分享给其他人 防止服务器被攻击!')
             return
         }
@@ -185,8 +186,8 @@ export class MiaoConsole extends interfaces.Plugin {
     @disable({ servers: [constants.ServerType.Bukkit, constants.ServerType.Sponge] })
     removeLog4jForward() {
         try {
-            this.appender.stop()
-            this.rootLogger.removeAppender(this.appender)
+            this.appender?.stop()
+            this.rootLogger?.removeAppender(this.appender)
         } catch (error) {
             console.ex(error)
         }
@@ -195,7 +196,7 @@ export class MiaoConsole extends interfaces.Plugin {
     @disable({ servers: [constants.ServerType.Bungee] })
     removeLoggerForward() {
         try {
-            this.rootLogger.removeHandler(this.handler)
+            this.rootLogger?.removeHandler(this.handler)
         } catch (error) {
             console.ex(error)
         }
@@ -204,7 +205,7 @@ export class MiaoConsole extends interfaces.Plugin {
     @disable({ servers: [constants.ServerType.Spring] })
     removeLogbackForward() {
         try {
-            this.rootLogger.detachAppender(this.LOGBACK_APPENDER_NAME)
+            this.rootLogger?.detachAppender(this.LOGBACK_APPENDER_NAME)
         } catch (error) {
             console.ex(error)
         }
@@ -216,6 +217,7 @@ export class MiaoConsole extends interfaces.Plugin {
             root: fs.concat(root, 'wwwroot')
         })
         this.container.bind(io.Instance).toConstantValue(this.socketIOServer)
+        process.emit('websocket.create', this.socketIOServer)
     }
 
     startSocketIOServer() {
@@ -224,20 +226,19 @@ export class MiaoConsole extends interfaces.Plugin {
         namespace.on('connect', (client: SocketIOSocket) => {
             if (!this.token) {
                 this.logger.console(`§6客户端 §b${client.id} §a请求连接 §4服务器尚未设置 Token 无法连接!`)
-                client.emit('unauthorized')
-                client.disconnect(true)
+                client.emit('unauthorized', () => client.disconnect(true))
                 return
             }
             if (this.token != client.handshake.query.token) {
                 this.logger.console(`§6客户端 §b${client.id} §c无效请求 §4请提供正确Token后再次连接!`)
-                client.emit('unauthorized')
-                client.disconnect(true)
+                client.emit('unauthorized', () => client.disconnect(true))
                 return
             }
             this.initWebSocketClient(client)
             this.logCache.forEach(msg => client.emit('log', msg))
             this.logger.console(`§6客户端 §b${client.id} §a新建连接 ${this.rootLogger ? '启动日志转发' : '§4转发日志启动失败'}...`)
         })
+        process.emit('websocket.start', this.socketIOServer)
     }
 
     private initWebSocketClient(client: SocketIOSocket) {
@@ -280,7 +281,7 @@ export class MiaoConsole extends interfaces.Plugin {
             if (!dir.isDirectory()) {
                 return fn(undefined, `${file} 不是一个目录!`)
             }
-            fn(fs.list(dir))
+            fn(fs.list(dir).map(f => f.name))
         })
         client.on('error', (error) => {
             this.logger.console(`§6客户端 §b${client.id} §c触发异常: ${error}`)

packages/plugins/src/MiaoExplorer.ts

@@ -0,0 +1,175 @@
+/// <reference types="@javatypes/bungee-api" />
+/// <reference types="@javatypes/bukkit-api" />
+/// <reference types="@javatypes/sponge-api" />
+
+import { plugin, server } from '@ccms/api'
+import { Autowired } from '@ccms/container'
+import { Cmd, interfaces, JSPlugin, Tab } from '@ccms/plugin'
+import { Server as SocketIOServer, Socket as SocketIOSocket, Namespace } from '@ccms/websocket'
+
+import * as fs from '@ccms/common/dist/fs'
+
+const FileFilter = Java.type('java.io.FileFilter')
+const ByteArrayInputStream = java.io.ByteArrayInputStream
+const ByteArrayOutputStream = java.io.ByteArrayOutputStream
+const StandardCharsets = Java.type("java.nio.charset.StandardCharsets")
+const GZIPInputStream = Java.type('java.util.zip.GZIPInputStream')
+const ByteArray = Java.type("byte[]")
+
+@JSPlugin({ prefix: 'Explorer', version: '1.0.0', author: 'MiaoWoo', source: __filename })
+export class MiaoExplorer extends interfaces.Plugin {
+    @Autowired()
+    private Server: server.Server
+    @Autowired()
+    private pluginManager: plugin.PluginManager
+
+    private token: string
+    private namespace: any
+    private chunkCacheMap: Map<string, Array<string>>
+
+    load() {
+        this.chunkCacheMap = new Map()
+    }
+
+    enable() {
+        let consolePlugin: any = this.pluginManager.getPlugin('MiaoConsole')
+        if (consolePlugin.socketIOServer) {
+            this.startWebSocketServer(consolePlugin.socketIOServer)
+        } else {
+            process.on('websocket.create', (server: SocketIOServer) => {
+                this.startWebSocketServer(server)
+            })
+        }
+    }
+
+    private startWebSocketServer(server: SocketIOServer) {
+        let consolePlugin: any = this.pluginManager.getPlugin('MiaoConsole')
+        this.token = consolePlugin.token
+        this.namespace = server.of('/MiaoExplorer')
+        this.namespace.on('connect', (client: SocketIOSocket) => {
+            if (!this.token) {
+                this.logger.console(`§6客户端 §b${client.id} §a请求连接 §4服务器尚未设置 Token 无法连接!`)
+                client.emit('unauthorized', () => client.disconnect(true))
+                return
+            }
+            if (this.token != client.handshake.query.token) {
+                this.logger.console(`§6客户端 §b${client.id} §c无效请求 §4请提供正确Token后再次连接!`)
+                client.emit('unauthorized', () => client.disconnect(true))
+                return
+            }
+            this.initWebSocketClient(client)
+            this.logger.console(`§6客户端 §b${client.id} §a新建连接...`)
+        })
+    }
+
+    disable() {
+        this.namespace.removeAllListeners('connect')
+        this.namespace.close()
+    }
+
+    private readDir(dir) {
+        let children = Java.from(dir.listFiles(new FileFilter({
+            accept: file => file.getName().endsWith('.yml') || file.isDirectory()
+        }))).sort().map(file => {
+            if (file.isDirectory()) {
+                let children = this.readDir(file)
+                if (!children.length) { return null }
+                return {
+                    label: file.getName(),
+                    value: fs.path(file),
+                    children,
+                    disabled: true
+                }
+            }
+            return {
+                label: file.getName(),
+                value: fs.path(file),
+                creatable: true,
+                editable: true,
+                removable: true,
+                deleteApi: "delete"
+            }
+        })
+        return children.filter(s => s)
+    }
+
+    private initWebSocketClient(client: SocketIOSocket) {
+        client.on('ls', (fn) => {
+            var pluginDirs = Java.from(fs.file('./plugins').listFiles(new FileFilter({
+                accept: dirs => dirs.isDirectory()
+            })))
+            let result = {
+                options: pluginDirs.sort().map(f => {
+                    let node: any = {
+                        label: f.getName(),
+                        value: fs.path(f)
+                    }
+                    let children = this.readDir(f)
+                    if (!children.length) {
+                        return null
+                    }
+                    node.children = children
+                    node.disabled = true
+                    return node
+                })
+            }
+            fn && fn(result.options.filter(s => s))
+        })
+        client.on('read', (file, callback) => {
+            callback?.(base.read(file))
+        })
+        client.on('chunk', (file, index, content, callback) => {
+            if (!this.chunkCacheMap.has(file)) {
+                this.chunkCacheMap.set(file, [])
+            }
+            this.chunkCacheMap.get(file)[index] = content
+            callback?.(true)
+        })
+        client.on('ungzip', (content) => {
+            try {
+                console.log(content)
+                let baos = new ByteArrayOutputStream()
+                let byte = java.util.Base64.getDecoder().decode(content)
+                let gzip = new GZIPInputStream(new ByteArrayInputStream(byte))
+                let buffer = new ByteArray(1024)
+                let n: number
+                while ((n = gzip.read(buffer)) != -1) {
+                    baos.write(buffer, 0, n)
+                }
+                gzip.close()
+                baos.close()
+                content = baos.toString(StandardCharsets.UTF_8.name())
+                this.logger.log(content)
+            } catch (error) {
+                console.ex(error)
+            }
+        })
+        client.on('save', (file, callback) => {
+            if (!this.chunkCacheMap.has(file)) {
+                return callback?.(false)
+            }
+            let content = this.chunkCacheMap.get(file).join('')
+            this.chunkCacheMap.delete(file)
+            base.save(file, content)
+            callback?.(true)
+        })
+        client.on('error', (error) => {
+            this.logger.console(`§6客户端 §b${client.id} §c触发异常: ${error}`)
+            this.logger.error(error)
+        })
+        client.on('disconnect', () => {
+            this.logger.console(`§6客户端 §b${client.id} §c断开连接...`)
+        })
+    }
+
+    @Cmd()
+    msme(sender: any, command: string, args: string[]) {
+        this.logger.log(sender, command, args)
+        sender.sendMessage(JSON.stringify({ command, ...args }))
+    }
+
+    @Tab()
+    tabmsme(_sender: any, _command: string, _args: string[]) {
+        return ['world']
+    }
+}

packages/plugins/src/MiaoProtocol.ts

@@ -1,18 +1,31 @@
-import { task, server, constants } from "@ccms/api";
-import { inject } from "@ccms/container";
-import { plugin, interfaces, cmd } from "@ccms/plugin";
+import { task, server, constants } from "@ccms/api"
+import { Autowired, JSClass } from "@ccms/container"
+import { plugin, interfaces } from "@ccms/plugin"
 
-import http from '@ccms/common/dist/http'
-import * as fs from '@ccms/common/dist/fs'
+let createPacketAdapterFunction = eval(`
+function(cls, plugin, type, onPacketSending){
+    return new cls(plugin, type) {
+        onPacketSending: onPacketSending
+    }
+}
+`)
 
-@plugin({ name: 'MiaoProtocol', prefix: 'MPTL', version: '1.0.0', author: 'MiaoWoo', servers: [constants.ServerType.Bukkit], source: __filename })
+@plugin({ prefix: 'MPTL', version: '1.0.0', author: 'MiaoWoo', servers: [constants.ServerType.Bukkit], source: __filename })
 export class MiaoProtocol extends interfaces.Plugin {
-    @inject(server.Server)
-    private server: server.Server;
-    @inject(task.TaskManager)
-    private taskManager: task.TaskManager;
+    @Autowired()
+    private server: server.Server
+    @Autowired()
+    private taskManager: task.TaskManager
+
+    @JSClass('com.comphenix.protocol.events.PacketAdapter')
+    private PacketAdapter
+    @JSClass('com.comphenix.protocol.PacketType')
+    private PacketType
+    @JSClass('com.comphenix.protocol.ProtocolLibrary')
+    private ProtocolLibrary
 
     private pipeline: any
+    private adapter: any
 
     enable() {
         let count = 0
@@ -25,6 +38,29 @@ export class MiaoProtocol extends interfaces.Plugin {
                 this.logger.console('§cNetty通道注入失败 §4所有功能将无法使用！')
             }
         }).later(20).timer(40).submit()
+        this.initPacketAdapter()
     }
 
+    disable() {
+        this.ProtocolLibrary.getProtocolManager().removePacketListener(this.adapter)
+    }
+
+    createPacketAdapter(onPacketSending: (event) => void) {
+        return createPacketAdapterFunction(this.PacketAdapter, base.getInstance(), [this.PacketType.Play.Server.MAP], onPacketSending)
+    }
+
+    initPacketAdapter() {
+        this.adapter = this.createPacketAdapter((event) => {
+            let integers = event.getPacket().getIntegers().getValues()
+            //             console.log(`ProtocolLib onPacketSending filter Map
+            // Player: ${event.getPlayer()}
+            // MapId: ${integers.get(0)}
+            // Short: ${event.getPacket().getShorts().read(0)}
+            // Bytes: ${event.getPacket().getByteArrays().read(0).length}
+            // `)
+            //Size: ${integers.get(3)}x${integers.get(4)}
+            // org.bukkit.map.MapPalette.imageToBytes()
+        })
+        this.ProtocolLibrary.getProtocolManager().addPacketListener(this.adapter)
+    }
 }

packages/plugins/src/MiaoReward.ts

@@ -6,48 +6,9 @@ import { QRCode, QRErrorCorrectLevel } from '@ccms/common/dist/qrcode'
 import { Autowired, JSClass, optional } from '@ccms/container'
 import http from '@ccms/common/dist/http'
 
-let MapView
-let Bukkit
-let MapRenderer
-let ItemStack
-let Material
-
-try {
-    MapView = Java.type('org.bukkit.map.MapView')
-    Bukkit = Java.type('org.bukkit.Bukkit')
-    MapRenderer = Java.type('org.bukkit.map.MapRenderer')
-    ItemStack = Java.type('org.bukkit.inventory.ItemStack')
-    Material = Java.type('org.bukkit.Material')
-} catch (error) {
-}
-
 const BufferedImage = Java.type('java.awt.image.BufferedImage')
 const Color = Java.type('java.awt.Color')
-
-class QRCodeRender {
-    private _proxy
-    private image
-    private rendered = false
-    constructor() {
-        const MapRendererAdapter = Java.extend(MapRenderer, {
-            render: (_mapView, mapCanvas, _player) => {
-                if (this.rendered) return
-                if (this.image) {
-                    mapCanvas.drawImage(0, 0, this.image)
-                }
-                this.rendered = true
-            }
-        })
-        this._proxy = new MapRendererAdapter()
-    }
-    setImage(image) {
-        this.image = image
-        this.rendered = false
-    }
-    getHandler() {
-        return this._proxy
-    }
-}
+const Bytes = Java.type('byte[]')
 
 interface PlaceholderAPI {
     registerPlaceholderHook: (key: string, onPlaceholderRequest: (player, s) => string) => void
@@ -62,18 +23,20 @@ interface UserInfo {
     box: string
 }
 
-@JSPlugin({ prefix: 'MRD', version: '1.3.3', author: 'MiaoWoo', servers: [constants.ServerType.Bukkit], source: __filename })
+let createPacketAdapterFunction = eval(`
+function(cls, plugin, type, onPacketSending){
+    return new cls(plugin, type) {
+        onPacketSending: onPacketSending
+    }
+}`)
+
+@JSPlugin({ prefix: 'MRD', version: '1.4.2', author: 'MiaoWoo', servers: [constants.ServerType.Bukkit], source: __filename })
 export class MiaoReward extends interfaces.Plugin {
     private serverInfo: any
     private cacheBindUuid = ''
     private zeroMapView = undefined
-    private zeroMapRender: QRCodeRender = undefined
-    private isBinding = false
-    private bindingUser = 'unknow'
-    private bindingTask = undefined
-    private bindingLeftTime = 45
-    private bindingNotify = new java.util.HashSet<org.bukkit.entity.Player>()
-    private drawCooldown = new Map<string, number>()
+    private playerImageCache = new Map<string, any>()
+    private playerTaskCache = new Map<string, task.Cancelable>()
     private playerInfoCache = new Map<string, UserInfo>()
 
     private downgrade = false
@@ -90,34 +53,55 @@ export class MiaoReward extends interfaces.Plugin {
     private bungee: proxy.BungeeCord
 
     @Config()
-    private config: PluginConfig = {
-        prefix: '§6[§b广告系统§6]§r',
-        serverId: '',
-        serverToken: '',
-        drawCommand: 'p give %player_name% %amount%',
-        drawCooldown: 300
-    }
+    private config: PluginConfig & {
+        prefix: string
+        serverId: string
+        serverToken: string
+        drawCommand: string
+        coinName: string
+    } = {
+            prefix: '§6[§b广告系统§6]§r',
+            serverId: '',
+            serverToken: '',
+            drawCommand: 'p give %player_name% %amount%',
+            coinName: '点券'
+        }
+
+    @JSClass('org.bukkit.Bukkit')
+    private Bukkit: any
 
     @JSClass('me.clip.placeholderapi.PlaceholderAPI')
     private PlaceholderAPI: PlaceholderAPI
     @JSClass('me.clip.placeholderapi.PlaceholderHook')
     private PlaceholderHook: any
 
+    @JSClass('com.comphenix.protocol.ProtocolLibrary')
+    private ProtocolLibrary: any
+    @JSClass('com.comphenix.protocol.PacketType')
+    private PacketType: any
+    @JSClass('com.comphenix.protocol.events.PacketAdapter')
+    private PacketAdapter: any
+
+    private adapter: any
+    private itemStackArrayLength: number
+
     private isBungeeCord = undefined
     private channelOff: { off: () => void }
 
     load() {
         this.config.prefix = this.config.prefix || '§6[§b广告系统§6]§r'
         this.config.drawCommand = this.config.drawCommand || 'p give %player_name% %amount%'
-        this.config.drawCooldown = this.config.drawCooldown || 300
+        if (!this.config.coinName) {
+            this.config.coinName = '点券'
+            this.config.save()
+        }
         //@ts-ignore
         this.logger.prefix = this.config.prefix
-        this.downgrade = Bukkit.getServer().class.name.split('.')[3] == "v1_7_R4"
-        this.updateServerInfo()
-        this.updateOnlinePlayersInfo()
+        this.downgrade = this.Bukkit.server.class.name.split('.')[3] == "v1_7_R4"
+        this.updateServerInfo(null, () => this.updateOnlinePlayersInfo())
     }
 
-    private updateServerInfo(player?: any) {
+    private updateServerInfo(player?: any, cb?: () => void) {
         this.taskManager.create(() => {
             if (this.config.serverId) {
                 let result = this.httpPost(`https://reward.yumc.pw/server/server`, {
@@ -127,6 +111,7 @@ export class MiaoReward extends interfaces.Plugin {
                 if (result.code == 200) {
                     this.serverInfo = result.data
                     if (player) this.bungee.for(player).forward("ALL", "MiaoReward", { type: "updateServerInfo", data: result.data }).send()
+                    cb?.()
                 }
             }
         }).async().submit()
@@ -203,16 +188,67 @@ export class MiaoReward extends interfaces.Plugin {
 
     private initZeroMap() {
         this.taskManager.create(() => {
-            this.zeroMapRender = new QRCodeRender()
-            this.zeroMapView = Bukkit.getMap(0) || Bukkit.createMap(Bukkit.getWorlds()[0])
-            this.zeroMapView.setScale(MapView.Scale.FARTHEST)
-            this.zeroMapView.getRenderers().forEach(r => this.zeroMapView.removeRenderer(r))
-            this.zeroMapView.addRenderer(this.zeroMapRender.getHandler())
+            this.zeroMapView = this.Bukkit.getMap(0) || this.Bukkit.createMap(this.Bukkit.getWorlds()[0])
+            this.zeroMapView.setScale(org.bukkit.map.MapView.Scale.FARTHEST)
+            this.zeroMapView.getRenderers().clear()
         }).submit()
+        var minecraftVersion = this.ProtocolLibrary.getProtocolManager().getMinecraftVersion()
+        this.itemStackArrayLength = minecraftVersion.getMinor() < 9 ? 45 : 46
+        this.initPacketAdapter()
+    }
+
+    createPacketAdapter(onPacketSending: (event) => void) {
+        return createPacketAdapterFunction(this.PacketAdapter, base.getInstance(), [this.PacketType.Play.Server.MAP], onPacketSending)
+    }
+
+    initPacketAdapter() {
+        this.adapter = this.createPacketAdapter((event) => {
+            let integers = event.getPacket().getIntegers().getValues()
+            let mapId = integers.get(0)
+            let player = event.getPlayer()
+            if (mapId == this.zeroMapView.getId() && this.playerImageCache.has(player.getName())) {
+                let bytes = this.playerImageCache.get(player.getName())
+                if (!this.downgrade) {
+                    event.getPacket().getByteArrays().write(0, bytes)
+                    event.getPacket().getIntegers().write(3, 128)
+                    event.getPacket().getIntegers().write(4, 128)
+                } else {
+                    // let xbytes = new Bytes(131)
+                    let origin = event.getPacket().getByteArrays().read(0)
+                    // xbytes[1] = origin[1]
+                    // xbytes[2] = origin[2]
+                    for (let y = 0; y < 128; ++y) {
+                        origin[y + 3] = bytes[y * 128 + origin[1]]
+                    }
+                    event.getPacket().getByteArrays().write(0, origin)
+                }
+            }
+        })
+        this.ProtocolLibrary.getProtocolManager().addPacketListener(this.adapter)
+    }
+
+    private sendWindowItems(player: org.bukkit.entity.Player, mapItem: any) {
+        var protocolManager = this.ProtocolLibrary.getProtocolManager()
+        try {
+            let ItemStackArray = Java.type('org.bukkit.inventory.ItemStack[]')
+            let arritemStack = new ItemStackArray(this.itemStackArrayLength)
+            java.util.Arrays.fill(arritemStack, new org.bukkit.inventory.ItemStack(org.bukkit.Material.AIR))
+            arritemStack[36 + player.getInventory().getHeldItemSlot()] = mapItem
+            var packetContainer = protocolManager.createPacket(this.PacketType.Play.Server.WINDOW_ITEMS)
+            if (packetContainer.getItemArrayModifier().size() > 0) {
+                packetContainer.getItemArrayModifier().write(0, arritemStack)
+            } else {
+                packetContainer.getItemListModifier().write(0, java.util.Arrays.asList(arritemStack))
+            }
+            protocolManager.sendServerPacket(player, packetContainer)
+        } catch (ex) {
+            console.ex(ex)
+        }
     }
 
     disable() {
-        this.PlaceholderAPI.unregisterPlaceholderHook("mrd")
+        this.PlaceholderAPI?.unregisterPlaceholderHook("mrd")
+        this.adapter && this.ProtocolLibrary.getProtocolManager().removePacketListener(this.adapter)
         Java.from(this.server.getOnlinePlayers()).forEach(p => this.checkAndClear(p))
         this.channelOff?.off()
     }
@@ -276,42 +312,28 @@ export class MiaoReward extends interfaces.Plugin {
         }
     }
 
-    private bindCheck(sender: org.bukkit.entity.Player, cooldown: number) {
-        if (this.isBinding) {
-            let bindUser = Bukkit.getPlayerExact(this.bindingUser)
-            if (bindUser && bindUser.isOnline() && this.isHoldQrCodeItem(bindUser)) {
-                this.bindingNotify.add(sender)
-                this.logger.sender(sender, [
-                    "§c当前 §a" + this.bindingUser + " §c玩家正在扫码",
-                    "§6请等待 §e" + this.bindingLeftTime + "秒 §6后重试...",
-                    "§a玩家操作完成后将会通知您继续操作..."
-                ])
-                return true
-            }
+    private bindCheck(sender: org.bukkit.entity.Player) {
+        let scanning = this.playerTaskCache.has(sender.getName())
+        if (scanning) {
+            this.logger.sender(sender, "§4当前正在进行扫码 请稍候重试!")
         }
-        if (this.drawCooldown.has(sender.getName()) && !sender.hasPermission('mrd.admin')) {
-            let leftTime = cooldown - (Date.now() - this.drawCooldown.get(sender.getName())) / 1000
-            if (leftTime > 0) {
-                this.logger.sender(sender, `§c扫码功能冷却中 剩余 ${leftTime} 秒!`)
-                return true
-            }
-        }
-        this.drawCooldown.set(sender.getName(), Date.now())
-        this.isBinding = true
-        this.bindingUser = sender.getName()
-        this.bindingNotify.clear()
-        return false
+        return scanning
+    }
+
+    cmdopen(sender: org.bukkit.entity.Player) {
+        if (this.bindCheck(sender)) return
+        this.logger.sender(sender, '§a正在获取小程序二维码...')
+        let sync = { scaned: false }
+        this.setItemAndTp(sender, 'https://m.q.qq.com/a/p/1110360279?s=' + encodeURIComponent(`pages/my/index`), sync)
+        this.taskManager.create(() => sync.scaned = true).later(20 * 50).submit()
     }
 
     cmdbind(sender: org.bukkit.entity.Player, server: boolean) {
-        if (this.bindCheck(sender, 60)) return
         if (!sender.getItemInHand) { return this.logger.sender(sender, '§c手持物品检测异常 请检查是否在客户端执行命令!') }
-        if (sender.getItemInHand()?.getType() !== Material.AIR) { return this.logger.sender(sender, "§c请空手执行此命令!") }
+        if (this.bindCheck(sender)) return
         if (server) {
-            if (!sender.isOp()) { return this.logger.sender(sender, '§4您没有配置服务器的权限!') }
             this.bindServer(sender)
         } else {
-            if (!this.serverInfo) { return this.logger.sender(sender, '§4当前服务器尚未配置绑定ID 请联系腐竹进行配置!') }
             this.bindUser(sender)
         }
     }
@@ -326,7 +348,7 @@ export class MiaoReward extends interfaces.Plugin {
         if (amount % 100 !== 0) {
             return this.logger.sender(sender, '§4金额必须是100倍数!')
         }
-        if (this.bindCheck(sender, this.config.drawCooldown)) { return }
+        if (this.bindCheck(sender)) { return }
         this.scanAuth(sender,
             'draw', {
             title: '兑换授权',
@@ -363,11 +385,11 @@ export class MiaoReward extends interfaces.Plugin {
         this.taskManager.create(() => {
             let command = this.config.drawCommand.replace('%player_name%', sender.getName()).replace('%amount%', draw.data)
             if (!this.server.dispatchConsoleCommand(command)) {
-                return this.sendError(sender, ...draw.msg.split('\n'), `§6执行结果: §4已扣除 §c${amount} §4喵币`, `§6执行命令: §3/${command} §c可能存在异常`)
+                return this.sendError(sender, ...draw.msg.split('\n').map(s => s.replace('点券', this.config.coinName)), `§6执行结果: §4已扣除 §c${amount} §4喵币`, `§6执行命令: §3/${command} §c可能存在异常`)
             }
-            this.logger.sender(sender, draw.msg.split('\n'))
-            this.sendBroadcast(sender, `${this.config.prefix}§6玩家 §b${sender.getName()} §6成功将 §a${amount}喵币 §6兑换成 §c${draw.data}点券!`)
-            this.sendBroadcast(sender, `${this.config.prefix}§c/mrd help §b查看广告系统帮助 §6快来一起看广告赚点券吧!`)
+            this.logger.sender(sender, draw.msg.split('\n').map(s => s.replace('点券', this.config.coinName)))
+            this.sendBroadcast(sender, `${this.config.prefix}§6玩家 §b${sender.getName()} §6成功将 §a${amount}喵币 §6兑换成 §c${draw.data}${this.config.coinName}!`)
+            this.sendBroadcast(sender, `${this.config.prefix}§c/mrd help §b查看广告系统帮助 §6快来一起看广告赚${this.config.coinName}吧!`)
         }).submit()
     }
 
@@ -429,14 +451,13 @@ export class MiaoReward extends interfaces.Plugin {
         let [ratio, mbr, msg] = this.ratio2string(ratioStr)
         if (!confirm) {
             return this.logger.sender(sender, [
-                '§4警告: 您正在设置服务器喵币/点券兑换比例 设置后将实时生效!',
+                `§4警告: 您正在设置服务器喵币/${this.config.coinName}兑换比例 设置后将实时生效!`,
                 `§6您设置的兑换比例为 ` + msg,
-                `§6玩家至少需要 §a${mbr}喵币 §6才可以兑换点券!`,
+                `§6玩家至少需要 §a${mbr}喵币 §6才可以兑换${this.config.coinName}!`,
                 `§6请执行 §b/mrd ratio §c${ratio} §econfirm §c确认修改!`
             ])
         }
         if (confirm != 'confirm') return this.logger.sender(sender, `§6请执行 §b/mrd ratio §c${ratio} §econfirm §c确认修改!`)
-        if (this.bindCheck(sender, 60)) return
         this.scanAuth(sender, "ratio", {
             title: `是否授权 ${this.serverInfo.name} 调整兑换比例`,
             content: [
@@ -470,10 +491,10 @@ export class MiaoReward extends interfaces.Plugin {
     private ratio2string(ratio) {
         ratio = parseFloat(ratio)
         if (ratio > 1) {
-            return [ratio, 1, `§c${ratio} §6就是 §a1喵币 §6=> §c${ratio}点券!`]
+            return [ratio, 1, `§c${ratio} §6就是 §a1喵币 §6=> §c${ratio}${this.config.coinName}!`]
         }
         let mbr = Math.round(1 / ratio * 10000) / 10000
-        return [ratio, mbr, `§c${ratio} §6就是 §a${mbr}喵币 §6=> §c1点券!`]
+        return [ratio, mbr, `§c${ratio} §6就是 §a${mbr}喵币 §6=> §c1${this.config.coinName}!`]
     }
 
     private sendBroadcast(player, message) {
@@ -482,6 +503,7 @@ export class MiaoReward extends interfaces.Plugin {
     }
 
     private bindServer(sender: org.bukkit.entity.Player) {
+        if (!sender.isOp()) { return this.logger.sender(sender, '§4您没有配置服务器的权限!') }
         this.logger.sender(sender, '§a正在请求二维码 请稍候...')
         let scanObj = http.get(`https://reward.yumc.pw/server/scan`)
         if (scanObj.code !== 200) {
@@ -508,8 +530,7 @@ export class MiaoReward extends interfaces.Plugin {
     }
 
     private bindUser(sender: org.bukkit.entity.Player) {
-        if (!this.config.serverId || !this.config.serverToken) { return this.logger.sender(sender, '§4当前服务器尚未配置绑定ID 请联系腐竹进行配置!') }
-        this.logger.sender(sender, '§a正在请求二维码 请稍候...')
+        if (!this.serverInfo) { return this.logger.sender(sender, '§4当前服务器尚未配置绑定ID 请联系腐竹进行配置!') }
         let check = this.httpPost(`https://reward.yumc.pw/server/query`, {
             id: this.config.serverId,
             token: this.config.serverToken
@@ -519,8 +540,10 @@ export class MiaoReward extends interfaces.Plugin {
         }
         let queryUser = this.queryUser(sender)
         if (queryUser.code == 200) {
-            return this.logger.sender(sender, ['§4当前用户已绑定! §c如需解绑 请联系腐竹!', '§b如需看广告请进QQ群 §a点击聊天框上的圈云盒子!'])
+            this.logger.sender(sender, ['§a当前用户已绑定! §3如需看广告请扫码进入!'])
+            return this.cmdopen(sender)
         }
+        this.logger.sender(sender, '§a正在请求二维码 请稍候...')
         let bindUrl = 'https://m.q.qq.com/a/p/1110360279?s=' + encodeURIComponent(`pages/my/index?bindType=user&serverId=${this.config.serverId}&uuid=${sender.getUniqueId().toString()}&username=${sender.getName()}`)
         let sync = { scaned: false, timeout: false }
         this.taskManager.create(() => {
@@ -550,45 +573,50 @@ export class MiaoReward extends interfaces.Plugin {
 
     private setItemAndTp(sender: org.bukkit.entity.Player, content: string, sync: { scaned: boolean }) {
         this.taskManager.create(() => {
-            this.bindingLeftTime = 30
-            this.bindingTask = this.taskManager.create(() => {
+            let bindingLeftTime = 55
+            let task = this.taskManager.create(() => {
                 try {
-                    if (sync.scaned || !sender.isOnline() || !this.isHoldQrCodeItem(sender) || --this.bindingLeftTime < 0) {
-                        if (this.bindingLeftTime < 0) {
+                    if (sync.scaned || !sender.isOnline() || !this.isHoldQrCodeItem(sender) || --bindingLeftTime < 0) {
+                        if (bindingLeftTime < 0) {
                             this.logger.sender(sender, '§c二维码已过期 请重新获取 如已扫码请忽略!')
+                            task.cancel()
                         }
                         this.cancelTask(sender)
                         return
                     }
-                    this.sendActionBar(sender, `§c§l手机QQ扫描二维码 剩余 ${this.bindingLeftTime} 秒...`)
+                    this.sendActionBar(sender, `§c§l手机QQ扫描二维码 剩余 ${bindingLeftTime} 秒...`)
                 } catch (error) {
                     console.ex(error)
                 }
-            }).async().later(20).timer(20).submit()
-            sender.setItemInHand(this.createQrCodeMapItem(content))
+            }, this).async().later(20).timer(20).submit()
+            this.playerTaskCache.set(sender.getName(), task)
             if (this.downgrade) {
-                this.logger.sender(sender, '§c低版本客户端 二维码渲染中 请等待 6 秒 稍候扫码!')
+                this.logger.sender(sender, '§c低版本客户端 二维码渲染中 请等待 3 秒 稍候扫码!')
                 let waitTask = this.taskManager.create(() => {
                     let temp = sender.getLocation()
                     temp.setPitch(-90)
                     sender.teleport(temp)
-                }).later(20).timer(20).submit()
+                }, this).later(0).timer(20).submit()
                 this.taskManager.create(() => {
                     waitTask.cancel()
                     let temp = sender.getLocation()
                     temp.setPitch(90)
                     sender.teleport(temp)
-                }).later(150).submit()
-            } else {
+                }).later(80).submit()
+            }
+            this.playerImageCache.set(sender.getName(), org.bukkit.map.MapPalette.imageToBytes(this.createQrcode(content)))
+            if (!this.downgrade) {
                 let temp = sender.getLocation()
                 temp.setPitch(90)
                 sender.teleport(temp)
             }
+            this.sendWindowItems(sender, this.createQrCodeMapItem())
+            sender.sendMap(this.zeroMapView)
         }).submit()
     }
 
     private queryUser(sender: org.bukkit.entity.Player, sync = false) {
-        if (!this.config.serverId || !this.config.serverToken) { return this.logger.sender(sender, '§4当前服务器尚未配置绑定ID 请联系腐竹进行配置!') }
+        if (!this.serverInfo) { return this.logger.sender(sender, '§4当前服务器尚未配置绑定ID 请联系腐竹进行配置!') }
         let result = this.httpPost(`https://reward.yumc.pw/server/queryUser`, {
             id: this.config.serverId,
             token: this.config.serverToken,
@@ -636,9 +664,9 @@ CAST TIME   : ${Date.now() - startTime}`)
         return result
     }
 
-    private createQrCodeMapItem(content: string) {
+    private createQrCodeMapItem() {
         let item: org.bukkit.inventory.ItemStack
-        item = new ItemStack(Material.FILLED_MAP || Material.MAP)
+        item = new org.bukkit.inventory.ItemStack(org.bukkit.Material.FILLED_MAP || org.bukkit.Material.MAP)
         let meta = <org.bukkit.inventory.meta.MapMeta>item.getItemMeta()
         if (meta.setMapView) {
             meta.setMapView(this.zeroMapView)
@@ -650,7 +678,6 @@ CAST TIME   : ${Date.now() - startTime}`)
         meta.setDisplayName('§c请使用手机QQ扫描二维码!')
         meta.setLore(["QRCODE"])
         item.setItemMeta(meta)
-        this.zeroMapRender.setImage(this.createQrcode(content))
         return item
     }
 
@@ -691,30 +718,19 @@ CAST TIME   : ${Date.now() - startTime}`)
         const player = event.getPlayer()
         this.bungeeCordDetect(player)
         this.updatePlayerInfo(player)
+        this.taskManager.create(() => this.logger.sender(player, `§a本服已使用喵式奖励 §3可以看广告赚${this.config.coinName} §c/mrd help §b查看帮助!`)).later(50).submit()
     }
 
     @Listener()
     PlayerDropItemEvent(event: org.bukkit.event.player.PlayerDropItemEvent) {
-        if (this.isQrCodeItem(event.getItemDrop().getItemStack())) {
-            event.getItemDrop().remove()
+        if (this.checkAndClear(event.getPlayer())) {
+            event.setCancelled(true)
         }
     }
 
     @Listener()
     PlayerItemHeldEvent(event: org.bukkit.event.player.PlayerItemHeldEvent) {
-        let inv = event.getPlayer().getInventory()
-        if (this.isQrCodeItem(inv.getItem(event.getPreviousSlot() as any))) {
-            inv.setItem(event.getPreviousSlot(), null)
-        }
-    }
-
-    @Listener()
-    InventoryClickEvent(event: org.bukkit.event.inventory.InventoryClickEvent) {
-        let item = event.getCurrentItem()
-        if (this.isQrCodeItem(item)) {
-            event.getInventory().setItem(event.getSlot(), null)
-            event.setCancelled(true)
-        }
+        this.checkAndClear(event.getPlayer())
     }
 
     @Listener()
@@ -723,36 +739,23 @@ CAST TIME   : ${Date.now() - startTime}`)
     }
 
     private cancelTask(player) {
-        if (!this.isBinding) return
-        this.isBinding = false
-        this.bindingTask.cancel()
-        this.bindingTask = undefined
-        this.bindingUser = 'unknow'
+        if (!this.playerTaskCache.has(player.getName())) { return }
         this.checkAndClear(player)
         this.sendActionBar(player, "")
-        this.zeroMapRender.setImage(undefined)
-        //@ts-ignore
-        this.bindingNotify.forEach(p => {
-            if (p.isOnline()) {
-                this.logger.sender(p, `§6用户 §a${player.getName()} §6扫码已完成 §a您可以继续操作!`)
-            }
-        })
+        player.updateInventory()
+        this.playerTaskCache.get(player.getName()).cancel()
+        this.playerTaskCache.delete(player.getName())
+        this.playerImageCache.delete(player.getName())
     }
 
     private isHoldQrCodeItem(player: org.bukkit.entity.Player) {
-        return this.isQrCodeItem(player.getItemInHand())
+        return this.playerImageCache.has(player.getName())
     }
 
     private checkAndClear(player: org.bukkit.entity.Player) {
         if (this.isHoldQrCodeItem(player)) {
-            player.setItemInHand(null)
-        }
-    }
-
-    private isQrCodeItem(item: org.bukkit.inventory.ItemStack): boolean {
-        if (!item || item.getType() == Material.AIR) { return false }
-        if ((item.getType() == Material.MAP || item.getType() == Material.FILLED_MAP) && item.hasItemMeta()) {
-            return Java.from(item.getItemMeta().getLore()).indexOf('QRCODE') != -1
+            this.playerImageCache.delete(player.getName())
+            return true
         }
         return false
     }
@@ -761,19 +764,20 @@ CAST TIME   : ${Date.now() - startTime}`)
         let help = [
             `§6====== ${this.config.prefix} §a帮助菜单 §6======`,
             `§6/mrd bind §a绑定圈云盒子`,
+            `§6/mrd open §a打开圈云盒子`,
             `§6/mrd query §a查询当前账户`,
-            `§6/mrd draw §e<兑换数量> §a兑换点券`
+            `§6/mrd draw §e<兑换数量> §a兑换${this.config.coinName}`
         ]
         if (sender.isOp()) {
             help = help.concat([
                 `§c由于您是管理员 以为您展示额外命令`,
                 `§6/mrd bind server §a绑定服务器`,
-                `§6/mrd ratio §e<兑换比例> §a设置喵币/点券兑换比例`,
+                `§6/mrd ratio §e<兑换比例> §a设置喵币/${this.config.coinName}兑换比例`,
                 `§6/mrd statistic §3近期收入统计`,
                 `§6/mrd rank <boardcast>(是否公告) §2今日兑换排行`,
                 `§6/mrd server §c当前服务器信息`,
-                `§6兑换比例设置说明: §b默认比例为 0.001 §6=> §a1000喵币 §6兑换 §c1点券`,
-                `§c注意 设置比例后 玩家兑换点券数量不能少于 1点券`,
+                `§6兑换比例设置说明: §b默认比例为 0.001 §6=> §a1000喵币 §6兑换 §c1${this.config.coinName}`,
+                `§c注意 设置比例后 玩家兑换${this.config.coinName}数量不能少于 1${this.config.coinName}`,
                 `§c比如 设置了0.001 那就是 玩家至少 1000喵币 才能兑换!`
             ])
         }

packages/plugins/src/MiaoScriptPackageManager.ts

@@ -51,6 +51,7 @@ let langMap = {
     'install.finish': '§6插件 §b{name} §6版本 §3{version} §a安装成功!',
     'update.finish': '§6插件 §b{name} §6版本 §3{version} §a更新成功!',
     'upgrade.confirm': '§6您正在尝试更新 §bMiaoScript §c核心 §6请执行 §b/mpm §aupgrade §cconfirm §6确认执行!',
+    'upgrade.start': '§6开始§a更新 §bMiaoScript §6核心 §c正在清理 node_modules 请稍候...',
     'upgrade.failed': '§6尝试热更新 §bMiaoScript §c核心 §4失败! §6请重启服务器完成更新...',
     'deploy.token.not.exists': '§4请先配置发布Token!',
     'deploy.success': '§6插件 §b{name} §6版本 §3{version} §a发布成功! §6服务器返回: §a{msg}',
@@ -104,7 +105,7 @@ class SpongeFakeSender extends FakeSender {
     }
 }
 
-@JSPlugin({ prefix: 'PM', version: '1.3.0', author: 'MiaoWoo', source: __filename })
+@JSPlugin({ prefix: 'PM', version: '1.3.1', author: 'MiaoWoo', source: __filename })
 export class MiaoScriptPackageManager extends interfaces.Plugin {
     @Autowired()
     private pluginManager: pluginApi.PluginManager
@@ -326,6 +327,7 @@ export class MiaoScriptPackageManager extends interfaces.Plugin {
             let enginePath = fs.path(fs.file(root, 'node_modules'))
             if (enginePath.startsWith(root)) {
                 try {
+                    this.i18n(sender, 'upgrade.start')
                     base.delete(enginePath)
                     this.cmdrestart(sender)
                 } catch (ex) {
@@ -381,20 +383,22 @@ export class MiaoScriptPackageManager extends interfaces.Plugin {
     }
 
     cmdrestart(sender: any) {
-        if (this.serverType === "sponge") {
-            setTimeout(() => this.server.dispatchConsoleCommand('sponge plugins reload'), 0)
-            return
-        }
-        try {
-            this.logger.sender(sender, '§6Reloading §3MiaoScript Engine...')
-            ScriptEngineContextHolder.disableEngine()
-            Packages.java.lang.System.gc()
-            ScriptEngineContextHolder.enableEngine()
-            this.logger.sender(sender, '§3MiaoScript Engine §6Reload §aSuccessful...')
-        } catch (ex) {
-            this.logger.sender(sender, "§3MiaoScript Engine §6Reload §cError! ERR: " + ex)
-            this.logger.sender(sender, this.logger.stack(ex))
-        }
+        setTimeout(() => {
+            if (this.serverType === "sponge") {
+                this.server.dispatchConsoleCommand('sponge plugins reload')
+                return
+            }
+            try {
+                this.logger.sender(sender, '§6Reloading §3MiaoScript Engine...')
+                ScriptEngineContextHolder.disableEngine()
+                Packages.java.lang.System.gc()
+                ScriptEngineContextHolder.enableEngine()
+                this.logger.sender(sender, '§3MiaoScript Engine §6Reload §aSuccessful...')
+            } catch (ex) {
+                this.logger.sender(sender, "§3MiaoScript Engine §6Reload §cError! ERR: " + ex)
+                this.logger.sender(sender, this.logger.stack(ex))
+            }
+        }, 0)
     }
 
     cmdrun(sender: any, ...args: any[]) {

packages/plugins/src/MiaoSpring.ts

@@ -94,7 +94,7 @@ export class MiaoSpring extends interfaces.Plugin {
             preHandle: (ctx: Context) => {
                 const index = foundMap.indexOf(ctx.request.getRequestURI())
                 if (index != -1) {
-                    return this.ResponseEntity.status(this.HttpStatus.FOUND).header('Location', foundMap[index + 1]).build()
+                    return this.ResponseEntity.status(org.springframework.http.HttpStatus.FOUND).header('Location', foundMap[index + 1]).build()
                 }
             }
         })

packages/protocol/.npmignore

@@ -0,0 +1 @@
+../../.npmignore

packages/protocol/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@ccms/protocol",
+    "version": "0.12.0",
+    "description": "MiaoScript protocol package",
+    "keywords": [
+        "miaoscript",
+        "minecraft",
+        "bukkit",
+        "sponge"
+    ],
+    "author": "MiaoWoo <admin@yumc.pw>",
+    "homepage": "https://github.com/circlecloud/ms.git",
+    "license": "ISC",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "clean": "rimraf dist",
+        "watch": "tsc --watch",
+        "build": "yarn clean && tsc",
+        "test": "echo \"Error: run tests from root\" && exit 1"
+    },
+    "devDependencies": {
+        "reflect-metadata": "^0.1.13",
+        "rimraf": "^3.0.2",
+        "typescript": "^4.0.5"
+    }
+}

packages/protocol/src/index.ts

@@ -0,0 +1 @@
+export { }

packages/protocol/tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "baseUrl": "src",
+        "outDir": "dist"
+    }
+}

packages/sponge/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/sponge",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript api package",
     "keywords": [
         "miaoscript",
@@ -22,11 +22,11 @@
         "@javatypes/sponge-api": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/common": "^0.9.8",
-        "@ccms/container": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/common": "^0.12.0",
+        "@ccms/container": "^0.12.0"
     }
 }

packages/sponge/src/index.ts

@@ -8,9 +8,12 @@ import './chat'
 import './task'
 import './event'
 import './server'
+import { SpongeNativePluginManager } from './plugin'
 import './command'
 import './channel'
+import './particle'
 
 export default function SpongeImpl(container: Container) {
     container.bind(server.Console).toConstantValue(SpongeConsole)
+    container.rebind(server.NativePluginManager).toConstantValue(new SpongeNativePluginManager())
 }

packages/sponge/src/particle.ts

@@ -0,0 +1,32 @@
+import { provideSingleton } from '@ccms/container'
+import { particle, plugin } from '@ccms/api'
+
+@provideSingleton(particle.ParticleManager)
+export class SpongeParticleManager extends particle.ParticleManager {
+    private globalSpawner = new SpongeParticleSpawner()
+    constructor() {
+        super()
+        particle.ParticleManager.globalSpawner = this.globalSpawner
+    }
+    protected getGlobalSpawner() {
+        return this.globalSpawner
+    }
+}
+export class SpongeParticleSpawner extends particle.ParticleSpawner {
+    spawnParticle(location: org.spongepowered.api.world.Location<any>, particle: any, count: number = 1) {
+        location.getPosition()
+        // location.getWorld().spawnParticle(particle, location, count)
+    }
+    spawn(location: any, particle: particle.Particle) {
+        location.getWorld().spawnParticle(
+            particle.getParticle(),
+            location,
+            particle.getCount(),
+            particle.getOffsetX(),
+            particle.getOffsetY(),
+            particle.getOffsetZ(),
+            particle.getExtra(),
+            particle.getData()
+        )
+    }
+}

packages/sponge/src/plugin.ts

@@ -0,0 +1,12 @@
+import { server } from '@ccms/api'
+
+const Sponge = org.spongepowered.api.Sponge
+
+export class SpongeNativePluginManager extends server.NativePluginManager {
+    has(name: string) {
+        return !!this.get(name)
+    }
+    get(name: string) {
+        return Sponge.getPluginManager().getPlugin(name).orElse(null)
+    }
+}

packages/sponge/src/server.ts

@@ -4,7 +4,6 @@ import { provideSingleton } from '@ccms/container'
 import * as reflect from '@ccms/common/dist/reflect'
 
 const Sponge = org.spongepowered.api.Sponge
-const TextSerializers = org.spongepowered.api.text.serializer.TextSerializers
 const File = Java.type("java.io.File")
 
 @provideSingleton(server.Server)
@@ -35,10 +34,10 @@ export class SpongeServer extends server.ReflectServer {
         if (typeof sender === 'string') {
             sender = this.getPlayer(sender)
         }
-        return Sponge.getCommandManager().process(sender, command).getSuccessCount().get() != 0
+        return Sponge.getCommandManager().process(sender, command).getSuccessCount().orElse(0) != 0
     }
     dispatchConsoleCommand(command: string): boolean {
-        return Sponge.getCommandManager().process(Sponge.getServer().getConsole(), command).getSuccessCount().get() != 0
+        return Sponge.getCommandManager().process(Sponge.getServer().getConsole(), command).getSuccessCount().orElse(0) != 0
     }
     getPluginsFolder(): string {
         return this.pluginsFolder

packages/sponge/src/task.ts

@@ -9,24 +9,21 @@ const TimeUnit = Java.type('java.util.concurrent.TimeUnit')
 
 @provideSingleton(task.TaskManager)
 export class SpongeTaskManager extends task.TaskManager {
-    @inject(plugin.PluginInstance)
-    private pluginInstance: any
     private syncExecutor: any
 
     @postConstruct()
     initialize() {
-        this.syncExecutor = Sponge.getScheduler().createSyncExecutor(this.pluginInstance)
+        this.syncExecutor = Sponge.getScheduler().createSyncExecutor(base.getInstance())
     }
 
-    create0(func: Function): task.Task {
-        return new SpongeTask(this.pluginInstance, func)
+    create0(owner: plugin.Plugin, func: Function, id: number): task.Task {
+        return new SpongeTask(owner, func, id)
     }
     callSyncMethod(func: Function): any {
-        // @ts-ignore
-        return this.syncExecutor.schedule(new Callable({ call: () => func() }), java.lang.Long.valueOf(0), TimeUnit.NANOSECONDS).get()
+        return this.syncExecutor.execute(() => func())
     }
     disable0() {
-        Sponge.getScheduler().getScheduledTasks(this.pluginInstance).forEach((task: task.Cancelable) => task.cancel())
+        Sponge.getScheduler().getScheduledTasks(base.getInstance()).forEach((task: task.Cancelable) => task.cancel())
     }
 }
 
@@ -36,6 +33,6 @@ export class SpongeTask extends task.Task {
         if (this.isAsync) { run.async() }
         if (this.laterTime) { run.delayTicks(this.laterTime) }
         if (this.interval) { run.intervalTicks(this.interval) }
-        return run.submit(this.plugin)
+        return run.submit(base.getInstance())
     }
 }

packages/spring/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/spring",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript spring package",
     "keywords": [
         "miaoscript",
@@ -21,12 +21,12 @@
     "devDependencies": {
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/common": "^0.9.8",
-        "@ccms/container": "^0.9.9",
-        "@ccms/database": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/common": "^0.12.0",
+        "@ccms/container": "^0.12.0",
+        "@ccms/database": "^0.12.0"
     }
 }

packages/spring/src/server.ts

@@ -1,31 +1,32 @@
-import { server } from '@ccms/api'
-import { provideSingleton, inject } from '@ccms/container'
-import { NativePluginManager } from '@ccms/api'
+import { constants, server } from '@ccms/api'
+import { provideSingleton, postConstruct, Autowired, Container, ContainerInstance } from '@ccms/container'
 import { CommandMap } from './internal/command'
 
 @provideSingleton(server.Server)
-export class SpringServer implements server.Server {
-    @inject(CommandMap)
+export class SpringServer extends server.Server {
+    @Autowired(ContainerInstance)
+    private container: Container
+    @Autowired()
     private commandMap: CommandMap
 
+    private nettyPipeline = base.getInstance().getAutowireCapableBeanFactory()
+    private rootLogger = Packages.org.slf4j.LoggerFactory.getLogger("root") || global.logger
+
+    @postConstruct()
+    initialize() {
+        this.container.bind(constants.ServiceIdentifier.NettyPipeline).toConstantValue(this.nettyPipeline)
+        this.container.bind(constants.ServiceIdentifier.RootLogger).toConstantValue(this.rootLogger)
+    }
+
     getVersion(): string {
         return "SpringFramework"
     }
-    getPlayer(name: string) {
-        throw new Error("Method not implemented.")
-    }
-    getOnlinePlayers(): any[] {
-        throw new Error("Method not implemented.")
-    }
     getConsoleSender() {
         return {
             name: 'CONSOLE',
             sendMessage: (message: string) => console.console(message)
         }
     }
-    getService(service: string) {
-        throw new Error("Method not implemented.")
-    }
     dispatchCommand(sender: any, command: string): boolean {
         let cmd_args = command.split(" ")
         return this.commandMap.dispatch(sender, cmd_args.shift(), cmd_args || [])
@@ -33,16 +34,10 @@ export class SpringServer implements server.Server {
     dispatchConsoleCommand(command: string): boolean {
         return this.dispatchCommand(this.getConsoleSender(), command)
     }
-    getPluginsFolder(): string {
-        throw new Error("Method not implemented.")
-    }
-    getNativePluginManager(): NativePluginManager {
-        throw new Error("Method not implemented.")
-    }
     getNettyPipeline() {
-        return base.getInstance().getAutowireCapableBeanFactory()
+        return this.nettyPipeline
     }
     getRootLogger() {
-        return Packages.org.slf4j.LoggerFactory.getLogger("root") || global.logger
+        return this.rootLogger
     }
 }

packages/spring/src/task.ts

@@ -2,7 +2,6 @@ import { task, plugin } from '@ccms/api'
 import { inject, provideSingleton } from '@ccms/container'
 import thread_pool from '@ccms/common/dist/thread-pool'
 
-const AtomicInteger = Java.type("java.util.concurrent.atomic.AtomicInteger")
 const AtomicBoolean = Java.type("java.util.concurrent.atomic.AtomicBoolean")
 const Thread = Java.type('java.lang.Thread')
 
@@ -11,21 +10,19 @@ export class SpringTaskManager extends task.TaskManager {
     @inject(plugin.PluginInstance)
     private pluginInstance: any
 
-    private taskId: any
     private tasks: { [s: string]: task.Cancelable }
     private executor: java.util.concurrent.ThreadPoolExecutor
 
     constructor() {
         super()
-        this.taskId = new AtomicInteger(0)
         this.tasks = {}
         this.executor = thread_pool.create({
             groupName: '@ccms/spring'
         })
     }
 
-    create0(func: Function): task.Task {
-        return new SpringTask(this.pluginInstance, func, this)
+    create0(owner: plugin.Plugin, func: Function, id: number): task.Task {
+        return new SpringTask(owner, func, id, this)
     }
     callSyncMethod(func: Function): any {
         return func()
@@ -51,8 +48,8 @@ export class SpringTask extends task.Task {
     private taskManager: SpringTaskManager
     private running = new AtomicBoolean(true)
 
-    constructor(plugin: any, func: Function, taskManager: SpringTaskManager) {
-        super(plugin, func)
+    constructor(owner: plugin.Plugin, func: Function, id: number, taskManager: SpringTaskManager) {
+        super(owner, func, id)
         this.id = taskManager.nextId()
         this.taskManager = taskManager
     }
@@ -83,19 +80,16 @@ export class SpringTask extends task.Task {
         this.cancel()
     }
 
-    cancel0(): any {
+    cancel0() {
         var wasRunning = this.running.getAndSet(false)
         if (wasRunning) {
             this.taskManager.cancel(this.id)
+            return true
         }
+        return false
     }
 
     submit0(...args: any[]) {
         this.taskManager.submit(this.id, this, () => this.run(...args))
-        return {
-            cancel: () => {
-                return this.cancel0()
-            }
-        }
     }
 }

packages/web/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/web",
-    "version": "0.9.9",
+    "version": "0.12.0",
     "description": "MiaoScript web package",
     "keywords": [
         "miaoscript",
@@ -26,10 +26,10 @@
         "@javatypes/tomcat": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     },
     "dependencies": {
-        "@ccms/api": "^0.9.9",
-        "@ccms/container": "^0.9.9"
+        "@ccms/api": "^0.12.0",
+        "@ccms/container": "^0.12.0"
     }
 }

packages/websocket/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ccms/websocket",
-    "version": "0.9.8",
+    "version": "0.12.0",
     "description": "MiaoScript websocket package",
     "keywords": [
         "miaoscript",
@@ -19,10 +19,10 @@
         "test": "echo \"Error: run tests from root\" && exit 1"
     },
     "devDependencies": {
-        "@ccms/nashorn": "^0.9.8",
+        "@ccms/nashorn": "^0.12.0",
         "@javatypes/tomcat-websocket-api": "^0.0.3",
         "reflect-metadata": "^0.1.13",
         "rimraf": "^3.0.2",
-        "typescript": "^4.0.3"
+        "typescript": "^4.0.5"
     }
 }

packages/websocket/src/index.ts

@@ -4,43 +4,43 @@
 import { Server, ServerOptions } from './socket-io'
 
 interface SocketIOStatic {
-	/**
-	 * Default Server constructor
-	 */
-	(): Server
+    /**
+     * Default Server constructor
+     */
+    (): Server
 
-	/**
-	 * Creates a new Server
-	 * @param srv The HTTP server that we're going to bind to
-	 * @param opts An optional parameters object
-	 */
-	(srv: any, opts?: ServerOptions): Server
+    /**
+     * Creates a new Server
+     * @param srv The HTTP server that we're going to bind to
+     * @param opts An optional parameters object
+     */
+    (srv: any, opts?: Partial<ServerOptions>): Server
 
-	/**
-	 * Creates a new Server
-	 * @param port A port to bind to, as a number, or a string
-	 * @param An optional parameters object
-	 */
-	(port: string | number, opts?: ServerOptions): Server
+    /**
+     * Creates a new Server
+     * @param port A port to bind to, as a number, or a string
+     * @param An optional parameters object
+     */
+    (port: string | number, opts?: Partial<ServerOptions>): Server
 
-	/**
-	 * Creates a new Server
-	 * @param A parameters object
-	 */
-	(opts: ServerOptions): Server
+    /**
+     * Creates a new Server
+     * @param A parameters object
+     */
+    (opts: Partial<ServerOptions>): Server
 
-	/**
-	 * Backwards compatibility
-	 * @see io().listen()
-	 */
-	listen?: SocketIOStatic
+    /**
+     * Backwards compatibility
+     * @see io().listen()
+     */
+    listen?: SocketIOStatic
 }
 
 type SocketStatic = SocketIOStatic & { Instance?: symbol }
 
 // @ts-ignore
-let io: SocketStatic = function (pipeline: any, options: ServerOptions) {
-	return new Server(pipeline, options)
+let io: SocketStatic = function (pipeline: any, options: Partial<ServerOptions>) {
+    return new Server(pipeline, options)
 }
 io.Instance = Symbol("@ccms/websocket")
 export default io

packages/websocket/src/netty/adapter/httprequest.ts

@@ -0,0 +1,20 @@
+const TypeParameterMatcher = Java.type('io.netty.util.internal.TypeParameterMatcher')
+const SimpleChannelInboundHandler = Java.type('io.netty.channel.SimpleChannelInboundHandler')
+const FullHttpRequestMatcher = TypeParameterMatcher.get(base.getClass('io.netty.handler.codec.http.FullHttpRequest'))
+
+export abstract class HttpRequestHandlerAdapter {
+    private _Handler;
+    constructor() {
+        let HttpRequestHandlerAdapterImpl = Java.extend(SimpleChannelInboundHandler, {
+            acceptInboundMessage: (msg: any) => {
+                return FullHttpRequestMatcher.match(msg)
+            },
+            channelRead0: this.channelRead0.bind(this)
+        })
+        this._Handler = new HttpRequestHandlerAdapterImpl();
+    }
+    abstract channelRead0(ctx: any, request: any);
+    getHandler() {
+        return this._Handler;
+    }
+}

packages/websocket/src/netty/adapter/index.ts

@@ -0,0 +1,3 @@
+export * from './text_websocket_frame'
+export * from './websocket'
+export * from './httprequest'

packages/websocket/src/netty/adapter/text_websocket_frame.ts

@@ -0,0 +1,24 @@
+const TypeParameterMatcher = Java.type('io.netty.util.internal.TypeParameterMatcher')
+const TextWebSocketFrameMatcher = TypeParameterMatcher.get(base.getClass('io.netty.handler.codec.http.websocketx.TextWebSocketFrame'))
+const SimpleChannelInboundHandler = Java.type('io.netty.channel.SimpleChannelInboundHandler')
+
+export abstract class TextWebSocketFrameHandlerAdapter {
+    private _Handler
+    constructor() {
+        let TextWebSocketFrameHandlerAdapterImpl = Java.extend(SimpleChannelInboundHandler, {
+            userEventTriggered: this.userEventTriggered.bind(this),
+            acceptInboundMessage: (msg: any) => {
+                return TextWebSocketFrameMatcher.match(msg)
+            },
+            channelRead0: this.channelRead0.bind(this),
+            exceptionCaught: this.exceptionCaught.bind(this)
+        })
+        this._Handler = new TextWebSocketFrameHandlerAdapterImpl()
+    }
+    abstract userEventTriggered(ctx: any, evt: any)
+    abstract channelRead0(ctx: any, msg: any)
+    abstract exceptionCaught(ctx: any, cause: Error)
+    getHandler() {
+        return this._Handler
+    }
+}

packages/websocket/src/netty/adapter/websocket.ts

@@ -1,17 +1,25 @@
 const ChannelInboundHandlerAdapter = Java.type('io.netty.channel.ChannelInboundHandlerAdapter')
 
 export abstract class WebSocketHandlerAdapter {
-    private _Handler;
+    private _Handler
     constructor() {
         let ChannelInboundHandlerAdapterImpl = Java.extend(ChannelInboundHandlerAdapter, {
             channelRead: this.channelRead.bind(this),
+            channelInactive: this.channelInactive.bind(this),
+            channelUnregistered: this.exceptionCaught.bind(this),
             exceptionCaught: this.exceptionCaught.bind(this)
         })
         this._Handler = new ChannelInboundHandlerAdapterImpl()
     }
-    abstract channelRead(ctx: any, channel: any);
-    abstract exceptionCaught(ctx: any, cause: Error);
+    abstract channelRead(ctx: any, channel: any)
+    channelInactive(ctx: any) {
+        ctx.fireChannelInactive()
+    }
+    channelUnregistered(ctx: any) {
+        ctx.fireChannelUnregistered()
+    }
+    abstract exceptionCaught(ctx: any, cause: Error)
     getHandler() {
-        return this._Handler;
+        return this._Handler
     }
 }

packages/websocket/src/netty/client.ts

@@ -0,0 +1,24 @@
+import { Transport } from '../transport'
+import { AttributeKeys } from './constants'
+
+const TextWebSocketFrame = Java.type('io.netty.handler.codec.http.websocketx.TextWebSocketFrame')
+
+export class NettyClient extends Transport {
+    private channel: any
+
+    constructor(server: any, channel: any) {
+        super(server)
+        this.remoteAddress = channel.remoteAddress() + ''
+        this.request = channel.attr(AttributeKeys.Request).get()
+
+        this._id = channel.id() + ''
+        this.channel = channel
+    }
+
+    doSend(text: string) {
+        this.channel.writeAndFlush(new TextWebSocketFrame(text))
+    }
+    doClose() {
+        this.channel.close()
+    }
+}

packages/websocket/src/netty/httprequest.ts

@@ -1,20 +1,61 @@
-const TypeParameterMatcher = Java.type('io.netty.util.internal.TypeParameterMatcher')
-const SimpleChannelInboundHandler = Java.type('io.netty.channel.SimpleChannelInboundHandler')
-const FullHttpRequestMatcher = TypeParameterMatcher.get(base.getClass('io.netty.handler.codec.http.FullHttpRequest'))
+import { HttpRequestHandlerAdapter } from './adapter'
+import { AttributeKeys } from './constants'
+import { ServerOptions } from 'socket-io'
 
-export abstract class HttpRequestHandlerAdapter {
-    private _Handler;
-    constructor() {
-        let HttpRequestHandlerAdapterImpl = Java.extend(SimpleChannelInboundHandler, {
-            acceptInboundMessage: (msg: any) => {
-                return FullHttpRequestMatcher.match(msg)
-            },
-            channelRead0: this.channelRead0.bind(this)
-        })
-        this._Handler = new HttpRequestHandlerAdapterImpl();
+const DefaultHttpResponse = Java.type('io.netty.handler.codec.http.DefaultHttpResponse')
+const DefaultFullHttpResponse = Java.type('io.netty.handler.codec.http.DefaultFullHttpResponse')
+const HttpHeaders = Java.type('io.netty.handler.codec.http.HttpHeaders')
+const HttpVersion = Java.type('io.netty.handler.codec.http.HttpVersion')
+const HttpResponseStatus = Java.type('io.netty.handler.codec.http.HttpResponseStatus')
+const LastHttpContent = Java.type('io.netty.handler.codec.http.LastHttpContent')
+
+const File = Java.type('java.io.File')
+const Runnable = Java.type('java.lang.Runnable')
+const RandomAccessFile = Java.type('java.io.RandomAccessFile')
+const DefaultFileRegion = Java.type('io.netty.channel.DefaultFileRegion')
+const ChannelFutureListener = Java.type('io.netty.channel.ChannelFutureListener')
+
+export class HttpRequestHandler extends HttpRequestHandlerAdapter {
+    private ws: string
+    private root: string
+    constructor(options: ServerOptions) {
+        super()
+        this.root = options.root
+        this.ws = options.path
     }
-    abstract channelRead0(ctx: any, request: any);
-    getHandler() {
-        return this._Handler;
+    channelRead0(ctx: any, request: any) {
+        if (request.getUri().startsWith(this.ws)) {
+            ctx.channel().attr(AttributeKeys.Request).set(request)
+            ctx.fireChannelRead(request.retain())
+        } else {
+            ctx.executor().execute(new Runnable({
+                run: () => {
+                    if (HttpHeaders.is100ContinueExpected(request)) {
+                        ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE))
+                    }
+                    let filename = request.getUri().split('?')[0].substr(1)
+                    let file = new File(this.root, filename || 'index.html')
+                    if (!file.exists() || !file.isFile()) {
+                        ctx.write(new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.NOT_FOUND))
+                        ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT).addListener(ChannelFutureListener.CLOSE)
+                        return
+                    }
+                    let response = new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.OK)
+                    response.headers().set(HttpHeaders.Names.CONTENT_TYPE, "text/html charset=UTF-8")
+                    let raf = new RandomAccessFile(file, 'r')
+                    let keepAlive = HttpHeaders.isKeepAlive(request)
+                    if (keepAlive) {
+                        response.headers().set(HttpHeaders.Names.CONTENT_LENGTH, file.length())
+                        response.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE)
+                    }
+                    ctx.write(response)
+                    ctx.write(new DefaultFileRegion(raf.getChannel(), 0, raf.length()))
+                    let future = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
+                    if (!keepAlive) {
+                        future.addListener(ChannelFutureListener.CLOSE)
+                    }
+                }
+            }))
+        }
     }
 }

packages/websocket/src/netty/index.ts

@@ -1,3 +1,70 @@
-export * from './text_websocket_frame'
-export * from './websocket'
-export * from './httprequest'
+import { EventEmitter } from 'events'
+
+import { ServerOptions } from '../socket-io'
+import { ServerEvent } from '../socket-io/constants'
+
+import { NettyClient } from './client'
+import { Keys } from './constants'
+import { WebSocketDetect } from './websocket_detect'
+import { WebSocketHandler } from './websocket_handler'
+
+class NettyWebSocketServer extends EventEmitter {
+    private pipeline: any
+    private clients: Map<string, NettyClient>
+
+    constructor(pipeline: any, options: ServerOptions) {
+        super()
+        this.clients = new Map()
+        this.pipeline = pipeline
+        let connectEvent = options.event
+        try { this.pipeline.remove(Keys.Detect) } catch (error) { }
+        this.pipeline.addFirst(Keys.Detect, new WebSocketDetect(connectEvent).getHandler())
+        connectEvent.on(ServerEvent.detect, (ctx, channel) => {
+            channel.pipeline().addFirst(Keys.Handler, new WebSocketHandler(options).getHandler())
+            ctx.fireChannelRead(channel)
+        })
+        connectEvent.on(ServerEvent.connect, (ctx) => {
+            let cid = ctx?.channel().id() + ''
+            let nettyClient = new NettyClient(this, ctx.channel())
+            this.clients.set(cid, nettyClient)
+            this.emit(ServerEvent.connect, nettyClient)
+        })
+        connectEvent.on(ServerEvent.message, (ctx, msg) => {
+            let cid = ctx?.channel().id() + ''
+            if (this.clients.has(cid)) {
+                this.emit(ServerEvent.message, this.clients.get(cid), msg.text())
+            } else {
+                console.error(`unknow client ${ctx} reciver message ${msg.text()}`)
+            }
+        })
+        connectEvent.on(ServerEvent.disconnect, (ctx, cause) => {
+            let cid = ctx?.channel().id() + ''
+            if (this.clients.has(cid)) {
+                this.emit(ServerEvent.disconnect, this.clients.get(cid), cause)
+            } else {
+                console.error(`unknow client ${ctx} disconnect cause ${cause}`)
+            }
+        })
+        connectEvent.on(ServerEvent.error, (ctx, cause) => {
+            let cid = ctx?.channel().id() + ''
+            if (this.clients.has(cid)) {
+                this.emit(ServerEvent.error, this.clients.get(cid), cause)
+            } else {
+                console.error(`unknow client ${ctx} cause error ${cause}`)
+                console.ex(cause)
+            }
+        })
+    }
+    close() {
+        if (this.pipeline.names().contains(Keys.Detect)) {
+            this.pipeline.remove(Keys.Detect)
+        }
+        this.clients.forEach(client => client.close())
+    }
+}
+
+export {
+    NettyWebSocketServer,
+    ServerEvent,
+    NettyClient
+}

packages/websocket/src/netty/text_websocket_frame.ts

@@ -1,24 +1,23 @@
-const TypeParameterMatcher = Java.type('io.netty.util.internal.TypeParameterMatcher')
-const TextWebSocketFrameMatcher = TypeParameterMatcher.get(base.getClass('io.netty.handler.codec.http.websocketx.TextWebSocketFrame'))
-const SimpleChannelInboundHandler = Java.type('io.netty.channel.SimpleChannelInboundHandler')
+import { EventEmitter } from 'events'
+import { ServerOptions } from '../socket-io'
+import { ServerEvent } from '../socket-io/constants'
+import { TextWebSocketFrameHandlerAdapter } from './adapter'
 
-export abstract class TextWebSocketFrameHandlerAdapter {
-    private _Handler;
-    constructor() {
-        let TextWebSocketFrameHandlerAdapterImpl = Java.extend(SimpleChannelInboundHandler, {
-            userEventTriggered: this.userEventTriggered.bind(this),
-            acceptInboundMessage: (msg: any) => {
-                return TextWebSocketFrameMatcher.match(msg)
-            },
-            channelRead0: this.channelRead0.bind(this),
-            exceptionCaught: this.exceptionCaught.bind(this)
-        })
-        this._Handler = new TextWebSocketFrameHandlerAdapterImpl();
+export class TextWebSocketFrameHandler extends TextWebSocketFrameHandlerAdapter {
+    private event: EventEmitter
+    constructor(options: ServerOptions) {
+        super()
+        this.event = options.event
     }
-    abstract userEventTriggered(ctx: any, evt: any);
-    abstract channelRead0(ctx: any, msg: any);
-    abstract exceptionCaught(ctx: any, cause: Error);
-    getHandler() {
-        return this._Handler;
+    userEventTriggered(ctx: any, evt: any) {
+        if (evt == 'HANDSHAKE_COMPLETE') {
+            this.event.emit(ServerEvent.connect, ctx)
+        }
+    }
+    channelRead0(ctx: any, msg: any) {
+        this.event.emit(ServerEvent.message, ctx, msg)
+    }
+    exceptionCaught(ctx: any, cause: Error) {
+        this.event.emit(ServerEvent.error, ctx, cause)
     }
 }

packages/websocket/src/netty/websocket_detect.ts

@@ -1,17 +1,17 @@
 import { EventEmitter } from 'events'
-import { WebSocketHandlerAdapter } from "../netty"
+import { WebSocketHandlerAdapter } from "./adapter"
 import { ServerEvent } from '../socket-io/constants'
 
 export class WebSocketDetect extends WebSocketHandlerAdapter {
-    private event: EventEmitter;
+    private event: EventEmitter
     constructor(event: EventEmitter) {
         super()
-        this.event = event;
+        this.event = event
     }
     channelRead(ctx: any, channel: any) {
-        this.event.emit(ServerEvent.detect, ctx, channel);
+        this.event.emit(ServerEvent.detect, ctx, channel)
     }
     exceptionCaught(ctx: any, cause: Error) {
-        this.event.emit(ServerEvent.error, ctx, cause);
+        this.event.emit(ServerEvent.error, ctx, cause)
     }
 }

packages/websocket/src/netty/websocket_handler.ts

@@ -3,7 +3,7 @@ import { ServerEvent } from '../socket-io/constants'
 
 import { Keys } from './constants'
 import { HttpRequestHandler } from './httprequest'
-import { WebSocketHandlerAdapter } from "../netty"
+import { WebSocketHandlerAdapter } from "./adapter"
 import { TextWebSocketFrameHandler } from './text_websocket_frame'
 
 const CharsetUtil = Java.type('io.netty.util.CharsetUtil')
@@ -13,10 +13,10 @@ const HttpObjectAggregator = Java.type('io.netty.handler.codec.http.HttpObjectAg
 const WebSocketServerProtocolHandler = Java.type('io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler')
 
 export class WebSocketHandler extends WebSocketHandlerAdapter {
-    private options: ServerOptions;
+    private options: ServerOptions
     constructor(options: ServerOptions) {
         super()
-        this.options = options;
+        this.options = options
     }
     channelRead(ctx: any, msg: any) {
         msg.markReaderIndex()
@@ -32,6 +32,7 @@ export class WebSocketHandler extends WebSocketHandlerAdapter {
             pipeline.addLast('chunk', new ChunkedWriteHandler())
             pipeline.addLast('httpobj', new HttpObjectAggregator(64 * 1024))
             pipeline.addLast('http_request', new HttpRequestHandler(this.options).getHandler())
+            // this.options.path, null, false, 655360, false, true, false, 10000
             pipeline.addLast('websocket', new WebSocketServerProtocolHandler(this.options.path, true))
             pipeline.addLast('websocket_handler', new TextWebSocketFrameHandler(this.options).getHandler())
         }
@@ -39,6 +40,19 @@ export class WebSocketHandler extends WebSocketHandlerAdapter {
         msg.resetReaderIndex()
         ctx.fireChannelRead(msg)
     }
+
+    channelInactive(ctx: any) {
+        console.debug('WebSocketHandler channelInactive ' + ctx)
+        this.options.event.emit(ServerEvent.disconnect, ctx, 'netty channelInactive')
+        super.channelInactive(ctx)
+    }
+
+    channelUnregistered(ctx: any) {
+        console.debug('WebSocketHandler channelUnregistered ' + ctx)
+        this.options.event.emit(ServerEvent.disconnect, ctx, 'netty channelUnregistered')
+        super.channelUnregistered(ctx)
+    }
+
     exceptionCaught(ctx: any, cause: Error) {
         this.options.event.emit(ServerEvent.error, ctx, cause)
     }

packages/websocket/src/server/client.ts

@@ -1,40 +0,0 @@
-import { EventEmitter } from 'events'
-import { SocketIO } from '../socket-io/interfaces';
-import { AttributeKeys } from './constants';
-
-const TextWebSocketFrame = Java.type('io.netty.handler.codec.http.websocketx.TextWebSocketFrame')
-
-export class NettyClient extends EventEmitter implements SocketIO.EngineSocket {
-    private _id: string;
-    private channel: any
-
-    server: any;
-    readyState: string;
-    remoteAddress: string;
-    upgraded: boolean;
-    request: any;
-    transport: any;
-
-    constructor(server: any, channel: any) {
-        super();
-        this.server = server;
-        this.readyState = 'open';
-        this.remoteAddress = channel.remoteAddress() + ''
-        this.upgraded = true;
-        this.request = channel.attr(AttributeKeys.Request).get();
-        this.transport = null;
-
-        this.channel = channel;
-        this._id = channel.id();
-    }
-
-    get id() {
-        return this._id;
-    }
-    send(text: string) {
-        this.channel.writeAndFlush(new TextWebSocketFrame(text))
-    }
-    close() {
-        this.channel.close();
-    }
-}

packages/websocket/src/server/httprequest.ts

@@ -1,61 +0,0 @@
-import { HttpRequestHandlerAdapter } from '../netty'
-import { AttributeKeys } from './constants'
-import { ServerOptions } from 'socket-io'
-
-const DefaultHttpResponse = Java.type('io.netty.handler.codec.http.DefaultHttpResponse')
-const DefaultFullHttpResponse = Java.type('io.netty.handler.codec.http.DefaultFullHttpResponse')
-const HttpHeaders = Java.type('io.netty.handler.codec.http.HttpHeaders')
-const HttpVersion = Java.type('io.netty.handler.codec.http.HttpVersion')
-const HttpResponseStatus = Java.type('io.netty.handler.codec.http.HttpResponseStatus')
-const LastHttpContent = Java.type('io.netty.handler.codec.http.LastHttpContent')
-
-const File = Java.type('java.io.File')
-const Runnable = Java.type('java.lang.Runnable')
-const RandomAccessFile = Java.type('java.io.RandomAccessFile')
-const DefaultFileRegion = Java.type('io.netty.channel.DefaultFileRegion')
-const ChannelFutureListener = Java.type('io.netty.channel.ChannelFutureListener')
-
-export class HttpRequestHandler extends HttpRequestHandlerAdapter {
-    private ws: string;
-    private root: string;
-    constructor(options: ServerOptions) {
-        super()
-        this.root = options.root;
-        this.ws = options.path;
-    }
-    channelRead0(ctx: any, request: any) {
-        if (request.getUri().startsWith(this.ws)) {
-            ctx.channel().attr(AttributeKeys.Request).set(request);
-            ctx.fireChannelRead(request.retain())
-        } else {
-            ctx.executor().execute(new Runnable({
-                run: () => {
-                    if (HttpHeaders.is100ContinueExpected(request)) {
-                        ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE))
-                    }
-                    let filename = request.getUri().split('?')[0].substr(1)
-                    let file = new File(this.root, filename || 'index.html')
-                    if (!file.exists() || !file.isFile()) {
-                        ctx.write(new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.NOT_FOUND))
-                        ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT).addListener(ChannelFutureListener.CLOSE)
-                        return
-                    }
-                    let response = new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.OK)
-                    response.headers().set(HttpHeaders.Names.CONTENT_TYPE, "text/html charset=UTF-8")
-                    let raf = new RandomAccessFile(file, 'r')
-                    let keepAlive = HttpHeaders.isKeepAlive(request)
-                    if (keepAlive) {
-                        response.headers().set(HttpHeaders.Names.CONTENT_LENGTH, file.length())
-                        response.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE)
-                    }
-                    ctx.write(response)
-                    ctx.write(new DefaultFileRegion(raf.getChannel(), 0, raf.length()))
-                    let future = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
-                    if (!keepAlive) {
-                        future.addListener(ChannelFutureListener.CLOSE)
-                    }
-                }
-            }))
-        }
-    }
-}

packages/websocket/src/server/index.ts

@@ -1,50 +0,0 @@
-import { EventEmitter } from 'events'
-
-import { ServerOptions } from '../socket-io'
-import { ServerEvent } from '../socket-io/constants'
-
-import { NettyClient } from './client'
-import { Keys } from './constants'
-import { WebSocketDetect } from './websocket_detect'
-import { WebSocketHandler } from './websocket_handler'
-
-class NettyWebSocketServer extends EventEmitter {
-    private pipeline: any;
-    private allClients: { [key: string]: NettyClient };
-
-    constructor(pipeline: any, options: ServerOptions) {
-        super()
-        this.allClients = {};
-        this.pipeline = pipeline;
-        let connectEvent = options.event;
-        try { this.pipeline.remove(Keys.Detect) } catch (error) { }
-        this.pipeline.addFirst(Keys.Detect, new WebSocketDetect(connectEvent).getHandler())
-        connectEvent.on(ServerEvent.detect, (ctx, channel) => {
-            channel.pipeline().addFirst(Keys.Handler, new WebSocketHandler(options).getHandler())
-            ctx.fireChannelRead(channel)
-        })
-        connectEvent.on(ServerEvent.connect, (ctx) => {
-            let nettyClient = new NettyClient(this, ctx.channel())
-            this.allClients[nettyClient.id] = nettyClient
-            this.emit(ServerEvent.connect, nettyClient)
-        })
-        connectEvent.on(ServerEvent.message, (ctx, msg) => {
-            this.emit(ServerEvent.message, this.allClients[ctx.channel().id()], msg.text())
-        })
-        connectEvent.on(ServerEvent.error, (ctx, cause) => {
-            this.emit(ServerEvent.error, this.allClients[ctx.channel().id()], cause)
-        })
-    }
-    close() {
-        if (this.pipeline.names().contains(Keys.Detect)) {
-            this.pipeline.remove(Keys.Detect)
-        }
-        Object.values(this.allClients).forEach(client => client.close())
-    }
-}
-
-export {
-    NettyWebSocketServer,
-    ServerEvent,
-    NettyClient
-}

packages/websocket/src/server/text_websocket_frame.ts

@@ -1,23 +0,0 @@
-import { EventEmitter } from 'events'
-import { ServerOptions } from '../socket-io';
-import { ServerEvent } from '../socket-io/constants'
-import { TextWebSocketFrameHandlerAdapter } from '../netty'
-
-export class TextWebSocketFrameHandler extends TextWebSocketFrameHandlerAdapter {
-    private event: EventEmitter;
-    constructor(options: ServerOptions) {
-        super()
-        this.event = options.event;
-    }
-    userEventTriggered(ctx: any, evt: any) {
-        if (evt == 'HANDSHAKE_COMPLETE') {
-            this.event.emit(ServerEvent.connect, ctx)
-        }
-    }
-    channelRead0(ctx: any, msg: any) {
-        this.event.emit(ServerEvent.message, ctx, msg)
-    }
-    exceptionCaught(ctx: any, cause: Error) {
-        this.event.emit(ServerEvent.error, ctx, cause)
-    }
-}

packages/websocket/src/socket-io/adapter.ts

@@ -1,24 +1,39 @@
 import { EventEmitter } from 'events'
-import { SocketIO } from './interfaces';
-import { Namespace } from './namespace';
-import { Parser } from './parser';
-import { Socket } from './socket';
+import { Namespace } from './namespace'
+import { Parser } from './parser'
+import { Socket } from './socket'
 
-export class Adapter extends EventEmitter implements SocketIO.Adapter {
-    nsp: Namespace;
-    rooms: Rooms;
-    sids: { [id: string]: { [room: string]: boolean; }; };
+export type SocketId = string
+export type Room = string
+
+export interface BroadcastFlags {
+    volatile?: boolean
+    compress?: boolean
+    local?: boolean
+    broadcast?: boolean
+    binary?: boolean
+}
+
+export interface BroadcastOptions {
+    rooms: Set<Room>
+    except?: Set<SocketId>
+    flags?: BroadcastFlags
+}
+
+export class Adapter extends EventEmitter implements Adapter {
+    rooms: Map<Room, Set<SocketId>>
+    sids: Map<SocketId, Set<Room>>
+    private readonly encoder: Parser
     parser: Parser
-    constructor(nsp: Namespace) {
+
+    constructor(readonly nsp: Namespace) {
         super()
-        this.nsp = nsp;
-        this.rooms = new Rooms();
-        this.sids = {};
-        this.parser = nsp.server.parser;
-    }
-    add(id: string, room: string, callback?: (err?: any) => void): void {
-        return this.addAll(id, [room], callback);
+        this.rooms = new Map()
+        this.sids = new Map()
+        this.parser = nsp.server._parser
+        this.encoder = this.parser
     }
+
     /**
      * Adds a socket to a list of room.
      *
@@ -27,101 +42,123 @@ export class Adapter extends EventEmitter implements SocketIO.Adapter {
      * @param {Function} callback
      * @api public
      */
-    addAll(id: string, rooms: string | any[], fn: { (err?: any): void; bind?: any; }) {
-        for (var i = 0; i < rooms.length; i++) {
-            var room = rooms[i];
-            this.sids[id] = this.sids[id] || {};
-            this.sids[id][room] = true;
-            this.rooms[room] = this.rooms[room] || new Room();
-            this.rooms[room].add(id);
-        }
-        fn && fn.bind(null, null)
-    };
-    del(id: string, room: string, callback?: (err?: any) => void): void {
-        if (this.sids[id]) delete this.sids[id][room];
+    addAll(id: SocketId, rooms: Set<Room>): Promise<void> | void {
+        for (const room of rooms) {
+            if (!this.sids.has(id)) {
+                this.sids.set(id, new Set())
+            }
+            this.sids.get(id).add(room)
 
-        if (this.rooms.hasOwnProperty(room)) {
-            this.rooms[room].del(id);
-            if (this.rooms[room].length === 0) delete this.rooms[room];
+            if (!this.rooms.has(room)) {
+                this.rooms.set(room, new Set())
+            }
+            this.rooms.get(room).add(id)
+        }
+    }
+    del(id: string, room: string, callback?: (err?: any) => void): void {
+        if (this.sids.has(id)) {
+            this.sids.get(id).delete(room)
+        }
+
+        if (this.rooms.has(room)) {
+            this.rooms.get(room).delete(id)
+            if (this.rooms.get(room).size === 0) this.rooms.delete(room)
         }
         callback && callback.bind(null, null)
     }
     delAll(id: string): void {
-        var rooms = this.sids[id];
-        if (rooms) {
-            for (var room in rooms) {
-                if (this.rooms.hasOwnProperty(room)) {
-                    this.rooms[room].del(id);
-                    if (this.rooms[room].length === 0) delete this.rooms[room];
-                }
+        if (!this.sids.has(id)) {
+            return
+        }
+
+        for (const room of this.sids.get(id)) {
+            if (this.rooms.has(room)) {
+                this.rooms.get(room).delete(id)
+                if (this.rooms.get(room).size === 0) this.rooms.delete(room)
             }
         }
-        delete this.sids[id];
+
+        this.sids.delete(id)
     }
-    broadcast(packet: any, opts: { rooms?: string[]; except?: string[]; flags?: { [flag: string]: boolean; }; }): void {
-        var rooms = opts.rooms || [];
-        var except = opts.except || [];
-        var flags = opts.flags || {};
-        var packetOpts = {
+
+    /**
+     * Broadcasts a packet.
+     *
+     * Options:
+     *  - `flags` {Object} flags for this packet
+     *  - `except` {Array} sids that should be excluded
+     *  - `rooms` {Array} list of rooms to broadcast to
+     *
+     * @param {Object} packet   the packet object
+     * @param {Object} opts     the options
+     * @public
+     */
+    public broadcast(packet: any, opts: BroadcastOptions): void {
+        const rooms = opts.rooms
+        const except = opts.except || new Set()
+        const flags = opts.flags || {}
+        const packetOpts = {
             preEncoded: true,
             volatile: flags.volatile,
             compress: flags.compress
-        };
-        var ids = {};
-        var self = this;
-        var socket: Socket;
+        }
+        const ids = new Set()
 
-        packet.nsp = this.nsp.name;
-        let encodedPackets = this.parser.encode(packet)
-        if (rooms.length) {
-            for (var i = 0; i < rooms.length; i++) {
-                var room = self.rooms[rooms[i]];
-                if (!room) continue;
-                var sockets = room.sockets;
-                for (var id in sockets) {
-                    if (sockets.hasOwnProperty(id)) {
-                        if (ids[id] || ~except.indexOf(id)) continue;
-                        socket = self.nsp.connected[id];
-                        if (socket) {
-                            socket.packet(encodedPackets as any, packetOpts);
-                            ids[id] = true;
-                        }
+        packet.nsp = this.nsp.name
+        const encodedPackets = this.encoder.encode(packet)
+
+        if (rooms.size) {
+            for (const room of rooms) {
+                if (!this.rooms.has(room)) continue
+
+                for (const id of this.rooms.get(room)) {
+                    if (ids.has(id) || except.has(id)) continue
+                    const socket = this.nsp.sockets.get(id)
+                    if (socket) {
+                        socket.packet(encodedPackets as any, packetOpts)
+                        ids.add(id)
                     }
                 }
             }
         } else {
-            for (var id in self.sids) {
-                if (self.sids.hasOwnProperty(id)) {
-                    if (~except.indexOf(id)) continue;
-                    socket = self.nsp.connected[id];
-                    if (socket) socket.packet(encodedPackets as any, packetOpts);
-                }
+            for (const [id] of this.sids) {
+                if (except.has(id)) continue
+                const socket = this.nsp.sockets.get(id)
+                if (socket) socket.packet(encodedPackets as any, packetOpts)
             }
         }
     }
-}
 
-class Rooms implements SocketIO.Rooms {
-    [room: string]: Room;
-}
+    /**
+     * Gets a list of sockets by sid.
+     *
+     * @param {Set<Room>} rooms   the explicit set of rooms to check.
+     */
+    public sockets(rooms: Set<Room>): Promise<Set<SocketId>> {
+        const sids = new Set<SocketId>()
+        if (rooms.size) {
+            for (const room of rooms) {
+                if (!this.rooms.has(room)) continue
+                for (const id of this.rooms.get(room)) {
+                    if (this.nsp.sockets.has(id)) {
+                        sids.add(id)
+                    }
+                }
+            }
+        } else {
+            for (const [id] of this.sids) {
+                if (this.nsp.sockets.has(id)) sids.add(id)
+            }
+        }
+        return Promise.resolve(sids)
+    }
 
-class Room implements SocketIO.Room {
-    sockets: { [id: string]: boolean; };
-    length: number;
-    constructor() {
-        this.sockets = {};
-        this.length = 0;
+    /**
+     * Gets the list of rooms a given socket has joined.
+     *
+     * @param {SocketId} id   the socket id
+     */
+    public socketRooms(id: SocketId): Set<Room> | undefined {
+        return this.sids.get(id)
     }
-    add(id) {
-        if (!this.sockets.hasOwnProperty(id)) {
-            this.sockets[id] = true;
-            this.length++;
-        }
-    }
-    del(id) {
-        if (this.sockets.hasOwnProperty(id)) {
-            delete this.sockets[id];
-            this.length--;
-        }
-    }
-}
+}

packages/websocket/src/socket-io/client.ts

@@ -1,107 +1,360 @@
 import { EventEmitter } from 'events'
 import { Parser } from './parser'
-import { Packet } from './packet';
-import { SocketIO } from './interfaces'
-import { Server, Socket } from './index';
-import { PacketTypes, SubPacketTypes } from './types';
-import { ServerEvent } from './constants';
+import { Packet } from './packet'
+import { Namespace, Server, Socket } from './index'
+import { PacketTypes, SubPacketTypes } from './types'
+import { ServerEvent } from './constants'
+import { SocketId } from './adapter'
+import { Transport } from '../transport'
 
-const parser = new Parser();
+const parser = new Parser()
 
-export class Client extends EventEmitter implements SocketIO.Client {
-    id: string;
-    server: Server;
-    conn: SocketIO.EngineSocket;
-    request: any;
-    sockets: { [id: string]: Socket; };
-    nsps: { [nsp: string]: SocketIO.Socket; };
-    connectBuffer: any;
+export class Client extends EventEmitter {
+    public readonly conn: Transport
+    /**
+     * @private
+     */
+    readonly id: string
+    private readonly server: Server
+    // private readonly encoder: Encoder
+    private readonly decoder: any
+    private sockets: Map<SocketId, Socket>
+    private nsps: Map<string, Socket>
+    private connectTimeout: NodeJS.Timeout
 
-    constructor(server: Server, engine: SocketIO.EngineSocket) {
-        super();
-        this.server = server;
-        this.conn = engine;
-        this.id = this.conn.id + '';
-        this.request = engine.request;
-        this.sockets = {};
-        this.nsps = {};
+    private checkIntervalTimer: NodeJS.Timeout
+    private upgradeTimeoutTimer: NodeJS.Timeout
+    private pingTimeoutTimer: NodeJS.Timeout
+    private pingIntervalTimer: NodeJS.Timeout
 
+    constructor(server: Server, conn) {
+        super()
+        this.server = server
+        this.conn = conn
+        // this.encoder = server.encoder
+        this.decoder = server._parser
+        this.id = this.conn.id + ''
+        this.setup()
+        // =============================
+        this.sockets = new Map()
+        this.nsps = new Map()
+        // ================== engine.io
+        this.onOpen()
+        // ================== Transport
         this.conn.on(ServerEvent.disconnect, (reason) => {
             this.onclose(reason)
         })
     }
-    connect(name, query) {
-        if (this.server.nsps[name]) {
-            // console.debug(`connecting to namespace ${name}`);
-            return this.doConnect(name, query);
-        }
-        this.server.checkNamespace(name, query, (dynamicNsp) => {
-            if (dynamicNsp) {
-                // console.debug('dynamic namespace %s was created', dynamicNsp.name);
-                this.doConnect(name, query);
+    /**
+     * @return the reference to the request that originated the Engine.IO connection
+     *
+     * @public
+     */
+    public get request(): any /**IncomingMessage */ {
+        return this.conn.request
+    }
+    /**
+     * Sets up event listeners.
+     *
+     * @private
+     */
+    private setup() {
+        // @ts-ignore
+        // this.decoder.on("decoded", this.ondecoded)
+        this.conn.on("data", this.ondata.bind(this))
+        this.conn.on("error", this.onerror.bind(this))
+        this.conn.on("close", this.onclose.bind(this))
+        console.debug(`setup client ${this.id}`)
+        this.connectTimeout = setTimeout(() => {
+            if (this.nsps.size === 0) {
+                console.debug("no namespace joined yet, close the client")
+                this.close()
             } else {
-                // console.debug('creation of namespace %s was denied', name);
-                this.packet({
+                console.debug("the client has already joined a namespace, nothing to do")
+            }
+        }, this.server._connectTimeout)
+    }
+    /**
+     * Connects a client to a namespace.
+     *
+     * @param {String} name - the namespace
+     * @param {Object} auth - the auth parameters
+     * @private
+     */
+    private connect(name: string, auth: object = {}) {
+        console.debug(`client ${this.id} connecting to namespace ${name} has: ${this.server._nsps.has(name)}`)
+        if (this.server._nsps.has(name)) {
+            return this.doConnect(name, auth)
+        }
+
+        this.server._checkNamespace(name, auth, (dynamicNsp: Namespace) => {
+            if (dynamicNsp) {
+                console.debug(`dynamic namespace ${dynamicNsp.name} was created`)
+                this.doConnect(name, auth)
+            } else {
+                console.debug(`creation of namespace ${name} was denied`)
+                this._packet({
                     type: PacketTypes.MESSAGE,
                     sub_type: SubPacketTypes.ERROR,
                     nsp: name,
-                    data: 'Invalid namespace'
-                });
+                    data: {
+                        message: "Invalid namespace"
+                    }
+                })
             }
         })
     }
-    doConnect(name, query) {
-        var nsp = this.server.of(name);
-        if ('/' != name && !this.nsps['/']) {
-            this.connectBuffer.push(name);
-            return;
+    doConnect(name, auth: object) {
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout)
+            this.connectTimeout = null
         }
-        var socket = nsp.add(this, query, () => {
-            this.sockets[socket.id] = socket;
-            this.nsps[nsp.name] = socket;
+        const nsp = this.server.of(name)
 
-            if ('/' == nsp.name && this.connectBuffer.length > 0) {
-                this.connectBuffer.forEach(this.connect, this);
-                this.connectBuffer = [];
-            }
-        });
+        nsp._add(this, auth, (socket: Socket) => {
+            this.sockets.set(socket.id, socket)
+            this.nsps.set(nsp.name, socket)
+        })
     }
-    packet(packet: Packet, opts: any = { preEncoded: false }) {
-        this.conn.send(opts.preEncoded ? packet as unknown as string : parser.encode(packet))
+    /**
+     * Disconnects from all namespaces and closes transport.
+     *
+     * @private
+     */
+    _disconnect() {
+        for (const socket of this.sockets.values()) {
+            socket.disconnect()
+        }
+        this.sockets.clear()
+        this.close()
+    }
+    /**
+     * Removes a socket. Called by each `Socket`.
+     *
+     * @private
+     */
+    _remove(socket: Socket) {
+        if (this.sockets.has(socket.id)) {
+            this.sockets.delete(socket.id)
+            this.nsps.delete(socket.nsp.name)
+        } else {
+            console.debug(`ignoring remove for ${socket.id}`,)
+        }
+        process.nextTick(() => {
+            if (this.sockets.size == 0) {
+                this.onclose('no live socket')
+            }
+        })
+    }
+    /**
+     * Closes the underlying connection.
+     *
+     * @private
+     */
+    private close() {
+        console.debug(`client ${this.id} close`)
+        if ("open" == this.conn.readyState) {
+            console.debug("forcing transport close")
+            this.onclose("forced server close")
+            this.conn.close()
+        }
+    }
+    /**
+     * Writes a packet to the transport.
+     *
+     * @param {Object} packet object
+     * @param {Object} opts
+     * @private
+     */
+    _packet(packet: Packet, opts = { preEncoded: false }) {
+        // opts = opts || {}
+        // const self = this
+
+        // // this writes to the actual connection
+        // function writeToEngine(encodedPackets) {
+        //     if (opts.volatile && !self.conn.transport.writable) return
+        //     for (let i = 0; i < encodedPackets.length; i++) {
+        //         self.conn.write(encodedPackets[i], { compress: opts.compress })
+        //     }
+        // }
+
+        // if ("open" == this.conn.readyState) {
+        //     debug("writing packet %j", packet)
+        //     if (!opts.preEncoded) {
+        //         // not broadcasting, need to encode
+        //         writeToEngine(this.encoder.encode(packet)) // encode, then write results to engine
+        //     } else {
+        //         // a broadcast pre-encodes a packet
+        //         writeToEngine(packet)
+        //     }
+        // } else {
+        //     debug("ignoring packet write %j", packet)
+        // }
+        if ("open" == this.conn.readyState) {
+            this.conn.send(opts.preEncoded ? packet as unknown as string : parser.encode(packet))
+        } else {
+            console.debug(`ignoring write packet ${JSON.stringify(packet)} to client ${this.id} is already close!`)
+        }
+    }
+    /**
+     * Called with incoming transport data.
+     *
+     * @private
+     */
+    private ondata(data) {
+        // try/catch is needed for protocol violations (GH-1880)
+        try {
+            this.decoder.add(data)
+        } catch (e) {
+            this.onerror(e)
+        }
+    }
+    /**
+     * Called when parser fully decodes a packet.
+     *
+     * @private
+     */
+    ondecoded(packet: Packet) {
+        if (SubPacketTypes.CONNECT == packet.sub_type) {
+            this.connect(packet.nsp, packet.data)
+        } else {
+            process.nextTick(() => {
+                const socket = this.nsps.get(packet.nsp)
+                if (socket) {
+                    socket._onpacket(packet)
+                } else {
+                    console.debug(`client ${this.id} no socket for namespace ${packet.nsp}.`)
+                }
+            })
+        }
+    }
+    /**
+     * Handles an error.
+     *
+     * @param {Object} err object
+     * @private
+     */
+    private onerror(err) {
+        for (const socket of this.sockets.values()) {
+            socket._onerror(err)
+        }
+        this.conn.close()
     }
     onclose(reason?: string) {
-        // debug('client close with reason %s', reason);
-        // ignore a potential subsequent `close` event
-        this.destroy();
-        // `nsps` and `sockets` are cleaned up seamlessly
-        for (var id in this.sockets) {
-            if (this.sockets.hasOwnProperty(id)) {
-                this.sockets[id].onclose(reason);
-            }
+        this.conn.readyState = "closing"
+        // ======= engine.io
+        this.onClose(reason)
+        // cleanup connectTimeout
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout)
+            this.connectTimeout = null
         }
-        this.sockets = {};
+        console.debug(`client ${this.id} close with reason ${reason}`)
+        // ignore a potential subsequent `close` event
+        // `nsps` and `sockets` are cleaned up seamlessly
+        for (const socket of this.sockets.values()) {
+            socket._onclose(reason)
+        }
+        this.sockets.clear()
         // this.decoder.destroy(); // clean up decoder
     }
-    disconnect() {
-        if ('open' == this.conn.readyState) {
-            // debug('forcing transport close');
-            this.conn.close();
-            this.onclose('forced server close');
-        }
-    }
-    remove(socket: Socket) {
-        if (this.sockets.hasOwnProperty(socket.id)) {
-            var nsp = this.sockets[socket.id].nsp.name;
-            delete this.sockets[socket.id];
-            delete this.nsps[nsp];
-        } else {
-            // debug('ignoring remove for %s', socket.id);
-        }
-    }
+
     destroy() {
         // this.conn.removeListener('data', this.ondata);
         // this.conn.removeListener('error', this.onerror);
         // this.conn.removeListener('close', this.onclose);
         // this.decoder.removeListener('decoded', this.ondecoded);
-    };
+    }
+
+    //================== engine.io
+    onOpen() {
+        this.conn.readyState = "open"
+        this._packet({
+            type: PacketTypes.OPEN,
+            data: {
+                sid: this.id,
+                upgrades: [],
+                pingInterval: this.server.options.pingInterval,
+                pingTimeout: this.server.options.pingTimeout
+            }
+        })
+        this.schedulePing()
+    }
+
+    onPacket(packet: Packet) {
+        if ("open" === this.conn.readyState) {
+            // export packet event
+            // debug("packet")
+            // this.emit("packet", packet)
+
+            // Reset ping timeout on any packet, incoming data is a good sign of
+            // other side's liveness
+            this.resetPingTimeout(this.server.options.pingInterval + this.server.options.pingTimeout * 2)
+            switch (packet.type) {
+                case PacketTypes.PING:
+                    this._packet({
+                        type: PacketTypes.PONG,
+                        data: packet.data
+                    })
+                    break
+                case PacketTypes.PONG:
+                    this.schedulePing()
+                    break
+                case PacketTypes.UPGRADE:
+                    break
+                case PacketTypes.MESSAGE:
+                    this.ondecoded(packet)
+                    break
+                case PacketTypes.CLOSE:
+                    this.onclose()
+                    break
+                default:
+                    console.log(`client ${this.id} reciver unknow packet type: ${packet.type}`)
+            }
+        } else {
+            console.debug(`packet received with closed client ${this.id}`)
+        }
+    }
+    /**
+     * Called upon transport considered closed.
+     * Possible reasons: `ping timeout`, `client error`, `parse error`,
+     * `transport error`, `server close`, `transport close`
+     */
+    onClose(reason, description?: string) {
+        // if ("closed" !== this.conn.readyState) {
+        clearTimeout(this.pingIntervalTimer)
+        clearTimeout(this.pingTimeoutTimer)
+
+        clearInterval(this.checkIntervalTimer)
+        this.checkIntervalTimer = null
+        clearTimeout(this.upgradeTimeoutTimer)
+        //     this.emit("close", reason, description)
+        // }
+    }
+    /**
+     * Pings client every `this.pingInterval` and expects response
+     * within `this.pingTimeout` or closes connection.
+     *
+     * @api private
+     */
+    schedulePing() {
+        clearTimeout(this.pingIntervalTimer)
+        this.pingIntervalTimer = setTimeout(() => {
+            this.resetPingTimeout(this.server.options.pingTimeout)
+            process.nextTick(() => this._packet({ type: PacketTypes.PING }))
+        }, this.server.options.pingInterval)
+    }
+
+    /**
+     * Resets ping timeout.
+     *
+     * @api private
+     */
+    resetPingTimeout(timeout) {
+        clearTimeout(this.pingTimeoutTimer)
+        this.pingTimeoutTimer = setTimeout(() => {
+            if (this.conn.readyState === "closed") return
+            this.onclose("ping timeout")
+        }, timeout)
+    }
 }

packages/websocket/src/socket-io/constants.ts

@@ -4,5 +4,6 @@ export enum ServerEvent {
     connection = 'connection',
     message = 'message',
     error = 'error',
-    disconnect = 'disconnect'
-}
+    disconnecting = 'disconnecting',
+    disconnect = 'disconnect',
+}