private void LoginLobby(string url, string user, string pass)
{
if (GlobalVariables.Instance.IsFullClient)
{
m_Url = url;
m_User = user;
m_Pass = pass;
m_Guid = 1;
GfxSystem.PublishGfxEvent("ge_start_login", "lobby", "user", 0);
GfxSystem.PublishGfxEvent("ge_init_userinfo", "lobby", user, user, (int)m_Guid, 100);
}
else
{
if (IsConnected)
{
m_WebSocket.Close();
}
m_IsWaitStart = false;
m_IsLogged = false;
m_Url = url;
m_User = user;
m_Pass = pass;
ConnectIfNotOpen();
}
GfxSystem.GfxLog("LoginLobby {0} {1} {2}", url, user, pass);
}
private void HandleStartGameResult(int id, JsonData msg)
{
int sceneType = msg.GetInt("m_SceneType");
uint key = msg.GetUint("m_Key");
string ip = msg.GetString("m_ServerIp");
int port = msg.GetInt("m_ServerPort");
int heroId = msg.GetInt("m_HeroId");
int campId = msg.GetInt("m_CampId");
int weaponId = msg.GetInt("m_WeaponId");
int sceneId = msg.GetInt("m_SceneType");
Data_SceneConfig cfg = SceneConfigProvider.Instance.GetSceneConfigById(sceneType);
if (null == cfg || cfg.m_Type == (int)SceneTypeEnum.TYPE_PVE)
{
NetworkSystem.Instance.HeroId = heroId;
NetworkSystem.Instance.CampId = campId;
NetworkSystem.Instance.SceneId = sceneId;
}
else
{
NetworkSystem.Instance.Start(key, ip, port, heroId, campId, sceneId);
}
GameControler.ChangeScene((int)msg["m_SceneType"]);
GfxSystem.GfxLog("HandleStartGameResult");
}
private void OnRecvMessage()
{
m_NetClient.MessageReceivedEvent.WaitOne(1000);
NetIncomingMessage im;
while ((im = m_NetClient.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
LogSystem.Debug("Debug Message: {0}", im.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
LogSystem.Debug("Error Message: {0}", im.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
LogSystem.Debug("Warning Message: {0}", im.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = im.SenderConnection.Status;
string reason = im.ReadString();
LogSystem.Debug("Network Status Changed:{0} Reason:{1}\nStatistic:{2}", status.ToString(), reason, im.SenderConnection.Statistics.ToString());
if (NetConnectionStatus.Disconnected == status)
{
m_IsConnected = false;
}
else if (NetConnectionStatus.Connected == status)
{
OnConnected(im.SenderConnection);
}
break;
case NetIncomingMessageType.Data:
if (m_IsConnected == false)
{
break;
}
try {
object msg = Serialize.Decode(im.ReadBytes(im.LengthBytes));
if (msg != null)
{
PushMsg(msg, im.SenderConnection);
}
} catch (Exception ex) {
GfxSystem.GfxLog("Decode Message exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
break;
default:
break;
}
m_NetClient.Recycle(im);
}
}
private void SendHeartbeat()
{
CLJsonMsgHeartbeat msg = new CLJsonMsgHeartbeat();
msg.m_Guid = m_Guid;
SendTextMessage(msg);
GfxSystem.GfxLog("Send User Heartbeat : {0} , Time : {1}", m_UserHeartbeatCount++, DateTime.Now.ToString());
}
private void HandleLoginResult(int id, JsonData msg)
{
if (0 == msg.GetInt("m_Result"))
{
GfxSystem.PublishGfxEvent("ge_start_login", "lobby", "user", 0);
}
GfxSystem.GfxLog("HandleLoginResult");
}
private void webSocketClient_MessageReceived(object sender, MessageReceivedEventArgs e)
{
//收到消息后进行处理
string rawMsgString = e.Message;
GfxSystem.GfxLog("==> Websocket Recived Message: {0}", rawMsgString);
LogSystem.Info("==> Websocket Recived Message: {0}", rawMsgString);
try
{
WebSocketMessageTypes websocketMsgType = GetWebSocketMessageType(rawMsgString);
if (websocketMsgType == WebSocketMessageTypes.Event)
{
//处理事件消息
JsonMessage msg = null;
string jsonMsgString = "";
string eventName = HandleRawMsg(rawMsgString, out jsonMsgString);
int msgId = int.Parse(eventName);
Type type = m_JsonMsgDispatcher.GetMessageType(msgId);
msg = JsonConvert.DeserializeObject(jsonMsgString, type) as JsonMessage;
if (msg != null)
{
msg.m_ID = msgId;
m_JsonMsgDispatcher.HandleJsonMessage(msg);
}
}
else if (websocketMsgType == WebSocketMessageTypes.Message)
{
GfxSystem.GfxLog("!!!!!! Text Message: {0}", rawMsgString);
int msgId = 0;
JsonMessage msg = null;
string[] rawArgs = rawMsgString.Split(SPLITTER_VERTICAL, 2);
if (rawArgs.Length == 2)
{
int id;
if (int.TryParse(rawArgs[0], out id))
{
msgId = id;
}
GfxSystem.GfxLog("!!!!!! Client recive message id : {0}", msgId);
Type type = m_JsonMsgDispatcher.GetMessageType(msgId);
msg = JsonConvert.DeserializeObject(rawArgs[1], type) as JsonMessage;
if (msg != null)
{
GfxSystem.GfxLog("!!!!!! Client recive message: {0}", msg);
}
}
}
else if (websocketMsgType == WebSocketMessageTypes.Heartbeat)
{
//向node.js回复心跳消息
AnswerHeartbeat();
}
}
catch (System.Exception ex)
{
GfxSystem.GfxLog("Recived Message Error:{0} ", ex);
}
}
private void LoginLobby(string ip, int port, string user, string passwd)
{
GfxSystem.GfxLog("LoginLobby:{0}:{1} {2}/{3}", ip, port, user, passwd);
m_Address = string.Format("http://{0}:{1}", ip, port);
m_Uri = new Uri(m_Address);
ConnectIfNotOpen();
m_Account = user;
m_Password = passwd;
m_IsWaitStart = false;
}
private void OnError(object sender, SocketIOClient.ErrorEventArgs e)
{
if (null == e.Exception)
{
GfxSystem.GfxLog("LobbyNetworkSystem.OnError:{0}", e.Message);
}
else
{
GfxSystem.GfxLog("LobbyNetworkSystem.OnError:{0} Exception:{1}\n{2}", e.Message, e.Exception.Message, e.Exception.StackTrace);
}
}
internal bool SendMessage(string msgStr)
{
bool ret = false;
if (null != m_WebSocket && m_WebSocket.IsConnected)
{
m_WebSocket.Send(msgStr);
GfxSystem.GfxLog("SendToLobby {0}", msgStr);
ret = true;
}
return(ret);
}
private void OnOpened(object sender, EventArgs e)
{
JsonData loginMsg = new JsonData();
loginMsg["m_Account"] = m_User;
loginMsg["m_Passwd"] = m_Pass;
loginMsg["m_Ip"] = "127.0.0.1";
loginMsg["m_MacAddr"] = "FFFFFFFFFFFF";
SendMessage(JsonMessageID.Login, loginMsg);
GfxSystem.GfxLog("LobbyConnect opened.");
}
private void HandleUserInfo(int id, JsonData msg)
{
m_Guid = msg.GetUlong("m_Guid");
string account = msg.GetString("m_Account");
string nick = msg.GetString("m_Nick");
int level = msg.GetInt("m_Level");
m_IsLogged = true;
GfxSystem.PublishGfxEvent("ge_init_userinfo", "lobby", account, nick, (int)m_Guid, level);
GfxSystem.GfxLog("HandleUserInfo");
}
public void SendEventMessage(JsonMessage msg)
{
try {
if (msg != null)
{
string s = JsonConvert.SerializeObject(msg);
string msgStr = "5:::{\"name\":\"" + msg.m_ID.ToString() + "\",\"args\":[" + s + "]}";
this.SendMessage(msgStr);
}
} catch (System.Exception ex) {
GfxSystem.GfxLog("Build Json Message String Error: {0}", ex);
}
}
public void Start(uint key, string ip, int port, int heroId, int campId, int sceneId)
{
m_Key = key;
m_Ip = ip;
m_Port = port;
m_HeroId = heroId;
m_CampId = campId;
m_SceneId = sceneId;
m_IsWaitStart = false;
m_IsConnected = false;
GfxSystem.GfxLog("NetworkSystem.Start key {0} ip {1} port {2} hero {3} camp {4} scene {5}", key, ip, port, heroId, campId, sceneId);
}
private void HandleStartGameResult(JsonMessage msg)
{
LCJsonMsgStartGameResult lcMsg = msg as LCJsonMsgStartGameResult;
if (lcMsg != null)
{
GfxSystem.GfxLog("!!!!! Start Game Args:{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}",
lcMsg.m_Guid, lcMsg.m_ServerIp, lcMsg.m_ServerPort, lcMsg.m_Key, lcMsg.m_CampId, lcMsg.m_HeroId, lcMsg.m_WeaponId, lcMsg.m_SceneType);
GfxSystem.LoadScene("Test");
NetWorkSystem.Instance.Start(lcMsg.m_Key, lcMsg.m_ServerIp, (int)lcMsg.m_ServerPort, lcMsg.m_HeroId, lcMsg.m_CampId);
GameControler.ChangeScene(lcMsg.m_SceneType);
}
}
private void webSocketClient_Opened(object sender, EventArgs e)
{
GfxSystem.GfxLog("Websocket Opened");
if (!m_IsLogged)
{
CLJsonMsgLogin loginMsg = new CLJsonMsgLogin();
loginMsg.m_Account = m_Account;
loginMsg.m_Passwd = m_Password;
loginMsg.m_IP = "127.0.0.1";
loginMsg.m_MacAddr = "6666666";
SendTextMessage(loginMsg);
m_Password = "";
m_IsLogged = true;
}
}
private static void HandleNodeMessage(int id, JsonData msg)
{
if (s_Inited && msg != null)
{
JsonMessageHandlerDelegate handler = s_MessageHandlers[id];
if (handler != null)
{
try {
handler(id, msg);
} catch (Exception ex) {
GfxSystem.GfxLog("[Exception] HandleNodeMessage:{0} throw:{1}\n{2}", id, ex.Message, ex.StackTrace);
}
}
}
}
private void ConnectIfNotOpen()
{
if (!IsConnected)
{
m_IsLogged = false;
m_LastConnectTime = TimeUtility.GetLocalMilliseconds();
GfxSystem.GfxLog("ConnectIfNotOpen at time {0}", m_LastConnectTime);
m_WebSocket = new SocketIOClient.Client(m_Url);
m_WebSocket.Opened += OnOpened;
m_WebSocket.Error += OnError;
m_WebSocket.SocketConnectionClosed += OnClosed;
m_WebSocket.Message += OnMessageReceived;
m_WebSocket.Connect();
}
}
public void SendTextMessage(JsonMessage msg)
{
try
{
if (msg != null)
{
string jsonStr = JsonConvert.SerializeObject(msg);
string bodyStr = string.Format("{0}|{1}|{2}", msg.m_ID, m_Guid, jsonStr);;
string msgStr = "3:::" + bodyStr;
this.SendMessage(msgStr);
}
}
catch (System.Exception ex)
{
GfxSystem.GfxLog("Build Json Message String Error: {0}", ex);
}
}
public void Tick()
{
try {
if (m_NetClient == null)
{
return;
}
if (m_IsConnected)
{
if (TimeUtility.GetLocalMilliseconds() - m_LastPingTime >= m_PingInterval)
{
InternalPing();
}
}
ProcessMsg();
} catch (Exception e) {
string err = "Exception:" + e.Message + "\n" + e.StackTrace + "\n";
GfxSystem.GfxLog("Exception:{0}\n{1}", e.Message, e.StackTrace);
}
}
private static unsafe JsonData DecodeJsonMessage(string msgStr, out int id)
{
JsonData msg = null;
id = 0;
if (s_Inited)
{
try {
GfxSystem.GfxLog("DecodeJsonMessage:{0}", msgStr);
int ix = msgStr.IndexOf('|');
if (ix > 0)
{
id = int.Parse(msgStr.Substring(0, ix));
msg = JsonMapper.ToObject(msgStr.Substring(ix + 1));
}
} catch (Exception ex) {
GfxSystem.GfxLog("[Exception] DecodeJsonMessage:{0} throw:{1}\n{2}", msgStr, ex.Message, ex.StackTrace);
}
}
return(msg);
}
private void ConnectIfNotOpen()
{
if (!(this.m_ReadyState == WebSocketState.Connecting || this.m_ReadyState == WebSocketState.Open))
{
try {
m_Handshake = RequestHandshake(m_Uri);
if (m_Handshake == null || m_Handshake.SID.Trim() == string.Empty || m_Handshake.HadError)
{
GfxSystem.GfxLog("Failed to request socketio handshake ");
}
else
{
string wsScheme = (m_Uri.Scheme == Uri.UriSchemeHttps ? "wss" : "ws");
m_WebsocketClient = new WebSocket(
string.Format("{0}://{1}:{2}/socket.io/1/websocket/{3}", wsScheme, m_Uri.Host, m_Uri.Port, m_Handshake.SID),
string.Empty,
m_SocketVersion);
m_WebsocketClient.EnableAutoSendPing = false;
m_WebsocketClient.add_Opened(new EventHandler <EventArgs>(webSocketClient_Opened));
m_WebsocketClient.add_Closed(new EventHandler <EventArgs>(webSocketClient_Closed));
m_WebsocketClient.add_Error(new EventHandler <ErrorEventArgs>(webSocketClient_Error));
m_WebsocketClient.add_MessageReceived(new EventHandler <MessageReceivedEventArgs>(webSocketClient_MessageReceived));
/*
* m_WebsocketClient.Opened += this.webSocketClient_Opened;
* m_WebsocketClient.MessageReceived += this.webSocketClient_MessageReceived;
* m_WebsocketClient.Closed += webSocketClient_Closed;
* m_WebsocketClient.Error += this.webSocketClient_Error;
*/
m_WebsocketClient.Open();
m_LastConnectTime = TimeUtility.GetLocalMilliseconds();
GfxSystem.GfxLog("Try to Open ... {0}", DateTime.Now.ToString());
}
} catch (Exception ex) {
GfxSystem.GfxLog("Websocket connect error : " + ex.ToString());
}
}
}
private void CloseWebSocketClient()
{
if (this.m_WebsocketClient != null)
{
// unwire events
m_WebsocketClient.remove_Opened(new EventHandler <EventArgs>(webSocketClient_Opened));
m_WebsocketClient.remove_Closed(new EventHandler <EventArgs>(webSocketClient_Closed));
m_WebsocketClient.remove_Error(new EventHandler <ErrorEventArgs>(webSocketClient_Error));
m_WebsocketClient.remove_MessageReceived(new EventHandler <MessageReceivedEventArgs>(webSocketClient_MessageReceived));
/*
* this.m_WebsocketClient.Closed -= this.webSocketClient_Closed;
* this.m_WebsocketClient.MessageReceived -= webSocketClient_MessageReceived;
* this.m_WebsocketClient.Error -= webSocketClient_Error;
* this.m_WebsocketClient.Opened -= this.webSocketClient_Opened;
*/
if (this.m_WebsocketClient.State == WebSocketState.Connecting || this.m_WebsocketClient.State == WebSocketState.Open)
{
try { this.m_WebsocketClient.Close(); }
catch { GfxSystem.GfxLog("exception raised trying to close websocket: can safely ignore, socket is being closed"); }
}
this.m_WebsocketClient = null;
}
}
private void webSocketClient_Error(object sender, EventArgs e)
{
GfxSystem.GfxLog("Websocket Error : " + e.ToString());
}
private void SendMessage(string msgStr)
{
GfxSystem.GfxLog("Websocket Send Message ==> {0}", msgStr);
m_WebsocketClient.Send(msgStr);
}
private void webSocketClient_Closed(object sender, EventArgs e)
{
GfxSystem.GfxLog("Websocket Closed ");
CloseWebSocketClient();
}
private void HandleFindTeamResult(int id, JsonData msg)
{
GfxSystem.GfxLog("HandleFindTeamResult");
}
