From 4bdf0962fe9c6f22edd0291bb993ddb36ffaf1ce Mon Sep 17 00:00:00 2001 From: liangtongchuan Date: Mon, 1 Mar 2021 22:09:21 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B5=8B=E8=AF=95=EF=BC=9A=E5=AE=A2=E6=88=B7?= =?UTF-8?q?=E7=AB=AF=E6=8E=A5=E6=94=B6=E6=9C=8D=E5=8A=A1=E5=99=A8=E5=9B=9E?= =?UTF-8?q?=E8=B0=83=E7=9B=B8=E5=85=B3=E6=96=B9=E6=B3=95=EF=BC=9B=E6=89=93?= =?UTF-8?q?=E5=BC=80=E4=B9=8B=E5=89=8D=E5=85=B3=E9=97=AD=E7=9A=84=20protob?= =?UTF-8?q?uf=EF=BC=9B=E4=BF=AE=E6=94=B9pinus=E6=9C=BA=E5=99=A8=E4=BA=BA?= =?UTF-8?q?=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- game-server/config/serverProtos.ts | 24 +- game-server/test/PinusWSClient.js | 729 +++++++++++++++++++++++ game-server/test/PinusWSClient.ts | 901 +++++++++++++++++++++++++++++ game-server/test/comBattle.test.ts | 9 + 4 files changed, 1651 insertions(+), 12 deletions(-) create mode 100644 game-server/test/PinusWSClient.js create mode 100644 game-server/test/PinusWSClient.ts diff --git a/game-server/config/serverProtos.ts b/game-server/config/serverProtos.ts index 62ba1533c..73669425d 100644 --- a/game-server/config/serverProtos.ts +++ b/game-server/config/serverProtos.ts @@ -5,18 +5,18 @@ module.exports = { 'required string target': 3 }, // TODO 检查 protobuf 和测试冲突的原因 - // 'onItemUpdate': { - // 'message Data': { - // "message Good": { - // 'required uInt32 id': 1, - // 'required uInt32 count': 2, - // }, - // 'repeated Good goods': 1, - // }, - // 'required string msg': 1, - // 'required uInt32 code': 2, - // 'required Data data': 3 - // }, + 'onItemUpdate': { + 'message Data': { + "message Good": { + 'required uInt32 id': 1, + 'required uInt32 count': 2, + }, + 'repeated Good goods': 1, + }, + 'required string msg': 1, + 'required uInt32 code': 2, + 'required Data data': 3 + }, 'onPlayerCeUpdate': { 'message Data': { "message Hero": { diff --git a/game-server/test/PinusWSClient.js b/game-server/test/PinusWSClient.js new file mode 100644 index 000000000..9350ecc10 --- /dev/null +++ b/game-server/test/PinusWSClient.js @@ -0,0 +1,729 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const egret = require("./ByteArray"); +const WebSocket = require("ws"); +var PinusWSClientEvent; +(function (PinusWSClientEvent) { + PinusWSClientEvent["EVENT_IO_ERROR"] = "io-error"; + PinusWSClientEvent["EVENT_CLOSE"] = "close"; + PinusWSClientEvent["EVENT_KICK"] = "onKick"; + PinusWSClientEvent["EVENT_HEART_BEAT_TIMEOUT"] = "heartbeat timeout"; +})(PinusWSClientEvent = exports.PinusWSClientEvent || (exports.PinusWSClientEvent = {})); +class PinusWSClient { + constructor() { + this.JS_WS_CLIENT_TYPE = 'js-websocket'; + this.JS_WS_CLIENT_VERSION = '0.0.5'; + this.RES_OK = 200; + this.RES_FAIL = 500; + this.RES_OLD_CLIENT = 501; + this.socket = null; + this.callbacks = {}; + this.handlers = {}; + // Map from request id to route + this.routeMap = {}; + this.heartbeatInterval = 0; + this.heartbeatTimeout = 0; + this.nextHeartbeatTimeout = 0; + this.gapThreshold = 100; + this.heartbeatId = null; + this.heartbeatTimeoutId = null; + this.handshakeCallback = null; + this.initCallback = null; + this._callbacks = {}; + this.reqId = 0; + this.socket = null; + this.callbacks = {}; + this.handlers = {}; + // Map from request id to route + this.routeMap = {}; + this._message = new Message(this.routeMap); + this._package = new Package(); + this.heartbeatInterval = 0; + this.heartbeatTimeout = 0; + this.nextHeartbeatTimeout = 0; + this.gapThreshold = 100; + this.heartbeatId = null; + this.heartbeatTimeoutId = null; + this.handshakeCallback = null; + this.handshakeBuffer = { + 'sys': { + type: this.JS_WS_CLIENT_TYPE, + version: this.JS_WS_CLIENT_VERSION + }, + 'user': {} + }; + this.initCallback = null; + this.reqId = 0; + this.handlers[Package.TYPE_HANDSHAKE] = this.handshake; + this.handlers[Package.TYPE_HEARTBEAT] = this.heartbeat; + this.handlers[Package.TYPE_DATA] = this.onData; + this.handlers[Package.TYPE_KICK] = this.onKick; + } + init(params, cb) { + console.log('init', params); + this.initCallback = cb; + let host = params.host; + let port = params.port; + // + // var url = 'ws://' + host; + // if(port) { + // url += ':' + port; + // } + this.handshakeBuffer.user = params.user; + this.handshakeCallback = params.handshakeCallback; + this.initWebSocket(host, port, cb); + } + initWebSocket(host, port, cb) { + console.log('[Pinus] connect to:', host, port); + let url = 'ws://' + host; + if (port) { + url += ':' + port; + } + let socket = new WebSocket(url); + socket.binaryType = 'arraybuffer'; + socket.onopen = (event) => { + this.onConnect(); + }; + socket.onmessage = (event) => { + this.onMessage(event); + }; + socket.onerror = (event) => { + this.onIOError(event); + }; + socket.onclose = (event) => { + this.onClose(event); + }; + this.socket = socket; + } + on(event, fn) { + (this._callbacks[event] = this._callbacks[event] || []).push(fn); + } + request(route, msg, cb) { + if (arguments.length === 2 && typeof msg === 'function') { + cb = msg; + msg = {}; + } + else { + msg = msg || {}; + } + route = route || msg.route; + if (!route) { + return; + } + this.reqId++; + if (this.reqId > 127) { + this.reqId = 1; + } + let reqId = this.reqId; + if (PinusWSClient.DEBUG) { + console.log(`REQUEST:route:${route} , reqId:${reqId}, msg:${msg}`); + } + this.sendMessage(reqId, route, msg); + this.callbacks[reqId] = cb; + this.routeMap[reqId] = route; + } + notify(route, msg) { + this.sendMessage(0, route, msg); + } + onMessage(event) { + this.processPackage(this._package.decode(new egret.ByteArray(event.data))); + } + sendMessage(reqId, route, msg) { + let byte; + byte = this._message.encode(reqId, route, msg); + byte = this._package.encode(Package.TYPE_DATA, byte); + this.send(byte); + } + onConnect() { + console.log('[Pinus] connect success'); + this.send(this._package.encode(Package.TYPE_HANDSHAKE, Protocol.strencode(JSON.stringify(this.handshakeBuffer)))); + } + onClose(e) { + console.error('[Pinus] connect close:', e); + // this.emit(Pinus.EVENT_CLOSE,e); + } + onIOError(e) { + // this.emit(Pinus.EVENT_IO_ERROR, e); + console.error('socket error: ', e); + } + onKick(event) { + // this.emit(PinusWSClient.EVENT_KICK,event); + } + onData(data) { + // probuff decode + let msg = this._message.decode(data); + if (msg.id > 0) { + msg.route = this.routeMap[msg.id]; + delete this.routeMap[msg.id]; + if (!msg.route) { + return; + } + } + // msg.body = this.deCompose(msg); + this.processMessage(msg); + } + processMessage(msg) { + if (!msg.id) { + // server push message + if (PinusWSClient.DEBUG) { + console.log(`EVENT: Route:${msg.route} Msg:${msg.body}`); + } + this.emit(msg.route, msg.body); + return; + } + if (PinusWSClient.DEBUG) { + console.log(`RESPONSE: Id:${msg.id} Msg:${msg.body}`); + } + // if have a id then find the callback function with the request + let cb = this.callbacks[msg.id]; + delete this.callbacks[msg.id]; + if (typeof cb !== 'function') { + return; + } + if (msg.body && msg.body.code === 500) { + let obj = { 'code': 500, 'desc': '服务器内部错误', 'key': 'INTERNAL_ERROR' }; + msg.body.error = obj; + } + cb(msg.body); + return; + } + heartbeat(data) { + if (!this.heartbeatInterval) { + // no heartbeat + return; + } + let obj = this._package.encode(Package.TYPE_HEARTBEAT); + if (this.heartbeatTimeoutId) { + clearTimeout(this.heartbeatTimeoutId); + this.heartbeatTimeoutId = null; + } + if (this.heartbeatId) { + // already in a heartbeat interval + return; + } + let self = this; + self.heartbeatId = setTimeout(function () { + self.heartbeatId = null; + self.send(obj); + self.nextHeartbeatTimeout = Date.now() + self.heartbeatTimeout; + self.heartbeatTimeoutId = setTimeout(self.heartbeatTimeoutCb.bind(self, data), self.heartbeatTimeout); + }, self.heartbeatInterval); + } + heartbeatTimeoutCb(data) { + let gap = this.nextHeartbeatTimeout - Date.now(); + if (gap > this.gapThreshold) { + this.heartbeatTimeoutId = setTimeout(this.heartbeatTimeoutCb.bind(this, data), gap); + } + else { + console.error('server heartbeat timeout', data); + // this.emit(PinusWSClient.EVENT_HEART_BEAT_TIMEOUT,data); + this._disconnect(); + } + } + off(event, fn) { + this.removeAllListeners(event, fn); + } + removeAllListeners(event, fn) { + // all + if (0 === arguments.length) { + this._callbacks = {}; + return; + } + // specific event + let callbacks = this._callbacks[event]; + if (!callbacks) { + return; + } + // remove all handlers + if (event && !fn) { + delete this._callbacks[event]; + return; + } + // remove specific handler + let i = this.index(callbacks, fn._off || fn); + if (~i) { + callbacks.splice(i, 1); + } + return; + } + index(arr, obj) { + if ([].indexOf) { + return arr.indexOf(obj); + } + for (let i = 0; i < arr.length; ++i) { + if (arr[i] === obj) + return i; + } + return -1; + } + disconnect() { + this._disconnect(); + } + _disconnect() { + console.warn('[Pinus] client disconnect ...'); + if (this.socket) + this.socket.close(); + this.socket = null; + if (this.heartbeatId) { + clearTimeout(this.heartbeatId); + this.heartbeatId = null; + } + if (this.heartbeatTimeoutId) { + clearTimeout(this.heartbeatTimeoutId); + this.heartbeatTimeoutId = null; + } + } + processPackage(msg) { + this.handlers[msg.type].apply(this, [msg.body]); + } + handshake(resData) { + let data = JSON.parse(Protocol.strdecode(resData)); + if (data.code === this.RES_OLD_CLIENT) { + // this.emit(PinusWSClient.EVENT_IO_ERROR, 'client version not fullfill'); + return; + } + if (data.code !== this.RES_OK) { + // this.emit(PinusWSClient.EVENT_IO_ERROR, 'handshake fail'); + return; + } + this.handshakeInit(data); + let obj = this._package.encode(Package.TYPE_HANDSHAKE_ACK); + this.send(obj); + if (this.initCallback) { + this.initCallback(data); + this.initCallback = null; + } + } + handshakeInit(data) { + if (data.sys) { + Routedic.init(data.sys.dict); + Protobuf.init(data.sys.protos); + } + if (data.sys && data.sys.heartbeat) { + this.heartbeatInterval = data.sys.heartbeat * 1000; // heartbeat interval + this.heartbeatTimeout = this.heartbeatInterval * 2; // max heartbeat timeout + } + else { + this.heartbeatInterval = 0; + this.heartbeatTimeout = 0; + } + if (typeof this.handshakeCallback === 'function') { + this.handshakeCallback(data.user); + } + } + send(byte) { + if (this.socket) { + this.socket.send(byte.buffer); + } + } + // private deCompose(msg){ + // return JSON.parse(Protocol.strdecode(msg.body)); + // } + emit(event, ...args) { + let params = [].slice.call(arguments, 1); + let callbacks = this._callbacks[event]; + if (callbacks) { + callbacks = callbacks.slice(0); + for (let i = 0, len = callbacks.length; i < len; ++i) { + callbacks[i].apply(this, params); + } + } + return this; + } +} +exports.PinusWSClient = PinusWSClient; +PinusWSClient.DEBUG = false; +class Package { + encode(type, body) { + let length = body ? body.length : 0; + let buffer = new egret.ByteArray(); + buffer.writeByte(type & 0xff); + buffer.writeByte((length >> 16) & 0xff); + buffer.writeByte((length >> 8) & 0xff); + buffer.writeByte(length & 0xff); + if (body) + buffer.writeBytes(body, 0, body.length); + return buffer; + } + decode(buffer) { + let type = buffer.readUnsignedByte(); + let len = (buffer.readUnsignedByte() << 16 | buffer.readUnsignedByte() << 8 | buffer.readUnsignedByte()) >>> 0; + let body; + if (buffer.bytesAvailable >= len) { + body = new egret.ByteArray(); + if (len) + buffer.readBytes(body, 0, len); + } + else { + console.log('[Package] no enough length for current type:', type); + } + return { type: type, body: body, length: len }; + } +} +Package.TYPE_HANDSHAKE = 1; +Package.TYPE_HANDSHAKE_ACK = 2; +Package.TYPE_HEARTBEAT = 3; +Package.TYPE_DATA = 4; +Package.TYPE_KICK = 5; +class Message { + constructor(routeMap) { + this.routeMap = routeMap; + } + encode(id, route, msg) { + let buffer = new egret.ByteArray(); + let type = id ? Message.TYPE_REQUEST : Message.TYPE_NOTIFY; + let byte = Protobuf.encode(route, msg) || Protocol.strencode(JSON.stringify(msg)); + let rot = Routedic.getID(route) || route; + buffer.writeByte((type << 1) | ((typeof (rot) === 'string') ? 0 : 1)); + if (id) { + // 7.x + do { + let tmp = id % 128; + let next = Math.floor(id / 128); + if (next !== 0) { + tmp = tmp + 128; + } + buffer.writeByte(tmp); + id = next; + } while (id !== 0); + // 5.x + // var len:Array = []; + // len.push(id & 0x7f); + // id >>= 7; + // while(id > 0) + // { + // len.push(id & 0x7f | 0x80); + // id >>= 7; + // } + // + // for (var i:int = len.length - 1; i >= 0; i--) + // { + // buffer.writeByte(len[i]); + // } + } + if (rot) { + if (typeof rot === 'string') { + buffer.writeByte(rot.length & 0xff); + buffer.writeUTFBytes(rot); + } + else { + buffer.writeByte((rot >> 8) & 0xff); + buffer.writeByte(rot & 0xff); + } + } + if (byte) { + buffer.writeBytes(byte); + } + return buffer; + } + decode(buffer) { + // parse flag + let flag = buffer.readUnsignedByte(); + let compressRoute = flag & Message.MSG_COMPRESS_ROUTE_MASK; + let type = (flag >> 1) & Message.MSG_TYPE_MASK; + let route; + // parse id + let id = 0; + if (type === Message.TYPE_REQUEST || type === Message.TYPE_RESPONSE) { + // 7.x + let i = 0; + let m; + do { + m = buffer.readUnsignedByte(); + id = id + ((m & 0x7f) * Math.pow(2, (7 * i))); + i++; + } while (m >= 128); + // 5.x + // var byte:int = buffer.readUnsignedByte(); + // id = byte & 0x7f; + // while(byte & 0x80) + // { + // id <<= 7; + // byte = buffer.readUnsignedByte(); + // id |= byte & 0x7f; + // } + } + // parse route + if (type === Message.TYPE_REQUEST || type === Message.TYPE_NOTIFY || type === Message.TYPE_PUSH) { + if (compressRoute) { + route = buffer.readUnsignedShort(); + } + else { + let routeLen = buffer.readUnsignedByte(); + route = routeLen ? buffer.readUTFBytes(routeLen) : ''; + } + } + else if (type === Message.TYPE_RESPONSE) { + route = this.routeMap[id]; + } + if (!id && !(typeof (route) === 'string')) { + route = Routedic.getName(route); + } + let body = Protobuf.decode(route, buffer) || JSON.parse(Protocol.strdecode(buffer)); + return { id: id, type: type, route: route, body: body }; + } +} +Message.MSG_FLAG_BYTES = 1; +Message.MSG_ROUTE_CODE_BYTES = 2; +Message.MSG_ID_MAX_BYTES = 5; +Message.MSG_ROUTE_LEN_BYTES = 1; +Message.MSG_ROUTE_CODE_MAX = 0xffff; +Message.MSG_COMPRESS_ROUTE_MASK = 0x1; +Message.MSG_TYPE_MASK = 0x7; +Message.TYPE_REQUEST = 0; +Message.TYPE_NOTIFY = 1; +Message.TYPE_RESPONSE = 2; +Message.TYPE_PUSH = 3; +class Protocol { + static strencode(str) { + let buffer = new egret.ByteArray(); + buffer.length = str.length; + buffer.writeUTFBytes(str); + return buffer; + } + static strdecode(byte) { + return byte.readUTFBytes(byte.bytesAvailable); + } +} +class Protobuf { + static init(protos) { + this._clients = protos && protos.client || {}; + this._servers = protos && protos.server || {}; + } + static encode(route, msg) { + let protos = this._clients[route]; + if (!protos) + return null; + return this.encodeProtos(protos, msg); + } + static decode(route, buffer) { + let protos = this._servers[route]; + if (!protos) + return null; + return this.decodeProtos(protos, buffer); + } + static encodeProtos(protos, msg) { + let buffer = new egret.ByteArray(); + for (let name in msg) { + if (protos[name]) { + let proto = protos[name]; + switch (proto.option) { + case 'optional': + case 'required': + buffer.writeBytes(this.encodeTag(proto.type, proto.tag)); + this.encodeProp(msg[name], proto.type, protos, buffer); + break; + case 'repeated': + if (!!msg[name] && msg[name].length > 0) { + this.encodeArray(msg[name], proto, protos, buffer); + } + break; + } + } + } + return buffer; + } + static decodeProtos(protos, buffer) { + let msg = {}; + while (buffer.bytesAvailable) { + let head = this.getHead(buffer); + let name = protos.__tags[head.tag]; + switch (protos[name].option) { + case 'optional': + case 'required': + msg[name] = this.decodeProp(protos[name].type, protos, buffer); + break; + case 'repeated': + if (!msg[name]) { + msg[name] = []; + } + this.decodeArray(msg[name], protos[name].type, protos, buffer); + break; + } + } + return msg; + } + static encodeTag(type, tag) { + let value = this.TYPES[type] !== undefined ? this.TYPES[type] : 2; + return this.encodeUInt32((tag << 3) | value); + } + static getHead(buffer) { + let tag = this.decodeUInt32(buffer); + return { type: tag & 0x7, tag: tag >> 3 }; + } + static encodeProp(value, type, protos, buffer) { + switch (type) { + case 'uInt32': + buffer.writeBytes(this.encodeUInt32(value)); + break; + case 'int32': + case 'sInt32': + buffer.writeBytes(this.encodeSInt32(value)); + break; + case 'float': + // Float32Array + let floats = new egret.ByteArray(); + floats.endian = egret.Endian.LITTLE_ENDIAN; + floats.writeFloat(value); + buffer.writeBytes(floats); + break; + case 'double': + let doubles = new egret.ByteArray(); + doubles.endian = egret.Endian.LITTLE_ENDIAN; + doubles.writeDouble(value); + buffer.writeBytes(doubles); + break; + case 'string': + buffer.writeBytes(this.encodeUInt32(value.length)); + buffer.writeUTFBytes(value); + break; + default: + let proto = protos.__messages[type] || this._clients['message ' + type]; + if (!!proto) { + let buf = this.encodeProtos(proto, value); + buffer.writeBytes(this.encodeUInt32(buf.length)); + buffer.writeBytes(buf); + } + break; + } + } + static decodeProp(type, protos, buffer) { + switch (type) { + case 'uInt32': + return this.decodeUInt32(buffer); + case 'int32': + case 'sInt32': + return this.decodeSInt32(buffer); + case 'float': + let floats = new egret.ByteArray(); + buffer.readBytes(floats, 0, 4); + floats.endian = egret.Endian.LITTLE_ENDIAN; + let float = buffer.readFloat(); + return floats.readFloat(); + case 'double': + let doubles = new egret.ByteArray(); + buffer.readBytes(doubles, 0, 8); + doubles.endian = egret.Endian.LITTLE_ENDIAN; + return doubles.readDouble(); + case 'string': + let length = this.decodeUInt32(buffer); + return buffer.readUTFBytes(length); + default: + let proto = protos && (protos.__messages[type] || this._servers['message ' + type]); + if (proto) { + let len = this.decodeUInt32(buffer); + let buf; + if (len) { + buf = new egret.ByteArray(); + buffer.readBytes(buf, 0, len); + } + return len ? Protobuf.decodeProtos(proto, buf) : false; + } + break; + } + } + static isSimpleType(type) { + return (type === 'uInt32' || + type === 'sInt32' || + type === 'int32' || + type === 'uInt64' || + type === 'sInt64' || + type === 'float' || + type === 'double'); + } + static encodeArray(array, proto, protos, buffer) { + let isSimpleType = this.isSimpleType; + if (isSimpleType(proto.type)) { + buffer.writeBytes(this.encodeTag(proto.type, proto.tag)); + buffer.writeBytes(this.encodeUInt32(array.length)); + let encodeProp = this.encodeProp; + for (let i = 0; i < array.length; i++) { + encodeProp(array[i], proto.type, protos, buffer); + } + } + else { + let encodeTag = this.encodeTag; + for (let j = 0; j < array.length; j++) { + buffer.writeBytes(encodeTag(proto.type, proto.tag)); + this.encodeProp(array[j], proto.type, protos, buffer); + } + } + } + static decodeArray(array, type, protos, buffer) { + let isSimpleType = this.isSimpleType; + let decodeProp = this.decodeProp; + if (isSimpleType(type)) { + let length = this.decodeUInt32(buffer); + for (let i = 0; i < length; i++) { + array.push(this.decodeProp(type, protos, buffer)); + } + } + else { + array.push(this.decodeProp(type, protos, buffer)); + } + } + static encodeUInt32(n) { + let result = new egret.ByteArray(); + do { + let tmp = n % 128; + let next = Math.floor(n / 128); + if (next !== 0) { + tmp = tmp + 128; + } + result.writeByte(tmp); + n = next; + } while (n !== 0); + return result; + } + static decodeUInt32(buffer) { + let n = 0; + for (let i = 0; i < buffer.length; i++) { + let m = buffer.readUnsignedByte(); + n = n + ((m & 0x7f) * Math.pow(2, (7 * i))); + if (m < 128) { + return n; + } + } + return n; + } + static encodeSInt32(n) { + n = n < 0 ? (Math.abs(n) * 2 - 1) : n * 2; + return this.encodeUInt32(n); + } + static decodeSInt32(buffer) { + let n = this.decodeUInt32(buffer); + let flag = ((n % 2) === 1) ? -1 : 1; + n = ((n % 2 + n) / 2) * flag; + return n; + } +} +Protobuf.TYPES = { + uInt32: 0, + sInt32: 0, + int32: 0, + double: 1, + string: 2, + message: 2, + float: 5 +}; +Protobuf._clients = {}; +Protobuf._servers = {}; +class Routedic { + static init(dict) { + this._names = dict || {}; + let _names = this._names; + let _ids = this._ids; + for (let name in _names) { + _ids[_names[name]] = name; + } + } + static getID(name) { + return this._names[name]; + } + static getName(id) { + return this._ids[id]; + } +} +Routedic._ids = {}; +Routedic._names = {}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PinusWSClient.js","sourceRoot":"","sources":["../src/PinusWSClient.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/game-server/test/PinusWSClient.ts b/game-server/test/PinusWSClient.ts new file mode 100644 index 000000000..87d1c17bf --- /dev/null +++ b/game-server/test/PinusWSClient.ts @@ -0,0 +1,901 @@ + +import * as egret from './ByteArray'; +import * as WebSocket from 'ws'; + +export enum PinusWSClientEvent { + EVENT_IO_ERROR = 'io-error', + EVENT_CLOSE = 'close', + EVENT_KICK = 'onKick', + EVENT_HEART_BEAT_TIMEOUT = 'heartbeat timeout' +} + +export class PinusWSClient { + + static DEBUG: boolean = false; + + private JS_WS_CLIENT_TYPE = 'js-websocket'; + private JS_WS_CLIENT_VERSION = '0.0.5'; + + private RES_OK: number = 200; + private RES_FAIL: number = 500; + private RES_OLD_CLIENT: number = 501; + + + private socket: WebSocket = null; + private callbacks: any = {}; + private handlers: any = {}; + // Map from request id to route + private routeMap: any = {}; + + private heartbeatInterval: number = 0; + private heartbeatTimeout: number = 0; + private nextHeartbeatTimeout: number = 0; + private gapThreshold: number = 100; + private heartbeatId: any = null; + private heartbeatTimeoutId: any = null; + + private handshakeCallback: any = null; + private handshakeBuffer: any; + private initCallback: Function = null; + + private _callbacks: any = {}; + + private reqId: number = 0; + + + private _package: IPackage; + private _message: IMessage; + + constructor() { + + this.socket = null; + this.callbacks = {}; + this.handlers = {}; + // Map from request id to route + this.routeMap = {}; + this._message = new Message(this.routeMap); + this._package = new Package(); + + + this.heartbeatInterval = 0; + this.heartbeatTimeout = 0; + this.nextHeartbeatTimeout = 0; + this.gapThreshold = 100; + this.heartbeatId = null; + this.heartbeatTimeoutId = null; + + this.handshakeCallback = null; + + this.handshakeBuffer = { + 'sys': { + type: this.JS_WS_CLIENT_TYPE, + version: this.JS_WS_CLIENT_VERSION + }, + 'user': { + } + }; + + this.initCallback = null; + + this.reqId = 0; + + this.handlers[Package.TYPE_HANDSHAKE] = this.handshake; + this.handlers[Package.TYPE_HEARTBEAT] = this.heartbeat; + this.handlers[Package.TYPE_DATA] = this.onData; + this.handlers[Package.TYPE_KICK] = this.onKick; + } + + + public init(params: any, cb: Function): void { + console.log('init', params); + this.initCallback = cb; + let host = params.host; + let port = params.port; + // + // var url = 'ws://' + host; + // if(port) { + // url += ':' + port; + // } + + this.handshakeBuffer.user = params.user; + this.handshakeCallback = params.handshakeCallback; + this.initWebSocket(host, port, cb); + } + private initWebSocket(host: string, port: number, cb: Function): void { + console.log('[Pinus] connect to:', host, port); + + let url = 'ws://' + host; + if (port) { + url += ':' + port; + } + let socket = new WebSocket(url); + socket.binaryType = 'arraybuffer'; + socket.onopen = (event) => { + this.onConnect(); + }; + socket.onmessage = (event) => { + this.onMessage(event); + }; + socket.onerror = (event) => { + this.onIOError(event); + }; + socket.onclose = (event) => { + this.onClose(event); + }; + this.socket = socket; + } + + + public on(event: PinusWSClientEvent.EVENT_IO_ERROR, fn: (err: Error) => void): void; + public on(event: PinusWSClientEvent.EVENT_CLOSE, fn: (err: Error) => void): void; + public on(event: PinusWSClientEvent.EVENT_KICK, fn: (err: Error) => void): void; + public on(event: PinusWSClientEvent.EVENT_HEART_BEAT_TIMEOUT, fn: (err: Error) => void): void; + public on(route: string, fn: (msg: any) => void) : void; + public on(event: string, fn: (msg: any) => void) { + (this._callbacks[event] = this._callbacks[event] || []).push(fn); + } + public request(route: string, msg: any, cb: Function) { + if (arguments.length === 2 && typeof msg === 'function') { + cb = msg; + msg = {}; + } else { + msg = msg || {}; + } + route = route || msg.route; + if (!route) { + return; + } + + this.reqId++; + if (this.reqId > 127) { + this.reqId = 1; + } + let reqId = this.reqId; + + + if (PinusWSClient.DEBUG) { + console.log(`REQUEST:route:${route} , reqId:${reqId}, msg:${msg}`); + } + + this.sendMessage(reqId, route, msg); + + this.callbacks[reqId] = cb; + this.routeMap[reqId] = route; + } + + public notify(route: string, msg: any): void { + this.sendMessage(0, route, msg); + } + + private onMessage(event: { data: string | Buffer | ArrayBuffer | Buffer[]; type: string; target: WebSocket }): void { + this.processPackage(this._package.decode(new egret.ByteArray(event.data))); + + } + private sendMessage(reqId: number, route: string, msg: any) { + let byte: egret.ByteArray; + + byte = this._message.encode(reqId, route, msg); + byte = this._package.encode(Package.TYPE_DATA, byte); + + this.send(byte); + + } + + private onConnect(): void { + console.log('[Pinus] connect success'); + this.send(this._package.encode(Package.TYPE_HANDSHAKE, Protocol.strencode(JSON.stringify(this.handshakeBuffer)))); + } + + private onClose(e: any): void { + console.error('[Pinus] connect close:', e); + // this.emit(Pinus.EVENT_CLOSE,e); + } + + private onIOError(e: any): void { + // this.emit(Pinus.EVENT_IO_ERROR, e); + console.error('socket error: ', e); + } + + private onKick(event: string) { + // this.emit(PinusWSClient.EVENT_KICK,event); + } + private onData(data: any) { + // probuff decode + let msg = this._message.decode(data); + + if (msg.id > 0) { + msg.route = this.routeMap[msg.id]; + delete this.routeMap[msg.id]; + if (!msg.route) { + return; + } + } + + // msg.body = this.deCompose(msg); + + this.processMessage(msg); + + } + + private processMessage(msg: any) { + if (!msg.id) { + // server push message + + if (PinusWSClient.DEBUG) { + console.log(`EVENT: Route:${msg.route} Msg:${msg.body}`); + } + + // this.emit(msg.route, msg.body); + return; + } + if (PinusWSClient.DEBUG) { + console.log(`RESPONSE: Id:${msg.id} Msg:${msg.body}`); + } + + // if have a id then find the callback function with the request + let cb = this.callbacks[msg.id]; + + delete this.callbacks[msg.id]; + if (typeof cb !== 'function') { + return; + } + if (msg.body && msg.body.code === 500) { + let obj: any = { 'code': 500, 'desc': '服务器内部错误', 'key': 'INTERNAL_ERROR' }; + msg.body.error = obj; + } + cb(msg.body); + return; + } + + private heartbeat(data: any) { + + if (!this.heartbeatInterval) { + // no heartbeat + return; + } + + let obj = this._package.encode(Package.TYPE_HEARTBEAT); + if (this.heartbeatTimeoutId) { + clearTimeout(this.heartbeatTimeoutId); + this.heartbeatTimeoutId = null; + } + + if (this.heartbeatId) { + // already in a heartbeat interval + return; + } + + let self = this; + self.heartbeatId = setTimeout(function () { + self.heartbeatId = null; + self.send(obj); + + self.nextHeartbeatTimeout = Date.now() + self.heartbeatTimeout; + self.heartbeatTimeoutId = setTimeout(self.heartbeatTimeoutCb.bind(self, data), self.heartbeatTimeout); + }, self.heartbeatInterval); + } + private heartbeatTimeoutCb(data: any) { + let gap = this.nextHeartbeatTimeout - Date.now(); + if (gap > this.gapThreshold) { + this.heartbeatTimeoutId = setTimeout(this.heartbeatTimeoutCb.bind(this, data), gap); + } else { + console.error('server heartbeat timeout', data); + // this.emit(PinusWSClient.EVENT_HEART_BEAT_TIMEOUT,data); + this._disconnect(); + } + } + public off(event?: string, fn?: Function) { + this.removeAllListeners(event, fn); + } + public removeAllListeners(event?: string, fn?: Function) { + // all + if (0 === arguments.length) { + this._callbacks = {}; + return; + } + + // specific event + let callbacks = this._callbacks[event]; + if (!callbacks) { + return; + } + + // remove all handlers + if (event && !fn) { + delete this._callbacks[event]; + return; + } + + // remove specific handler + let i = this.index(callbacks, (fn as any)._off || fn); + if (~i) { + callbacks.splice(i, 1); + } + return; + } + private index(arr: any, obj: any) { + if ([].indexOf) { + return arr.indexOf(obj); + } + + for (let i = 0; i < arr.length; ++i) { + if (arr[i] === obj) + return i; + } + return -1; + } + public disconnect(): void { + this._disconnect(); + } + private _disconnect(): void { + console.warn('[Pinus] client disconnect ...'); + + if (this.socket) this.socket.close(); + this.socket = null; + if (this.heartbeatId) { + clearTimeout(this.heartbeatId); + this.heartbeatId = null; + } + + if (this.heartbeatTimeoutId) { + clearTimeout(this.heartbeatTimeoutId); + this.heartbeatTimeoutId = null; + } + + } + private processPackage(msg: any): void { + this.handlers[msg.type].apply(this, [msg.body]); + } + private handshake(resData: any) { + + let data = JSON.parse(Protocol.strdecode(resData)); + if (data.code === this.RES_OLD_CLIENT) { + // this.emit(PinusWSClient.EVENT_IO_ERROR, 'client version not fullfill'); + return; + } + + if (data.code !== this.RES_OK) { + // this.emit(PinusWSClient.EVENT_IO_ERROR, 'handshake fail'); + return; + } + + this.handshakeInit(data); + + let obj = this._package.encode(Package.TYPE_HANDSHAKE_ACK); + this.send(obj); + if (this.initCallback) { + this.initCallback(data); + this.initCallback = null; + } + } + private handshakeInit(data: any): void { + + if (data.sys) { + Routedic.init(data.sys.dict); + Protobuf.init(data.sys.protos); + } + if (data.sys && data.sys.heartbeat) { + this.heartbeatInterval = data.sys.heartbeat * 1000; // heartbeat interval + this.heartbeatTimeout = this.heartbeatInterval * 2; // max heartbeat timeout + } else { + this.heartbeatInterval = 0; + this.heartbeatTimeout = 0; + } + + if (typeof this.handshakeCallback === 'function') { + this.handshakeCallback(data.user); + } + } + private send(byte: egret.ByteArray): void { + if (this.socket) { + this.socket.send(byte.buffer); + } + } + // private deCompose(msg){ + // return JSON.parse(Protocol.strdecode(msg.body)); + // } + private emit(event: string, ...args: any[]) { + let params = [].slice.call(arguments, 1); + let callbacks = this._callbacks[event]; + + if (callbacks) { + callbacks = callbacks.slice(0); + for (let i = 0, len = callbacks.length; i < len; ++i) { + callbacks[i].apply(this, params); + } + } + + return this; + } + + +} + +class Package implements IPackage { + static TYPE_HANDSHAKE: number = 1; + static TYPE_HANDSHAKE_ACK: number = 2; + static TYPE_HEARTBEAT: number = 3; + static TYPE_DATA: number = 4; + static TYPE_KICK: number = 5; + + public encode(type: number, body?: egret.ByteArray) { + let length: number = body ? body.length : 0; + + let buffer: egret.ByteArray = new egret.ByteArray(); + buffer.writeByte(type & 0xff); + buffer.writeByte((length >> 16) & 0xff); + buffer.writeByte((length >> 8) & 0xff); + buffer.writeByte(length & 0xff); + + if (body) buffer.writeBytes(body, 0, body.length); + + return buffer; + } + public decode(buffer: egret.ByteArray) { + + let type: number = buffer.readUnsignedByte(); + let len: number = (buffer.readUnsignedByte() << 16 | buffer.readUnsignedByte() << 8 | buffer.readUnsignedByte()) >>> 0; + + let body: egret.ByteArray; + + if (buffer.bytesAvailable >= len) { + body = new egret.ByteArray(); + if (len) buffer.readBytes(body, 0, len); + } + else { + console.log('[Package] no enough length for current type:', type); + } + + return { type: type, body: body, length: len }; + } +} + +class Message implements IMessage { + + public static MSG_FLAG_BYTES: number = 1; + public static MSG_ROUTE_CODE_BYTES: number = 2; + public static MSG_ID_MAX_BYTES: number = 5; + public static MSG_ROUTE_LEN_BYTES: number = 1; + + public static MSG_ROUTE_CODE_MAX: number = 0xffff; + + public static MSG_COMPRESS_ROUTE_MASK: number = 0x1; + public static MSG_TYPE_MASK: number = 0x7; + + static TYPE_REQUEST: number = 0; + static TYPE_NOTIFY: number = 1; + static TYPE_RESPONSE: number = 2; + static TYPE_PUSH: number = 3; + + constructor(private routeMap: any) { + + } + + public encode(id: number, route: string, msg: any) { + let buffer: egret.ByteArray = new egret.ByteArray(); + + let type: number = id ? Message.TYPE_REQUEST : Message.TYPE_NOTIFY; + + let byte: egret.ByteArray = Protobuf.encode(route, msg) || Protocol.strencode(JSON.stringify(msg)); + + let rot: any = Routedic.getID(route) || route; + + buffer.writeByte((type << 1) | ((typeof (rot) === 'string') ? 0 : 1)); + + if (id) { + // 7.x + do { + let tmp: number = id % 128; + let next: number = Math.floor(id / 128); + + if (next !== 0) { + tmp = tmp + 128; + } + + buffer.writeByte(tmp); + + id = next; + } while (id !== 0); + + // 5.x + // var len:Array = []; + // len.push(id & 0x7f); + // id >>= 7; + // while(id > 0) + // { + // len.push(id & 0x7f | 0x80); + // id >>= 7; + // } + // + // for (var i:int = len.length - 1; i >= 0; i--) + // { + // buffer.writeByte(len[i]); + // } + } + + if (rot) { + if (typeof rot === 'string') { + buffer.writeByte(rot.length & 0xff); + buffer.writeUTFBytes(rot); + } + else { + buffer.writeByte((rot >> 8) & 0xff); + buffer.writeByte(rot & 0xff); + } + } + + if (byte) { + buffer.writeBytes(byte); + } + + return buffer; + } + + public decode(buffer: egret.ByteArray): any { + // parse flag + let flag: number = buffer.readUnsignedByte(); + let compressRoute: number = flag & Message.MSG_COMPRESS_ROUTE_MASK; + let type: number = (flag >> 1) & Message.MSG_TYPE_MASK; + let route: any; + + // parse id + let id: number = 0; + if (type === Message.TYPE_REQUEST || type === Message.TYPE_RESPONSE) { + // 7.x + let i: number = 0; + let m: number; + do { + m = buffer.readUnsignedByte(); + id = id + ((m & 0x7f) * Math.pow(2, (7 * i))); + i++; + } while (m >= 128); + + // 5.x + // var byte:int = buffer.readUnsignedByte(); + // id = byte & 0x7f; + // while(byte & 0x80) + // { + // id <<= 7; + // byte = buffer.readUnsignedByte(); + // id |= byte & 0x7f; + // } + } + + // parse route + if (type === Message.TYPE_REQUEST || type === Message.TYPE_NOTIFY || type === Message.TYPE_PUSH) { + + if (compressRoute) { + route = buffer.readUnsignedShort(); + } + else { + let routeLen: number = buffer.readUnsignedByte(); + route = routeLen ? buffer.readUTFBytes(routeLen) : ''; + } + } + else if (type === Message.TYPE_RESPONSE) { + route = this.routeMap[id]; + } + + if (!id && !(typeof (route) === 'string')) { + route = Routedic.getName(route); + } + + let body: any = Protobuf.decode(route, buffer) || JSON.parse(Protocol.strdecode(buffer)); + + return { id: id, type: type, route: route, body: body }; + } + +} +class Protocol { + + public static strencode(str: string): egret.ByteArray { + let buffer: egret.ByteArray = new egret.ByteArray(); + buffer.length = str.length; + buffer.writeUTFBytes(str); + return buffer; + } + + public static strdecode(byte: egret.ByteArray): string { + return byte.readUTFBytes(byte.bytesAvailable); + } +} +class Protobuf { + static TYPES: any = { + uInt32: 0, + sInt32: 0, + int32: 0, + double: 1, + string: 2, + message: 2, + float: 5 + }; + private static _clients: any = {}; + private static _servers: any = {}; + + static init(protos: any): void { + this._clients = protos && protos.client || {}; + this._servers = protos && protos.server || {}; + } + + static encode(route: string, msg: any): egret.ByteArray { + + let protos: any = this._clients[route]; + + if (!protos) return null; + + return this.encodeProtos(protos, msg); + } + + static decode(route: string, buffer: egret.ByteArray): any { + + let protos: any = this._servers[route]; + + if (!protos) return null; + + return this.decodeProtos(protos, buffer); + } + private static encodeProtos(protos: any, msg: any): egret.ByteArray { + let buffer: egret.ByteArray = new egret.ByteArray(); + + for (let name in msg) { + if (protos[name]) { + let proto: any = protos[name]; + + switch (proto.option) { + case 'optional': + case 'required': + buffer.writeBytes(this.encodeTag(proto.type, proto.tag)); + this.encodeProp(msg[name], proto.type, protos, buffer); + break; + case 'repeated': + if (!!msg[name] && msg[name].length > 0) { + this.encodeArray(msg[name], proto, protos, buffer); + } + break; + } + } + } + + return buffer; + } + static decodeProtos(protos: any, buffer: egret.ByteArray): any { + let msg: any = {}; + + while (buffer.bytesAvailable) { + let head: any = this.getHead(buffer); + let name: string = protos.__tags[head.tag]; + + switch (protos[name].option) { + case 'optional': + case 'required': + msg[name] = this.decodeProp(protos[name].type, protos, buffer); + break; + case 'repeated': + if (!msg[name]) { + msg[name] = []; + } + this.decodeArray(msg[name], protos[name].type, protos, buffer); + break; + } + } + + return msg; + } + + static encodeTag(type: number, tag: number): egret.ByteArray { + let value: number = this.TYPES[type] !== undefined ? this.TYPES[type] : 2; + + return this.encodeUInt32((tag << 3) | value); + } + static getHead(buffer: egret.ByteArray): any { + let tag: number = this.decodeUInt32(buffer); + + return { type: tag & 0x7, tag: tag >> 3 }; + } + static encodeProp(value: any, type: string, protos: any, buffer: egret.ByteArray): void { + switch (type) { + case 'uInt32': + buffer.writeBytes(this.encodeUInt32(value)); + break; + case 'int32': + case 'sInt32': + buffer.writeBytes(this.encodeSInt32(value)); + break; + case 'float': + // Float32Array + let floats: egret.ByteArray = new egret.ByteArray(); + floats.endian = egret.Endian.LITTLE_ENDIAN; + floats.writeFloat(value); + buffer.writeBytes(floats); + break; + case 'double': + let doubles: egret.ByteArray = new egret.ByteArray(); + doubles.endian = egret.Endian.LITTLE_ENDIAN; + doubles.writeDouble(value); + buffer.writeBytes(doubles); + break; + case 'string': + buffer.writeBytes(this.encodeUInt32(value.length)); + buffer.writeUTFBytes(value); + break; + default: + let proto: any = protos.__messages[type] || this._clients['message ' + type]; + if (!!proto) { + let buf: egret.ByteArray = this.encodeProtos(proto, value); + buffer.writeBytes(this.encodeUInt32(buf.length)); + buffer.writeBytes(buf); + } + break; + } + } + + static decodeProp(type: string, protos: any, buffer: egret.ByteArray): any { + switch (type) { + case 'uInt32': + return this.decodeUInt32(buffer); + case 'int32': + case 'sInt32': + return this.decodeSInt32(buffer); + case 'float': + let floats: egret.ByteArray = new egret.ByteArray(); + buffer.readBytes(floats, 0, 4); + floats.endian = egret.Endian.LITTLE_ENDIAN; + let float: number = buffer.readFloat(); + return floats.readFloat(); + case 'double': + let doubles: egret.ByteArray = new egret.ByteArray(); + buffer.readBytes(doubles, 0, 8); + doubles.endian = egret.Endian.LITTLE_ENDIAN; + return doubles.readDouble(); + case 'string': + let length: number = this.decodeUInt32(buffer); + return buffer.readUTFBytes(length); + default: + let proto: any = protos && (protos.__messages[type] || this._servers['message ' + type]); + if (proto) { + let len: number = this.decodeUInt32(buffer); + let buf: egret.ByteArray; + if (len) { + buf = new egret.ByteArray(); + buffer.readBytes(buf, 0, len); + } + + return len ? Protobuf.decodeProtos(proto, buf) : false; + } + break; + } + } + + static isSimpleType(type: string): boolean { + return ( + type === 'uInt32' || + type === 'sInt32' || + type === 'int32' || + type === 'uInt64' || + type === 'sInt64' || + type === 'float' || + type === 'double' + ); + } + static encodeArray(array: Array, proto: any, protos: any, buffer: egret.ByteArray): void { + let isSimpleType = this.isSimpleType; + if (isSimpleType(proto.type)) { + buffer.writeBytes(this.encodeTag(proto.type, proto.tag)); + buffer.writeBytes(this.encodeUInt32(array.length)); + let encodeProp = this.encodeProp; + for (let i: number = 0; i < array.length; i++) { + encodeProp(array[i], proto.type, protos, buffer); + } + } else { + let encodeTag = this.encodeTag; + for (let j: number = 0; j < array.length; j++) { + buffer.writeBytes(encodeTag(proto.type, proto.tag)); + this.encodeProp(array[j], proto.type, protos, buffer); + } + } + } + static decodeArray(array: Array, type: string, protos: any, buffer: egret.ByteArray): void { + let isSimpleType = this.isSimpleType; + let decodeProp = this.decodeProp; + + if (isSimpleType(type)) { + let length: number = this.decodeUInt32(buffer); + for (let i: number = 0; i < length; i++) { + array.push(decodeProp(type, protos, buffer)); + } + } else { + array.push(decodeProp(type, protos, buffer)); + } + } + + static encodeUInt32(n: number): egret.ByteArray { + let result: egret.ByteArray = new egret.ByteArray(); + + do { + let tmp: number = n % 128; + let next: number = Math.floor(n / 128); + + if (next !== 0) { + tmp = tmp + 128; + } + + result.writeByte(tmp); + n = next; + } + while (n !== 0); + + return result; + } + static decodeUInt32(buffer: egret.ByteArray): number { + let n: number = 0; + + for (let i: number = 0; i < buffer.length; i++) { + let m: number = buffer.readUnsignedByte(); + n = n + ((m & 0x7f) * Math.pow(2, (7 * i))); + if (m < 128) { + return n; + } + } + return n; + } + static encodeSInt32(n: number): egret.ByteArray { + n = n < 0 ? (Math.abs(n) * 2 - 1) : n * 2; + + return this.encodeUInt32(n); + } + static decodeSInt32(buffer: egret.ByteArray): number { + let n: number = this.decodeUInt32(buffer); + + let flag: number = ((n % 2) === 1) ? -1 : 1; + + n = ((n % 2 + n) / 2) * flag; + + return n; + } + +} +class Routedic { + private static _ids: any = {}; + private static _names: any = {}; + + static init(dict: any): void { + this._names = dict || {}; + let _names = this._names; + let _ids = this._ids; + for (let name in _names) { + _ids[_names[name]] = name; + } + } + + static getID(name: string) { + return this._names[name]; + } + static getName(id: number) { + return this._ids[id]; + } +} + +interface IMessage { + /** + * encode + * @param id + * @param route + * @param msg + * @return ByteArray + */ + encode(id: number, route: string, msg: any): egret.ByteArray; + + /** + * decode + * @param buffer + * @return Object + */ + decode(buffer: egret.ByteArray): any; +} +interface IPackage { + + encode(type: number, body?: egret.ByteArray): egret.ByteArray; + + decode(buffer: egret.ByteArray): any; +} + diff --git a/game-server/test/comBattle.test.ts b/game-server/test/comBattle.test.ts index 666f7e041..259f84719 100644 --- a/game-server/test/comBattle.test.ts +++ b/game-server/test/comBattle.test.ts @@ -73,6 +73,15 @@ describe('寻宝创建队伍', function() { }); it('两个玩家匹配到结算', function(done) { + pinusClient.on('onTeammateAct', (msg) => { + console.log('onTeammateAct: ', msg); + }); + pinusClient.on('onComBtlStart', (msg) => { + console.log('onComBtlStart: ', msg); + }); + pinusClient.on('onTeamJoin', (msg) => { + console.log('onTeamJoin: ', msg); + }); pinusClient.request('battle.comBattleHandler.createTeam', createTeamParms, (res) => { checkSuccessResponse(res); expect(res.data.teamCode).to.be.a('string');