您的位置：首页 > 移动开发 > Cocos引擎

使用cocoscreator + node.js + websocket实现简单的聊天服务

2019-07-26 20:08 621 查看

转载：https://www.geek-share.com/detail/2750847500.html
我觉得很有学习意义~~
若有不妥。请联系我删除！
先上个效果图：

使用cocoscreator 1.9.1 + node.js + websocket实现，没有使用socket.io, 全部自己封装，长连接进行封装后可以和短连接使用方法一样，使用简单，方便以后开发网络游戏。

1、客户端：

主要就是聊天内容的显示，自动换行和背景扩展，代码大概如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
cc.Class({
extends: cc.Component,

properties: {
msgLabel: cc.Label,
uidLabel: cc.Label,
msgLayout: cc.Layout,
msgBg: cc.Node,
maxLen: 500,
},

// LIFE-CYCLE CALLBACKS:

// onLoad () {},

start () {
this.node.runAction(cc.fadeTo(0.5, 255))
},

initMsg(msg, uid){
this.msgLabel.string = msg;
this.uidLabel.string = uid;

this.msgLabel.overflow = cc.Label.Overflow.NONE;
// this.msgBg.width = this.msgLabel.node.width + 10;
// this.msgBg.height = this.msgLabel.node.height + 10;
// this.node.height = this.msgBg.height + 40;

this.scheduleOnce((dt)=>{
if ( this.msgLabel.node.width >= this.maxLen){
this.msgLabel.overflow = cc.Label.Overflow.RESIZE_HEIGHT;
this.msgLabel.node.width = this.maxLen;
}

this.msgBg.width = this.msgLabel.node.width + 10;
this.msgBg.height = this.msgLabel.node.height + 10;
this.node.height = this.msgBg.height + 40;

}, 0);

this.node.opacity = 0;
}

// update (dt) {},

});
　　网络部分分成了四层：

1、socket 封装基础的websocket, 这里是最底层，也是真正链接的开始

2、network 控制socket链接层，实现各回调接口

3、netproxy 封装各服务功能，把长连接变成短连接的请求方式

4、netprotocols 和服务器协商，确定每个请求的请求体格式和回复格式

各部分代码如下：

GameWebSocket.js:

复制代码
/**

@enum {number}
*/
var GameWebSocketState = cc.Enum({
CONNECTING: 1,
OPEN: 2,
CLOSING: 3,
CLOSED: 4
});

/**

@interface
*/
var GameWebSocketDelegate = cc.Class({

onSocketOpen: function () {

},

/**
收到了消息
@param {string|Uint8Array} data
*/
onSocketMessage: function (data) {

onSocketError: function () {

/**

连接关闭
@param {string} reason
*/
onSocketClosed: function (reason) {

}
});

/**

@interface
*/
var GameWebSocketInterface = cc.Class({

connect: function () {

},

send: function () {

},

close: function () {

},

getState: function () {

}
});

var GameWebSocket = cc.Class({
extends: GameWebSocketInterface,

properties: {

/**
* @type {String} 服务器地址
*/
_address: null,

/**
* @type {GameWebSocketDelegate}
*/
_delegate: null,

/**
* @type {WebSocket}
*/
_webSocket: null,
},

/**
* @param {string} address 服务器地址
* @param {GameWebSocketDelegate} delegate 回调接口
*/
init: function(address, delegate){
this._address = address;
this._delegate = delegate;
this._webSocket = null;
},

connect: function () {
cc.log('connect to '+ this._address);

var ws = this._webSocket = new WebSocket(this._address);
ws.onopen = this._delegate.onSocketOpen.bind(this._delegate);
ws.onmessage = function (param) {
this._delegate.onSocketMessage(param.data);
}.bind(this);
ws.onerror = this._delegate.onSocketError.bind(this._delegate);
// function({code: Number, reason: String, wasClean: Boolean})}
ws.onclose = function (param) {
this._delegate.onSocketClosed(param.reason);
}.bind(this);
},

/**
* 发送数据
* @param {string|Uint8Array} stringOrBinary
*/
send: function (stringOrBinary) {
this._webSocket.send(stringOrBinary);
},

close: function () {
if (!this._webSocket) {
return;
}

try {
this._webSocket.close();
} catch (err) {
cc.log('error while closing webSocket', err.toString());
}
this._webSocket = null;
},

getState: function () {
if (this._webSocket) {
switch(this._webSocket.readyState){
case WebSocket.OPEN:
return GameWebSocketState.OPEN;
case WebSocket.CONNECTING:
return GameWebSocketState.CONNECTING;
case WebSocket.CLOSING:
return GameWebSocketState.CLOSING;
case WebSocket.CLOSED:
return GameWebSocketState.CLOSED;
}
}
return GameWebSocketState.CLOSED;
}

});

module.exports = {
GameWebSocketState: GameWebSocketState,
GameWebSocketDelegate: GameWebSocketDelegate,
GameWebSocketInterface: GameWebSocketInterface,
GameWebSocket: GameWebSocket
};
复制代码
　　GameNetwork.js

复制代码
/**

Created by skyxu on 2018/10/9.
*/

“use strict”;

let GameWebSocket = require("./GameWebSocket");
let GameProtocols = require("./GameProtocols");

/**

服务器回复消息状态，判断回复消息的各种问题
*/
var response_state = {
ERROR_OK : ‘0’
};

/**

请求回调对象，收到服务器回调后的回调方法
*/
var NetworkCallback = cc.Class({

properties: {
```
/**
* @type {BaseRequest} request
*/
request: null,

/**
* 请求回调对方法
*/
callback: null
```
},

/**
@param {BaseRequest} request
@param {function(BaseResponse): boolean} callback
*/
init: function (request, callback) {
this.request = request;
this.callback = callback;
}
});

let GameNetwork = cc.Class({
extends: GameWebSocket.GameWebSocketDelegate,

ctor: function() {
this._socket = null;

this._delegate = null;

/**
* 每次发送请求，都需要有一个唯一的编号
* @type {number}
* @private
*/
this._requestSequenceId = 0;

/**
* 接受服务器主动下发的response回调
* key 表示BaseResponse.act
* @type {Object.<string, function(object.<string, *>)>}
*/
this.pushResponseCallback = {};

/**
* 根据seq保存Request和其callback，以便在收到服务器的响应后回调
* @type {Object.<int, NetworkCallback>}
* @private
*/
this._networkCallbacks = {};
},

setDeleg
3ff7
ate: function (delegate) {
this._delegate = delegate;
},

/**
* 注册服务器主动推送的response 回调
*/
registerPushResponseCallback : function(act, callback){
this.pushResponseCallback[act] = callback;
},

/**
* 判断socket已连接成功，可以通信
* @returns {boolean}
*/
isSocketOpened: function(){
return (this._socket && this._socket.getState() == GameWebSocket.GameWebSocketState.OPEN);
},

isSocketClosed: function () {
return this._socket == null;
},

/**
* 启动连接
*/
connect: function (url) {
cc.log("webSocketUrls=" + url);
this._requestSequenceId = 0;
this._socket = new GameWebSocket.GameWebSocket();
this._socket.init(url, this);
this._socket.connect();
},

closeConnect: function () {
if(this._socket){
this._socket.close();
}
},

onSocketOpen: function () {
cc.log('Socket:onOpen');
if(this._delegate && this._delegate.onNetworkOpen){
this._delegate.onNetworkOpen();
}
},

onSocketError: function () {
cc.log('Socket:onError');
},

onSocketClosed: function (reason) {
cc.log('Socket:onClose', reason);
if (this._socket) {
this._socket.close();
}
this._socket = null;

if(this._delegate && this._delegate.onNetworkClose){
this._delegate.onNetworkClose();
}
},

onSocketMessage: function (msg) {
this._onResponse(msg);
},

_onResponse: function(responseData){
cc.log('response->resp:', responseData);
var responseJson = JSON.parse(responseData);
var responseClass = GameProtocols.response_classes[responseJson.act];
/**
* @type {object.<BaseResponse>}
*/
var response = new responseClass();
response.loadData(responseJson.data);
response.act = responseJson.act;
response.seq = responseJson.seq;
response.err = responseJson.err;
response.ts = responseJson.ts;

// 如果指定了回调函数，先回调
var ignoreError = false;
if(response.seq != -1){
// 处理服务器推送消息
var pushCallback = this.pushResponseCallback[response.act];
if(pushCallback){
pushCallback(response);
}

// request回调
var callbackObj = this._networkCallbacks[response.seq];
if(callbackObj){
ignoreError = callbackObj.callback(response);
// try {
//     ignoreError = callbackObj.callback(response);
// } catch (err) {
//     cc.log(err + " error in response callback of " + response.act);
// } finally {
//     delete this._networkCallbacks[response.seq];
// }
}
}

//有错，且不忽略，则统一处理错误
if(response.err && response.err != response_state.ERROR_OK && !ignoreError){
if (response.is_async) {  // 异步请求，如果出错了，应该需要重新登录
// todo 重新登录？或者重新同步数据？
} else {  // 同步请求，如果出错了，需要显示错误信息
// todo 显示错误
var msg = responseJson.msg;
cc.log('server err ' + msg);
}
}
},

/**
* 向服务器发送请求。
*
* 如果提供了callback，在收到response后会被回调。如果response是一个错误(status!=ERR_OK)，则需要决定由谁来负责处理错误。
* 如果callback中已经对错误进行了处理，应该返回true，这样会忽略该错误。否则应该返回false，则负责处理该错误。
*
* 特别注意：如果这是一个异步(is_async)请求，且出错，一般来讲应该重新登录/同步。但是如果callback返回了true，不会进行
* 任何处理，也就是不会重新登录/同步。请小心确定返回值。
*
* @param {object.<BaseRequest>}
* @param {function(BaseResponse): boolean=} opt_callback 回调函数。出错的情况下，如果返回true，则不会再次处理错误。
*/
sendRequest: function (request, opt_callback) {
// 每个请求的seq应该唯一，且递增
request.seq = ++this._requestSequenceId;

//生成NetworkCallback对象，绑定请求seq和回调方法
if(opt_callback){
this._networkCallbacks[request.seq] = new NetworkCallback();
this._networkCallbacks[request.seq].init(request, opt_callback);
}
this._sendSocketRequest(false, request);
},

/**
* sendRequest的不发送data字段
*/
sendRequestNoData: function (request, opt_callback) {
// 每个请求的seq应该唯一，且递增
request.seq = ++this._requestSequenceId;

//生成NetworkCallback对象，绑定请求seq和回调方法
if(opt_callback){
this._networkCallbacks[request.seq] = new NetworkCallback();
this._networkCallbacks[request.seq].init(request, opt_callback);
}
this._sendSocketRequest(true, request);
},

/**
* @param {Boolean} isNoData
* @param {object.<BaseRequest>} req
*/
_sendSocketRequest: function (isNoData, req) {
cc.assert(this._socket);

if (this.isSocketOpened()){
//通过json的方法生成请求字符串
var msg = null;
if(isNoData){
msg = JSON.stringify({seq:req.seq, act:req.act});
}else{
msg = JSON.stringify({seq:req.seq, act:req.act, data:req});
}
cc.log("WebSocketDelegate::send->" + msg);
this._socket.send(msg);
} else{
// todo
}
}

});

module.exports = GameNetwork;
复制代码
　　GameProtocols.js

复制代码
/**

Created by skyxu on 2018/10/9.
*/

“use strict”;

/**

消息基类对象，请求消息BaseRequest，回调消息BaseResponse都继承BaseProtocol
/
let BaseProtocol = cc.Class({
ctor: function () {
/*
* 请求动作类型
*/
this.act = ‘’;
```
/**
* 每个请求的sequence_id应该唯一
*/
this.seq = 0;

/**
* 错误代码，0为正常
*/
this.err = 0;

/**
* 是否需要等待服务器回调
*/
this.is_async = false;
```
}
});

/**

请求消息基类，客户端的请求都继承这个类
*/
let BaseRequest = cc.Class({
extends: BaseProtocol
});

/**

服务器返回的消息对应的对象，包含返回数据，一般和BaseRequest成对使用
@class BaseResponse
@extends BaseProtocol
*/
let BaseResponse = cc.Class({
extends: BaseProtocol,

/**

读取返回数据，设置BaseResponse对象
*/
loadData: function (data) {
var key;
for (key in data) {
if(!this.hasOwnProperty(key)){
continue;
}
```
if(data[key] !== undefined && data[key] !== null){
this[key] = data[key];
}
```
}
}
});

let HeartRequest = cc.Class({
extends: BaseRequest,
ctor(){
this.act = ‘heart’;
this.t = -1; // 发送时间
}
});

let HeartResponse = cc.Class({
extends: BaseResponse,

ctor(){
this.act = 'heart';
this.t = -1;
}

});

let ChatRequest = cc.Class({
extends: BaseRequest,
ctor(){
this.act = ‘chat’;
this.msg = ‘’;
this.uid = ‘’;
}
});

let ChatResponse = cc.Class({
extends: BaseResponse,
ctor(){
this.act = ‘chat’;
this.msg = ‘’;
this.uid = ‘’;
}
});

let LoginRequest = cc.Class({
extends: BaseRequest,

ctor: function () {
this.act = 'login';

/**
* facebook用户的accessToken，或游客的UUID
*/
this.token = '';

/**
* token来源，默认0:游客，1:facebook
*/
this.origin = 0;

/**
* 平台: 必须为以下几种之一：android/ios/winphone/pc
*/
this.os = '';

/**
* 平台系统版本
*/
this.osVersion = '';

/**
* 设备产品型号, 示例 iPhone8,2, SM-G 9280
*/
this.deviceModel = '';

/**
* 渠道ID
*/
this.channelId = 0;

/**
* Ios设备广告标示符
*/
this.idfa = '';

/**
* 安卓设备id
*/
this.androidId = '';

/**
* Google广告平台账号，安装了google play的设备可取到
*/
this.googleAid = '';

/**
* 应用版本号
*/
this.appVersion = '';

/**
* 取package name或者bundle id
*/
this.packName = '';

/**
* 设备语言
* @type {string}
*/
this.language = '';

this.locale = "";

}

});

let LoginResponse = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = 'login';

/**
* 游客第一次登录时返回的token，需要客户端保存
*/
this.token = '';

/**
* 离体力下次恢复点的剩余时间秒数
* @type {number}
*/
this.spStepLeftTime = 0;

/**
* 体力恢复周期
* @type {Number}
*/
this.spInterval = 0;

/**
* 农场每天产出量，产出未解锁时为-1
* @type {number}
*/
this.farmDailyOut = -1;

/**
* 农场已产出量
* @type {number}
*/
this.farmCoins = 0;

/**
* 农场产出间隔
* @type {number}
*/
this.farmInterval = null;

/**
* 用json object表示的一个player对象，字段说明参见player json对象
*/
this.me = {};

/**
* 建筑数据数组
* @type {Array}
*/
this.buildings = [];

/**
* 农民数据数组
* @type {Array}
*/
this.farms = [];

/**
* 富豪数据
*/
this.cashking = {};

/**
* 行星配置
*/
this.planetConf = {};

/**
* 农民配置
*/
this.farmConfList = [];

/**
* 其他配置
*/
this.settingConf = {};

/**
* 好友数据
*/
this.friends = [];

/**
* 好友通缉的目标列表
*/
this.helpWantList = [];

/**
* 邮件消息列表
*/
this.newsList = [];

/**
* 复仇列表
*/
this.revengeList = [];

/**
* 商品信息
* @type {Array}
*/
this.rechargeConfs = [];

/**
* 总岛数
* @type {Number}
*/
this.planetConfListSize = 0;

/**
* 他人行星信息对象,仅在转到fire断线重新登录时有效
* @type {Object}
*/
this.fireTarget = null;

/**
* 他人行星信息对象列表,仅在转到steal断线重新登录时有效
* @type {Array}
*/
this.stealTarget = null;
}

});

let LogoutRequest = cc.Class({
extends: BaseRequest,

ctor: function () {
this.act = 'logout';
}

});

let LogoutResponse = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = 'logout';
}

});

/**

绑定fb账号
@extends BaseRequest
*/
let BindFacebookRequest = cc.Class({
extends: BaseRequest,

ctor: function () {
this.act = ‘bindFb’;
```
/**
* facebook用户的accessToken，或游客的UUID
*/
this.token = '';
```
}
});
/**
绑定fb账号
@extends BaseResponse
*/
let BindFacebookResponse = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = ‘bindFb’;
```
/**
* fb数据
*/
this.me = 0;

/**
* fb好友
*/
this.friends = 0;
```
}
});

let SpinRequest = cc.Class({
extends: BaseRequest,

ctor: function () {
this.act = 'spin';

/**
* 倍数
* @type {Number}
*/
this.x = 1;
}

});

let SpinResponse = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = 'spin';

/**
* 摇中的转盘ID
*/
this.hit = 0;

/**
* 转到护盾，但护盾已满时，存在
* @type {number}
*/
this.shieldfull = 0;

/**
* 玩家数据对象
*/
this.me = {};

/**
* 他人行星信息对象,仅在转到fire时有效
* @type {*}
*/
this.fireTarget = {};

/**
* 偷取对象数据
*/
this.stealTarget = [];

/**
* 离体力下次恢复点的剩余时间秒数
* @type {number}
*/
this.spStepLeftTime = 0;

/**
* 体力恢复周期
* @type {Number}
*/
this.spInterval = 0;

/**
* 倍数
* @type {Number}
*/
this.x = 1;
}

});

/**

获取排名
@extends BaseRequest
*/
let RankRequest = cc.Class({
extends: BaseRequest,

ctor: function () {
this.act = ‘rankboard’;
```
/**
* 请求动作类型{ 0全部，1本地，2好友 }
* @type {int}
*/
this.type = 0;
```
}
});
/**
获取排名
@extends BaseResponse
*/
let RankResponse = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = ‘rankboard’;
```
/**
*  我的排名
*/
this.myRank = 0;

/**
* 排名玩家数据
*/
this.men = [];
```
}
});

//push------------------------------------------------------------------------------

/**

推送消息被攻击

@extends BaseResponse
*/
var PushAttackedResponse = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = ‘attacked’;

/**
* 玩家更新数据
*/
this.me = null;

/**
* 建筑数据
*/
this.building = null;

/**
* 敌人
*/
this.hatredman = null;

/**
* 消息
*/
this.news = null;

}
});

/**

推送消息推送消息好友已赠送体力
@extends BaseResponse
*/
var PushSendSpResponse = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = ‘sendSpNotify’;
```
/**
* 好友对象
*/
this.friend = null;
```
}
});

/**

推送消息推送消息好友已领取赠送的体力
@extends BaseResponse
*/
var PushTakeSpResponse = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = ‘takeSpNotify’;
```
/**
* 好友对象
*/
this.friend = null;
```
}
});

/**

推送消息同步好友信息
@extends BaseResponse
*/
var PushSyncFriendInfo = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = ‘friendInfoSync’;
```
/**
* 好友
*/
this.friend = null;
```
}
});

/**

推送消息新增好友
@extends BaseResponse
*/
var PushAddNewFriend = cc.Class({
extends: BaseResponse,

ctor: function () {
```
this.act = 'newFriend';

/**
* 好友
*/
this.friend = null;

/**
* 消息
*/
this.news = null;
```
}
});

/**

debug回调

@extends BaseRequest
*/
let DebugChangeMeRequest = cc.Class({
extends: BaseRequest,

ctor: function () {

this.act = "cmdTest";                    //请求动作类型
this.cmd = "";
//  "player coins add 100", cmd格式：player field value 或者 player field add value
//  Building field [add] value where playerId value type value

}

});
/**

debug回调

@extends BaseResponse
*/
let DebugChangeMeResponse = cc.Class({
extends: BaseResponse,

ctor: function () {
this.act = “cmdTest”;

/**
* 玩家数据
* @type {Object}
*/
this.me = {};

/**
* 体力恢复周期
* @type {Number}
*/
this.spInterval = null;

/*
8000
*
* 体力恢复剩余时间
* @type {Number}
*/
this.spStepLeftTime = null;

/**
* 存钱罐速度
* @type {Number}
*/
this.farmDailyOut = null;

/**
* 存钱罐可回收金币
* @type {Number}
*/
this.farmCoins = null;

/**
* 存钱罐回收周期
* @type {Number}
*/
this.farmInterval = null;

/**
* 岛屿建筑数据
* @type {Array}
*/
this.buildings = null;

}
});

let response_classes = {
login: LoginResponse,
logout: LogoutResponse,
spin: SpinResponse,
bindFb: BindFacebookResponse,
rankboard: RankResponse,
heart: HeartResponse,
chat: ChatResponse,

//push
attacked: PushAttackedResponse,
sendSpNotify: PushSendSpResponse,
takeSpNotify: PushTakeSpResponse,
newFriend: PushAddNewFriend,
friendInfoSync: PushSyncFriendInfo,

// debug
cmdTest: DebugChangeMeResponse,

};

module.exports = {
LoginRequest: LoginRequest,
LoginResponse: LoginResponse,
LogoutRequest: LogoutRequest,
LogoutResponse: LogoutResponse,
SpinRequest: SpinRequest,
SpinResponse: SpinResponse,
BindFacebookRequest: BindFacebookRequest,
BindFacebookResponse: BindFacebookResponse,
RankRequest: RankRequest,
RankResponse: RankResponse,
HeartRequest: HeartRequest,
HeartResponse: HeartResponse,
ChatRequest: ChatRequest,
ChatResponse: ChatResponse,

// debug
DebugChangeMeRequest: DebugChangeMeRequest,
DebugChangeMeResponse: DebugChangeMeResponse,

//push消息
PushAttackedResponse: PushAttackedResponse,
PushSendSpResponse: PushSendSpResponse,
PushTakeSpResponse: PushTakeSpResponse,
PushAddNewFriend: PushAddNewFriend,
PushSyncFriendInfo: PushSyncFriendInfo,

response_classes: response_classes

};
复制代码
　　NetProxy.js

/**

Created by skyxu on 2018/10/9.
*/

“use strict”;

let GameNetwork = require("./GameNetwork");
let GameProtocols = require("./GameProtocols");

let GAME_SERVER_URL = ‘ws://127.0.0.1:3000’;
// GAME_SERVER_URL = ‘wss://echo.websocket.org’;

let NetProxy = cc.Class({
ctor: function () {
this.network = null;
this._cachePushCallback = [];
},

init: function () {
this.network = new GameNetwork();
this.network.setDelegate(this);
this.initPushCallback();
},

connect: function () {
this.network.connect(GAME_SERVER_URL);
},

closeConnect: function () {
this.network.closeConnect();
},

isNetworkOpened: function () {
return this.network.isSocketOpened();
},

isNetworkClosed: function () {
return this.network.isSocketClosed();
},

onNetworkOpen: function () {
Global.eventMgr.emit(Global.config.EVENT_NETWORK_OPENED);
},

onNetworkClose: function () {
Global.eventMgr.emit(Global.config.EVENT_NETWORK_CLOSED);
},

/**
* 注册push回调接口
*/
initPushCallback: function () {
let self = this;
let pushCallback = function (resp) {
self.pushCallback(resp);
};

this.network.registerPushResponseCallback('chat', pushCallback);

// let pushCallback = function(response){
//     if(Util.DNN(farm.game) && farm.game.loginSuccess){
//         this.dealCachePush();
//         this.pushCallback(response);
//     }else{
//         this._cachePushCallback.push(response);
//     }
// }.bind(this);

// this.network.registerPushResponseCallback('attacked', pushCallback);
// this.network.registerPushResponseCallback('acceptWantHelp', pushCallback);
// this.network.registerPushResponseCallback('sendSpNotify', pushCallback);
// this.network.registerPushResponseCallback('takeSpNotify', pushCallback);
// this.network.registerPushResponseCallback('wanted', pushCallback);
// this.network.registerPushResponseCallback('incomplete', pushCallback);
// this.network.registerPushResponseCallback('newFriend', pushCallback);
// this.network.registerPushResponseCallback('news', pushCallback);
// this.network.registerPushResponseCallback('hatredInfoSync', pushCallback);
// this.network.registerPushResponseCallback('friendInfoSync', pushCallback);
},

/**
* 处理缓存push
*/
dealCachePush: function () {
// if(this._cachePushCallback.length > 0){
//     for(var i = 0; i < this._cachePushCallback.length; i++){
//         this.pushCallback(this._cachePushCallback[i]);
//     }
// }
// this._cachePushCallback = [];
},

beatHeart: function (callback) {
let req = new GameProtocols.HeartRequest();
req.t = Date.now();
this.network.sendRequest(req, callback);
},

chat: function (msg) {
let req = new GameProtocols.ChatRequest();
let uid = cc.sys.localStorage.getItem("chat_uid");
req.uid = uid;
req.msg = msg;
this.network.sendRequest(req);
},

/**
* Facebook或者游客登录接口
* @param {Object.<LoginOriginType>} origin
* @param token
*/
login: function (origin, token) {
// let req = new GameProtocols.LoginRequest();
// if(token) req.token = token;
// req.origin = origin;
// req.os = cc.sys.os;
// req.osVersion = cc.sys.osVersion;
// // req.language = cc.sys.language;//farm.FarmPlatformHelper.jsToOc(farm.FarmPlatformHelper.JSB_EVENT_JTO_GetCurrentLanguage);
// /*
//  req.deviceModel = '';
//  req.channelId = 0;
//  req.idfa = '';
//  req.androidId = '';
//  req.googleAid = '';
//  req.appVersion = '';
//  req.packName = '';
//  */
// let callback =  function (resp) {
//     if(resp.err != 0){
//         Global.eventMgr.emit(farm.game.gmConst.SP_EVENT_LOGIN_FAILED, resp);
//         return;
//     }
//     if(resp.token && resp.token.length > 0){
//         farm.localStorage.setItem(farm.game.gmConst.GLS_KEY_GUEST_TOKEN, resp.token);
//     }
//     farm.localStorage.removeItem(farm.game.gmConst.GLS_KEY_IS_LOGOUT);
//
//     //
//     farm.game.initConfig(resp);
//     farm.game.initData(resp);
//     farm.game.loginSuccess = true;
//
//     // js 调取其他平台的sdk，传过去玩家id
//     farm.FarmPlatformHelper.jsToOc(farm.FarmPlatformHelper.JSB_EVENT_JTO_setSessionWithUid, farm.game.player.id.toString());
//     //
//
//     //登录
//     farm.eventManager.emit(farm.game.gmConst.SP_EVENT_LOGIN_SUCCESS);
// };
// this.network.sendRequest(req, callback);

},

/**
* Facebook或者游客登出
*/
logout: function () {
// let req = new GameProtocols.LogoutRequest();
// this.network.sendRequest(req, function (resp) {
//     if(resp.err != 0){
//         cc.log("网络请求---LogoutRequest 失败");
//         farm.eventManager.emit(farm.game.gmConst.SP_EVENT_LOGOUT_FAILED);
//         return;
//     }
//     cc.log("网络请求---LogoutRequest 成功");
//     Global.eventMgr.emit(farm.game.gmConst.SP_EVENT_LOGOUT_SUCCESS);
// });
},

/**
* 绑定fb账号
* @param {String} token
*/
bindFacebook: function (token) {
// let req = new GameProtocols.BindFacebookRequest();
// req.token = token;
// let callback =  function (resp) {
//     //绑定过得逻辑
//     if(resp.err == farm.game.gmConst.ERROR_USER_HAS_REGISTERED){
//         cc.log("网络请求---BindFacebookRequest 已绑定");
//         farm.eventManager.emit(farm.game.gmConst.SP_EVENT_HAS_BIND_FACEBOOK);
//         return;
//     }
//     //绑定失败
//     if(resp.err != 0){
//         cc.log("网络请求---BindFacebookRequest 失败");
//         farm.eventManager.emit(farm.game.gmConst.SP_EVENT_BIND_FACEBOOK_FAILED);
//         return;
//     }
//     //绑定成功
//     cc.log("网络请求---BindFacebookRequest 成功");
//     if(resp.me){
//         farm.game.player.parse(resp.me);
//     }
//     if(resp.friends){
//         farm.game.initFriends(resp.friends);
//     }
//     //绑定成功后删除本地token
//     farm.localStorage.removeItem(farm.game.gmConst.GLS_KEY_GUEST_TOKEN);
//     farm.eventManager.emit(farm.game.gmConst.SP_EVENT_BIND_FACEBOOK_SUCCESS);
// };
// this.network.sendRequest(req, callback);
},

/**
* 启动转盘
*/
spin: function (x) {
// let req = new GameProtocols.SpinRequest();
// if(farm.util.isNumber(x)){
//     req.x = x;
// }
// var callback =  function (resp) {
//     if(resp.err != 0){
//         cc.log("网络请求---spin 失败");
//         farm.eventManager.emit(farm.game.gmConst.SP_EVENT_SPIN_FAILED, resp);
//         return;
//     }
//     cc.log("网络请求---spin 成功");
//     farm.game.player.parse(resp.me);
//     farm.game.spTimer.updateSpTime(resp.spStepLeftTime, resp.spInterval);
//     farm.eventManager.emit(farm.game.gmConst.SP_EVENT_SPIN_SUCCESS, resp);
// };
// this.network.sendRequest(req, callback);
},

/**
* 获取排名
* @param {Number} rankType 0全部，1本地，2好友
*/
getRank: function (rankType) {
// let req = new GameProtocols.RankRequest();
// req.type = rankType;
// let callback =  function (resp) {
//     if(resp.err != 0){
//         cc.log("网络请求---getRank 失败");
//         Global.eventMgr.emit(farm.game.gmConst.SP_EVENT_GET_RANK_FAILED, resp);
//         return;
//     }
//     cc.log("网络请求---getRank 成功");
//     // todo 暂定排名类型
//     resp._rankType = rankType;
//     //farm.game.initLeaderBoardArray(rankType, resp.myRank, resp.men);
//     if(rankType == 2 && resp.men){
//         farm.game.updateFriends(resp.men);
//         resp.men = farm.game.sortFriendsByStar();
//     }
//     Global.eventMgr.emit(farm.game.gmConst.SP_EVENT_GET_RANK_SUCCESS, resp);
// };
// this.network.sendRequest(req, callback);
},

//push回调------------------------------------------------------------------------------

/**
* 推送回调
*/
pushCallback: function (response) {
switch (response.act){
case "sendSpNotify":
case "takeSpNotify":
case "friendInfoSync":
this.pushFriendSendTakeSp(response);
break;
case "stole":
this.pushStole(response);
break;
case "attacked":
this.pushAttacked(response);
break;
case "newFriend":
this.pushAddNewFriend(response);
break;
case "chat":
this.pushChat(response);
break;
}
},
/**
* 好友间互赠体力推送
* @param {PushSendSpResponse|PushTakeSpResponse} resp
*/
pushFriendSendTakeSp: function (resp) {
// cc.log("网络请求---push--- pushFriendSendTakeSp 成功");
// if(resp.friend) farm.game.updateFriends(resp.friend);
// farm.eventManager.emit(farm.game.gmConst.SP_PUSH_EVENT_UPDATE_FRIEND);
},

/**
* 被偷
* @param {PushStolenResponse} resp
*/
pushStole: function (resp) {
// cc.log("网络请求---push--- pushStole 成功");
// if(resp.me) farm.game.player.parse(resp.me);
// //if(resp.building) farm.game.buildings[resp.building.type].parse(resp.building);
// if(resp.hatredman && !farm.game.getHelpWant(resp.hatredman.id)){
//     farm.game.addEnemy(resp.hatredman);
// }
// if(resp.news){
//     resp.news = farm.game.addNews(resp.news);
// }
// farm.eventManager.emit(farm.game.gmConst.SP_PUSH_EVENT_BE_STOLE_SUCCESS, resp);
},

/**
* 被攻击
* @param {PushAttackedResponse} resp
*/
pushAttacked: function (resp) {
// cc.log("网络请求---push--- pushAttacked 成功");
// if(resp.me) {
//     farm.game.player.parse(resp.me);
//     farm.game.dataUpdater.updateStar();
// }
// if(resp.building) farm.game.buildings[resp.building.type].parse(resp.building);
// if(resp.hatredman){
//     farm.game.addBadass(resp.hatredman);
//     if(!farm.game.getHelpWant(resp.hatredman.id)){
//         farm.game.addEnemy(resp.hatredman);
//     }
// }
// if(resp.news){
//     resp.news = farm.game.addNews(resp.news);
// }
// farm.eventManager.emit(farm.game.gmConst.SP_PUSH_EVENT_BE_ATTACK_SUCCESS, resp);
},

/**
* 新增好友
* @param {PushAddNewFriend} resp
*/
pushAddNewFriend: function (resp) {
// cc.log("网络请求---push--- pushAddNewFriend 成功");
// if(resp.friend){
//     resp.friend = farm.game.addFriend(resp.friend);
// }
// if(resp.news){
//     resp.news = farm.game.addNews(resp.news);
// }
// farm.eventManager.emit(farm.game.gmConst.SP_PUSH_EVENT_ADD_FRIEND_SUCCESS, resp);
},

pushChat: function (resp) {
Global.eventMgr.emit(Global.config.EVENT_CHAT, resp);
},

/**
* debug调试请求
* @param {String} name
*/
debug_addCoins: function (name) {
var req = new GameProtocols.DebugChangeMeRequest();
if (name === "btnAddCoins") {
req.cmd = "player coins add 100000000";
} else if (name === "btnClearCoins") {
req.cmd = "player coins 0";
} else if (name === "btnAddEnergy") {
req.cmd = "player sp add 10";
} else if (name === "btnClearEnergy") {
req.cmd = "player sp 0";
} else if (name == "btnAddWp") {
req.cmd = "player wp add 10";
} else if (name == "btnClearWp") {
req.cmd = "player wp 0";
} else if (name == "btnUnwrap"){
req.cmd = "player fbuid null";
} else if (name == "btnWizard1"){
req.cmd = "player wizard1 0";
} else if (name == "btnWizard2"){
req.cmd = "player wizard2 0";
} else if (name == "btnClearShield"){
req.cmd = "player shield 0";
} else if (name == "btnSpEc"){
req.cmd = "SpEc stepInterval 60000";
} else if (name == "btnFarmEc"){
req.cmd = "FarmEc stepInterval 60000";
} else if (name == "btnSpEcBack"){
req.cmd = "SpEc stepInterval 3600000";
} else if (name == "btnFarmBack"){
req.cmd = "FarmEc stepInterval 86400000";
} else if (name == "btnUpdateBuild"){
req.cmd = "Building lv 5";
} else {
req.cmd = name;
}
// var callback = function (resp) {
//     if (resp.err != 0) {
//         return;
//     }
//     farm.game.player.parse(resp.me);
//     farm.game.spTimer.updateSpTime(resp.spStepLeftTime, resp.spInterval);
//     farm.game.dataUpdater.updateCoin();
//     farm.game.dataUpdater.updateSp();
//     farm.game.dataUpdater.updateShield();
//     farm.game.dataUpdater.updateStar();
//     //
//     if((req.cmd == "FarmEc stepInterval 60000" || req.cmd == "FarmEc stepInterval 86400000")
//         && farm.util.isNumber(resp.farmDailyOut)
//         && farm.util.isNumber(resp.farmCoins)){
//         farm.game.piggyBankTimer.init(resp.farmDailyOut, resp.farmCoins, resp.farmInterval);
//     }
//     if(req.cmd == "SpEc stepInterval 60000" || req.cmd == "SpEc stepInterval 3600000"){
//         farm.game.spTimer.updateSpTime(resp.spStepLeftTime, resp.spInterval);
//     }
//     if(resp.buildings){
//         for(var i = 0; i < resp.buildings.length; ++i){
//             farm.game.buildings[i].parse(resp.buildings[i]);
//         }
//         farm.eventManager.emit(farm.game.gmConst.SP_EVENT_UPGRADE_BUILDING_SUCCESS, resp);
//         farm.eventManager.emit(farm.game.gmConst.SP_DEBUG_EVENT_BUILD_TO_24_SUCCESS, resp);
//     }
// };
// this.network.sendRequest(req, callback);
},

});

module.exports = NetProxy;
2、服务端

使用express + express-ws组件，调用WSRouter的init初始化连接即可，

复制代码
let expressWS = require(‘express-ws’);
let work = require(’./work’);

let wsRouter = null;

function WSRouter(app, server){
this.app = app;
this.server = server;
this.clients = [];
expressWS(app, server);

this.listenClientConnection = ()=>{
app.ws('/', (socket, req)=>{
console.log('client connect to server successful.');
this.clients.push(socket);
console.log('clients: ' + this.clients.length);
socket.on('message', (msg)=>{
console.log('on message: ' + msg);
work(this, socket, msg);
});

socket.on('close', (msg)=>{
console.log('on close: ' + msg);
for (let index=0; index<this.clients.length; index++){
if (this.clients[index] == socket){
this.clients.splice(index,1);
}
}
console.log('clients: ' + this.clients.length);
});

socket.on('error', (err)=>{
console.log('on error: ' + error);
});
})
}

}

module.exports = {
init: function(app, server){
if (wsRouter == null){
wsRouter = new WSRouter(app, server);
}
return wsRouter;
}
}
复制代码
复制代码
module.exports = function(wsRouter, ws, msg){
let msgObj = JSON.parse(msg);
switch (msgObj.act){
case ‘heart’:{
msgObj.data.t = Date.now();
ws.send(JSON.stringify(msgObj));
break;
}
case ‘chat’: {
for (let w of wsRouter.clients){
w.send(msg);
}
break;
}

default:
break;
}

}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航