internal void Heartbeat(int netIndex)
{
bool needUpdateText = false;
NetIncomingMessage inc;
while ((inc = Nets[netIndex].ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)inc.ReadByte();
double delay = -1d;
this.TextNetMsgS[netIndex] = status.ToString() + "StatusChanged 延时：" + Nets[netIndex].ServerConnection ?? NetTime.ToReadable(Nets[netIndex].ServerConnection.PingTimeDelay);
needUpdateText = true;
break;
case NetIncomingMessageType.ErrorMessage:
this.TextNetMsgS[netIndex] = inc.ReadString() + "ErrorMessage 延时：" + Nets[netIndex].ServerConnection ?? NetTime.ToReadable(Nets[netIndex].ServerConnection.PingTimeDelay);
needUpdateText = true;
break;
}
}
// send message?
if (NetTime.Now > m_lastSent[netIndex] + c_sendFrequency)
{
var om = Nets[netIndex].CreateMessage();
om.Write("Hi!");
Nets[netIndex].SendMessage(om, NetDeliveryMethod.ReliableOrdered);
m_lastSent[netIndex] = NetTime.Now;
// also update title
#if DEBUG
/*this.Text*/ this.TextNetMsgS[netIndex] = Nets[netIndex].Statistics.SentBytes + " bytes sent; " + Nets[netIndex].Statistics.ReceivedBytes + " bytes received";
//if (needUpdateText) {
TextNetMsgSB.Remove(0, TextNetMsgSB.Length);
for (int i = 0; i < TextNetMsgS.Length; i++)
{
TextNetMsgSB.AppendLine(TextNetMsgS[i]);
}
this.label1.Text = TextNetMsgSB.ToString();
//}
#else
string str = Nets[netIndex].ServerConnection == null ? "No connection" : Nets[netIndex].ServerConnection.Status.ToString();
//if (this.TextNetMsgS[netIndex] != str) {
if (Nets[netIndex].ServerConnection != null)
{
this.TextNetMsgS[netIndex] = str + " 延时：" + NetTime.ToReadable(Nets[netIndex].ServerConnection.PingTimeDelay);
needUpdateText = true;
}
//if (needUpdateText) {
//TextNetMsgSB.Remove(0, TextNetMsgSB.Length);
//for (int i = 0; i < TextNetMsgS.Length; i++) {
// TextNetMsgSB.AppendLine(TextNetMsgS[i]);
//}
//this.label1.Text = TextNetMsgSB.ToString();
//}
#endif
}
}
protected void UpdateServerConnectionState(
NetConnectionStatus s,
NetIncomingMessage message,
MessagePipe pipe)
{
switch (s)
{
case NetConnectionStatus.Connected:
Log.Debug("player connected: {connection}", message.SenderConnection);
OnClientConnectionSuccessful?.Invoke(message.SenderConnection);
break;
case NetConnectionStatus.Disconnected:
Log.Debug("player disconnected: {connection}", message.SenderConnection);
OnClientDisconnected?.Invoke(message.SenderConnection);
break;
case NetConnectionStatus.Disconnecting:
case NetConnectionStatus.InitiatedConnect:
case NetConnectionStatus.None:
case NetConnectionStatus.ReceivedInitiation:
case NetConnectionStatus.RespondedConnect:
case NetConnectionStatus.RespondedAwaitingApproval:
break;
}
Log.Information("Updated connection status: " + s.ToString());
}
public string GetHelp()
{
string t_msg = "Normal Connection.";
if (m_status == NetConnectionStatus.Connected)
{
t_msg = "Connect succeed.";
}
else if (m_status == NetConnectionStatus.Disconnected)
{
t_msg = "Your connection was disable, please check Network Setting in Console.";
}
else if (m_status == NetConnectionStatus.MediaDisconnected)
{
t_msg = "Cable had bad contact with Network Card! Please check it.";
}
else if (m_status == NetConnectionStatus.InvalidAddress)
{
t_msg = "IP address is Invalid, please check DHCP/Router or IP setting.";
}
else
{
t_msg = string.Format("NetConnectionStatus is {0}", m_status.ToString());
}
return(t_msg);
}
public void Parse(NetIncomingMessage mes)
{
switch (mes.MessageType)
{
case NetIncomingMessageType.ConnectionApproval:
mes.SenderConnection.Approve();
break;
case NetIncomingMessageType.WarningMessage:
Logman.Log(mes.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus stat = (NetConnectionStatus)mes.ReadByte();
Logman.Log(mes.SenderEndPoint.Address.ToString() + ": " + stat.ToString(), LOG_TYPE.WARNING);
if (stat == NetConnectionStatus.Connected)
{
Logman.Log("New client connected, broadcasting connection.");
BroadcastNewConnection(mes.SenderConnection);
if (NewClientConnected != null)
{
NewClientConnected.Invoke(mes.SenderConnection);
}
}
break;
case NetIncomingMessageType.Data:
ParseData(mes);
break;
}
}
void OnClientStatusChanged(NetConnectionStatus inNewStatus, NetIncomingMessage inMsg)
{
Console.WriteLine(inMsg.SenderConnection + ": " + inNewStatus.ToString());
if (inNewStatus == NetConnectionStatus.Connected)
{
OnClientConnected?.Invoke(inMsg.SenderConnection);
}
}
static void StartClient()
{
client.Start();
client.DiscoverLocalPeers(8081);
NetOutgoingMessage hail = client.CreateMessage("This is the hail message");
NetIncomingMessage message;
while (true)
{
message = client.WaitMessage(500);
if (message != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.DiscoveryResponse:
Console.WriteLine("(Client) Got response from server.");
client.Connect(message.SenderEndPoint, hail);
Console.WriteLine("(Client) Attempting to connect to server...");
break;
case NetIncomingMessageType.DebugMessage:
Console.WriteLine(message.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(message.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Console.WriteLine(message.ReadString());
break;
case NetIncomingMessageType.VerboseDebugMessage:
Console.WriteLine(message.ReadString());
break;
case NetIncomingMessageType.Data:
string chat = message.ReadString();
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
Console.WriteLine(status.ToString());
break;
default:
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("(Client) Unrecognized message type! (" + message.MessageType + ")");
break;
}
}
client.Recycle(message);
}
}
public static void GotMessage(object peer)
{
NetClient s_client = peer as NetClient;
//foreach (var s_client in s_clients) {
NetIncomingMessage im;
while ((im = s_client.ReadMessage()) != null)
{
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
string text = im.ReadString();
Output(s_client.Port.ToString() + " recevied:" + text);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
if (status == NetConnectionStatus.Connected)
{
s_form.EnableInput();
}
else
{
s_form.DisableInput();
}
if (status == NetConnectionStatus.Disconnected)
{
s_form.button2.Text = "Connect";
}
string reason = im.ReadString();
Output(status.ToString() + ": " + reason);
break;
case NetIncomingMessageType.Data:
string chat = im.ReadString();
Output(s_client.Port.ToString() + " recevied:" + chat);
break;
default:
Output("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes");
break;
}
s_client.Recycle(im);
//}
}
}
private static void GotMessage(object peer)
{
var client = ((CClient)peer);
var msg = client.ReadMessage();
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryResponse:
string name = msg.ReadString();
var s = new FoundServer()
{
EndPoint = msg.SenderEndPoint, Name = name
};
if (client.callback != null)
{
client.callback.Invoke(s);
}
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
string statusText = msg.ReadString();
Main.Log("[STATUS UPDATE] " + status + " - " + statusText);
if (status == NetConnectionStatus.Connected)
{
Main.SetStatus("Connected to " + msg.SenderEndPoint.Address);
Main.Log("Connected!");
Net.UponClientConnected();
}
else if (status == NetConnectionStatus.Disconnected)
{
Main.Log("Disconnected from server. Reason: " + statusText);
Net.UponClientDisconnected();
MessageBox.Show("Disconnected from server: " + statusText, "Disconnected", MessageBoxButtons.OK);
}
else
{
Main.SetStatus(status.ToString());
}
break;
case NetIncomingMessageType.Data:
var type = (DataType)msg.ReadByte();
ProcessData(type, msg, client);
break;
default:
Main.Log("[CLIENT UNHANDLED] Type: " + msg.MessageType);
break;
}
client.Recycle(msg);
}
private void HandleStatusChange(NetConnectionStatus status, NetConnection connection, NetIncomingMessage incomingMessage)
{
if (_statusChangeHandlers.ContainsKey(status))
{
_statusChangeHandlers[status](connection, incomingMessage);
}
else
{
loggingService.Log($"Could not handle {status.ToString()} status message", LogMessageType.WARNING);
}
}
public void GotMessage(object peer)
{
NetIncomingMessage im;
while ((im = _client.ReadMessage()) != null)
{
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
string text = im.ReadString();
OnMessage(text);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
if (status == NetConnectionStatus.Connected)
{
OnMessage("Connected");
SendMessage("play", "data");
}
if (status == NetConnectionStatus.Disconnected)
{
OnMessage("Disconnected");
}
string reason = im.ReadString();
OnMessage(status.ToString() + ": " + reason);
break;
case NetIncomingMessageType.Data:
ProcessMessage(im.ReadString());
string data = im.ReadString();
if (!String.IsNullOrEmpty(data))
{
KeyValue <string> x = new KeyValue <string>(data);
OnMessage("data from client - key:" + x.key + " value:" + x.value);
}
//OnMessage(chat);
break;
default:
OnMessage("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes");
break;
}
_client.Recycle(im);
}
}
/// <summary>
/// Is callback
/// </summary>
protected void CheckMessageFromServer(object peer)
{
NetIncomingMessage im;
if ((im = s_client.ReadMessage()) != null)
{
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
if (UIText != null)
{
string text = im.ReadString();
UIText.text = text;
}
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
//if (status != NetConnectionStatus.Connected)
// Connect("localhost", 14242);
if (UIText != null)
{
string reason = im.ReadString();
UIText.text = status.ToString() + ": " + reason;
}
break;
case NetIncomingMessageType.Data:
string chat = im.ReadString();
{
if (mapVisualisator != null) // not destroyed yet
{
mapVisualisator.ReceiveNetData(chat);
}
}
break;
default:
UIText.text = "Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes";
break;
}
s_client.Recycle(im);
}
}
private static void Application_Idle(object sender, EventArgs e)
{
while (NativeMethods.AppStillIdle)
{
NetIncomingMessage im;
while ((im = s_client.ReadMessage()) != null)
{
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
string text = im.ReadString();
Output(text);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
if (status == NetConnectionStatus.Connected)
{
s_form.EnableInput();
}
else
{
s_form.DisableInput();
}
string reason = im.ReadString();
Output(status.ToString() + ": " + reason);
break;
case NetIncomingMessageType.Data:
string chat = im.ReadString();
Output(chat);
break;
default:
Output("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes");
break;
}
}
Thread.Sleep(1);
}
}
internal void HandleIncomingMessage(NetIncomingMessage msg)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
Console.WriteLine("[DEBUG] {0}", msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Console.WriteLine("[WARNING] {0}", msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine("[ERROR] {0}", msg.ReadString());
break;
// data messages
case NetIncomingMessageType.Data:
//HandleDataMessage(msg);
break;
// client connect / disconnect
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
OnConnected(msg.SenderConnection);
}
else if (status == NetConnectionStatus.Disconnected)
{
OnDisconnected(msg.SenderConnection);
}
string reason = msg.ReadString();
Console.WriteLine("[CONN] {0}", status.ToString() + ": " + reason);
break;
default:
Console.WriteLine("[ERROR] Unhandled message type: {0} ({1} bytes)", msg.MessageType, msg.LengthBytes);
break;
}
}
public void GotMessage()
{
NetIncomingMessage message;
Console.Write("");
message = client.ReadMessage();
if (message != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
Console.WriteLine("Status changed to " + status.ToString());
break;
case NetIncomingMessageType.Data:
{
var data = message.ReadString();
Console.WriteLine(data);
if (data == "exit")
{
//TODO: exit later
}
break;
}
default:
Console.WriteLine("Unhandled message type: {message.MessageType}");
break;
}
}
}
internal void Heartbeat()
{
NetIncomingMessage inc;
while ((inc = Net.ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)inc.ReadByte();
this.Text = status.ToString();
break;
case NetIncomingMessageType.ErrorMessage:
this.Text = inc.ReadString();
break;
}
}
// send message?
if (NetTime.Now > m_lastSent + c_sendFrequency)
{
var om = Net.CreateMessage();
om.Write("Hi!");
Net.SendMessage(om, NetDeliveryMethod.ReliableOrdered);
m_lastSent = NetTime.Now;
// also update title
#if DEBUG
this.Text = Net.Statistics.SentBytes + " bytes sent; " + Net.Statistics.ReceivedBytes + " bytes received";
#else
string str = Net.ServerConnection == null ? "No connection" : Net.ServerConnection.Status.ToString();
if (this.Text != str)
{
this.Text = str;
}
#endif
}
}
public void ReadStatus(NetIncomingMessage message)
{
NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
NetworkChannel channel = (NetworkChannel)message.SequenceChannel;
if (message.SequenceChannel < 0 || message.SequenceChannel > 32)
{
channel = NetworkChannel.LOGIN;
}
NetworkConnection connection = GetConnection(this, message);
Debug.Log($"Network status changed {status.ToString()}");
if (status == NetConnectionStatus.Connected)
{
OnConnectionCreate(this, message.SenderConnection);
}
if (status == NetConnectionStatus.Disconnected)
{
OnDisconnect(this, connection, message);
}
connection?.GetNetworkHandler(channel).OnStatusChange(status);
}
private void ProcessNetworkMessages()
{
NetIncomingMessage inc;
while ((inc = server.ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)inc.ReadByte();
switch (status)
{
case NetConnectionStatus.Connected:
Logger.InfoFormat("{0} Connected", inc.SenderEndpoint);
break;
case NetConnectionStatus.Disconnected:
sessions.Remove(inc.SenderConnection);
Logger.InfoFormat("{0} Disconnected", inc.SenderEndpoint);
break;
case NetConnectionStatus.Disconnecting:
case NetConnectionStatus.InitiatedConnect:
case NetConnectionStatus.RespondedConnect:
Logger.Debug(status.ToString());
break;
}
break;
//Check for client attempting to connect
case NetIncomingMessageType.ConnectionApproval:
NetOutgoingMessage hailMessage;
string username = null;
if (world.EnterWorld(inc, out hailMessage, out username))
{
sessions.Add(inc.SenderConnection, new Session(inc.SenderConnection, this, username));
inc.SenderConnection.Approve(hailMessage);
}
else
{
inc.SenderConnection.Deny("Wrong version !");
}
break;
case NetIncomingMessageType.Data:
Session session = null;
if (sessions.TryGetValue(inc.SenderConnection, out session))
{
session.HandlePacket(inc);
}
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
Logger.Debug(inc.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Logger.Warn(inc.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Logger.Error(inc.ReadString());
break;
}
server.Recycle(inc);
}
}
/// <summary>
/// Method for Receiving Messages kept in a Global Scope for the Engine.
/// </summary>
/// <param name="peer">Peer.</param>
public void GotMessage(object peer)
{
NetIncomingMessage im;
while ((im = MasterSeverClient.ReadMessage()) != null)
{
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
string text = im.ReadString();
vxConsole.WriteNetworkLine(im.MessageType + " : " + text);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
if (status == NetConnectionStatus.Connected)
{
MasterServerConnectionStatus = vxEnumNetworkConnectionStatus.Running;
}
else
{
MasterServerConnectionStatus = vxEnumNetworkConnectionStatus.Stopped;
}
if (status == NetConnectionStatus.Disconnected)
{
MasterServerConnectionStatus = vxEnumNetworkConnectionStatus.Stopped;
}
string reason = im.ReadString();
vxConsole.WriteNetworkLine(status.ToString() + " : " + reason);
break;
case NetIncomingMessageType.Data:
// incoming chat message from a client
string chat = im.ReadString();
//Split the Text By Carriage Return
string[] result = chat.Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
switch (result[0])
{
case "vrtx_serverList":
vxConsole.WriteNetworkLine("Server List Recieved");
if (GameServerListRecieved != null)
{
GameServerListRecieved(this, new vxGameServerListRecievedEventArgs(result));
}
break;
}
break;
default:
vxConsole.WriteNetworkLine("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes");
break;
}
MasterSeverClient.Recycle(im);
}
}
private static void Application_Idle(object sender, EventArgs e)
{
while (NativeMethods.AppStillIdle)
{
NetIncomingMessage im;
while ((im = s_client.ReadMessage()) != null)
{
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
string text = im.ReadString();
Output(text);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
string reason = im.ReadString();
Output(status.ToString() + ": " + reason);
s_form.Text = "Speed test client: " + status.ToString();
break;
case NetIncomingMessageType.Data:
//string chat = im.ReadString();
//Output(chat);
break;
default:
Output("Unhandled type: " + im.MessageType);
break;
}
s_client.Recycle(im);
}
float now = (float)NetTime.Now;
if (now > s_lastUpdatedTitle + s_titleUpdateInterval)
{
s_form.Text = "Speed test client: " + (s_client.ServerConnection != null ? s_client.ServerConnection.Status.ToString() : "(no connection)") + " " + NetUtility.ToHumanReadable(s_sentBytes) + " bytes sent";
s_lastUpdatedTitle = now;
}
if (s_client.ServerConnection != null && s_client.ServerConnection.Status == NetConnectionStatus.Connected)
{
//
// Saturate the line
//
int windowSize, freeWindowSlots;
s_client.ServerConnection.GetSendQueueInfo(s_method, s_sequenceChannel, out windowSize, out freeWindowSlots);
// queue up to double window size
if (windowSize == 0)
{
freeWindowSlots = 1;
}
int num = 0;
while (freeWindowSlots > -windowSize)
{
// send random data
int size = s_client.Configuration.MaximumTransmissionUnit - 30;
NetOutgoingMessage om = s_client.CreateMessage(size);
byte[] tmp = new byte[size];
MWCRandom.Instance.NextBytes(tmp);
int slot = (int)s_method + s_sequenceChannel;
om.Write(s_nextSendNumber[slot]);
s_nextSendNumber[slot]++;
om.Write(tmp);
// queue message for sending
NetSendResult res = s_client.SendMessage(om, s_method, s_sequenceChannel);
if (s_method != NetDeliveryMethod.Unreliable && s_method != NetDeliveryMethod.UnreliableSequenced)
{
if (res != NetSendResult.Queued && res != NetSendResult.Sent)
{
throw new NetException("Got res " + res);
}
}
s_sentBytes += size;
freeWindowSlots--;
num++;
}
//Console.WriteLine("Queued " + num + " messages");
//
// Send every X millisecond
//
/*
* if (now > s_lastSend + s_sendInterval)
* {
*
* // send random data
* int size = s_client.Configuration.MaximumTransmissionUnit - 25;
* NetOutgoingMessage om = s_client.CreateMessage(size);
* byte[] tmp = new byte[size];
* NetRandom.Instance.NextBytes(tmp);
* int slot = (int)s_method + s_sequenceChannel;
* om.Write(s_nextSendNumber[slot]);
* s_nextSendNumber[slot]++;
* om.Write(tmp);
*
* // queue message for sending
* NetSendResult res = s_client.SendMessage(om, s_method, s_sequenceChannel);
* if (res != NetSendResult.Queued && res != NetSendResult.Sent)
* throw new NetException("Got res " + res);
* //Console.WriteLine("Res: " + res);
* s_sentBytes += size;
*
* s_lastSend = now;
* }
*/
}
Thread.Sleep(0);
}
}
/// <summary>
/// Handles StatusChangedMessages
/// </summary>
/// <param name="msg"></param>
public void StatusChange(NetIncomingMessage msg)
{
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
switch (status)
{
case NetConnectionStatus.Disconnected:
Disconnected(msg);
break;
case NetConnectionStatus.Connected:
Connected(msg);
break;
default:
Debug.WriteLine(string.Format(Properties.strings.managerUnhandledStatusChange, status.ToString()));
break;
}
}
public void read()
{
while (client.Status == NetPeerStatus.Running && !ctSource.Token.IsCancellationRequested)
{
WaitHandle.WaitAny(new WaitHandle[] { client.MessageReceivedEvent, ctSource.Token.WaitHandle });
NetIncomingMessage im;
while ((im = client.ReadMessage()) != null && !ctSource.IsCancellationRequested)
{
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.Data:
try
{
if (alg != null)
{
im.Decrypt(alg);
}
MemoryStream ms = new MemoryStream(im.Data);
ProtoMessage m = null;
try
{
m = Serializer.DeserializeWithLengthPrefix <ProtoMessage>(ms, PrefixStyle.Fixed32);
}
catch (Exception e)
{
// Attempt to read string and add to message queue
string s = im.ReadString();
if (!string.IsNullOrWhiteSpace(s))
{
Console.WriteLine("CLIENT: Got message: " + s);
tClient.stringMessageQueue.Enqueue(s);
}
}
if (m != null)
{
Console.WriteLine("CLIENT: Got ProtoMessage with ActionType: " + m.ActionType + " and response type: " + m.ResponseType);
if (m.ResponseType == DisplayMessages.LogInSuccess)
{
loggedIn = true;
tClient.protobufMessageQueue.Enqueue(m);
}
else
{
if (m.ActionType == Actions.Update)
{
// Don't do anything at the moment for updates
}
else
{
tClient.protobufMessageQueue.Enqueue(m);
if (m.ActionType == Actions.LogIn && m.ResponseType == DisplayMessages.None)
{
byte[] key = null;
if (ValidateCertificateAndCreateKey(m as ProtoLogIn, out key))
{
ComputeAndSendHashAndKey(m as ProtoLogIn, key);
}
}
else
{
// Attempt to read string and add to message queue
string s = im.ReadString();
if (!string.IsNullOrWhiteSpace(s))
{
tClient.stringMessageQueue.Enqueue(s);
}
}
}
}
}
}
catch (Exception e)
{
Globals_Server.logError("Error in reading data: " + e.GetType() + " :" + e.Message + "; Stack Trace: " + e.StackTrace);
}
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
Console.WriteLine("CLIENT: Status changed to " + status.ToString());
//MemoryStream ms2 = new MemoryStream(im.SenderConnection.RemoteHailMessage.Data);
if (status == NetConnectionStatus.Connected)
{
if (im.SenderConnection.RemoteHailMessage != null)
{
try
{
MemoryStream ms2 = new MemoryStream(im.SenderConnection.RemoteHailMessage.Data);
ProtoMessage m = Serializer.DeserializeWithLengthPrefix <ProtoMessage>(ms2, PrefixStyle.Fixed32);
if (m != null)
{
tClient.protobufMessageQueue.Enqueue(m);
if (m.ActionType == Actions.LogIn && m.ResponseType == DisplayMessages.None)
{
byte[] key = null;
if (ValidateCertificateAndCreateKey(m as ProtoLogIn, out key))
{
if (autoLogIn)
{
ComputeAndSendHashAndKey(m as ProtoLogIn, key);
}
}
else
{
Console.WriteLine("Certificate validation failed: Server may be untrusted");
client.Disconnect("Invalid Certificate");
}
}
}
}
catch (Exception e)
{
}
}
break;
}
else if (status == NetConnectionStatus.Disconnected)
{
string reason = im.ReadString();
if (!string.IsNullOrEmpty(reason))
{
tClient.stringMessageQueue.Enqueue(reason);
}
}
if (im.SenderConnection.RemoteHailMessage != null && (NetConnectionStatus)im.ReadByte() == NetConnectionStatus.Connected)
{
}
break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
break;
default:
break;
}
client.Recycle(im);
}
}
#if DEBUG
Globals_Server.logEvent("Client listening thread ends");
#endif
}
private void PrivProcessData()
{
NetIncomingMessage buff;
while ((_connection.ReadMessage(out buff)) == true)
{
NetIncomingMessageType type = buff.MessageType;
switch (type)
{
case NetIncomingMessageType.DebugMessage:
string debug1 = buff.ReadString();
Debug.WriteLine(debug1);
break;
case NetIncomingMessageType.VerboseDebugMessage:
string debug2 = buff.ReadString();
Debug.WriteLine(debug2);
break;
case NetIncomingMessageType.WarningMessage:
string warning = buff.ReadString();
Debug.WriteLine(warning);
break;
case NetIncomingMessageType.ErrorMessage:
Debug.WriteLine(buff.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)buff.ReadByte();
string reason = buff.ReadString();
Debug.WriteLine(status.ToString() + ": " + reason);
break;
case NetIncomingMessageType.Data:
int t;
if (buff.ReadInt32(out t))
{
switch ((DataItem.DATA_TYPE)t)
{
case DataItem.DATA_TYPE.ACK_TYPE:
break;
case DataItem.DATA_TYPE.EVENT_TYPE:
EventData event_d = new EventData();
event_d.Deserialize(ref buff);
DataManager.PushToIn(new DataItem(DataItem.DATA_TYPE.EVENT_TYPE, event_d));
break;
case DataItem.DATA_TYPE.INPUT_TYPE:
InputData input = new InputData();
input.Deserialize(ref buff);
DataManager.PushToIn(new DataItem(DataItem.DATA_TYPE.INPUT_TYPE, input));
break;
case DataItem.DATA_TYPE.SIM_DATA:
SimData sim = new SimData();
sim.Deserialize(ref buff);
DataManager.PushToIn(new DataItem(DataItem.DATA_TYPE.SIM_DATA, sim));
break;
case DataItem.DATA_TYPE.STATE_TYPE:
StateData state = new StateData();
state.Deserialize(ref buff);
DataManager.PushToIn(new DataItem(DataItem.DATA_TYPE.STATE_TYPE, state));
break;
}
}
break;
case NetIncomingMessageType.UnconnectedData:
Debug.WriteLine("Recv(" + buff.SenderEndPoint + "): " + buff.ReadString());
break;
case NetIncomingMessageType.DiscoveryResponse:
Debug.WriteLine("Found server at " + buff.SenderEndPoint + " name: " + buff.ReadString());
_connection.Connect(buff.SenderEndPoint);
break;
}
_connection.Recycle(buff);
}
}
public virtual void Connect(string host, int port, string name, string password)
{
client.Connect(host, port, CreateApprovalRequest(password));
//read client number
int i = 0;
short n = -1;
byte[] classes = null;
while (i++ < 100)
{
Thread.Sleep(100);
NetIncomingMessage m;
while ((m = client.ReadMessage()) != null)
{
switch (m.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(m.ReadString());
break;
case NetIncomingMessageType.Data:
{
if (m.LengthBytes == 2)
{
n = m.ReadInt16();
System.Console.WriteLine(n);
break;
}
else if (m.PeekUInt32() == 0xFFFFFFFF)
{
m.ReadUInt32();
classes = m.ReadBytes(m.LengthBytes - 4);
System.Console.WriteLine("received class dictionary: " + classes.Length);
break;
}
else if (m.PeekUInt32() == 0xFFFFFFFE)
{
m.ReadUInt32();
compress = m.ReadBoolean();
Console.WriteLine("compression: " + compress);
}
Console.WriteLine("skip: " + m.LengthBytes);
}
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)m.ReadByte();
Console.WriteLine("status: " + status.ToString());
switch (status)
{
case NetConnectionStatus.InitiatedConnect:
break;
case NetConnectionStatus.Connected:
break;
}
break;
default:
Console.WriteLine("Unhandled type: " + m.MessageType);
break;
}
client.Recycle(m);
/*else if (m.SequenceChannel == NetChannel.ReliableUnordered)
* {
* classes = m.ReadBytes(m.Length);
* System.Console.WriteLine("received class dictionary: " + classes.Length);
* }*/
}
if (classes != null && n != -1)
{
break;
}
}
if (n == -1)
{
throw new Exception();
}
if (n > 16)
{
throw new Exception();
}
Root.Instance.Factory = new Factory(new MemoryStream(classes));
Console.WriteLine("connected to server: clientnumber: " + n);
ClientNumber = n;
}
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 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("{0} Debug Message: {1} {2}", Robot.LobbyNetworkSystem.User, im.ReadString(), LobbyRobot.Robot.GetDateTime());
break;
case NetIncomingMessageType.ErrorMessage:
LogSystem.Debug("{0} Error Message: {1} {2}", Robot.LobbyNetworkSystem.User, im.ReadString(), LobbyRobot.Robot.GetDateTime());
break;
case NetIncomingMessageType.WarningMessage:
LogSystem.Debug("{0} Warning Message: {1} {2}", Robot.LobbyNetworkSystem.User, im.ReadString(), LobbyRobot.Robot.GetDateTime());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
string reason = im.ReadString();
if (null != im.SenderConnection)
{
LogSystem.Debug("{0} Network Status Changed:{1} Reason:{2} {3}", Robot.LobbyNetworkSystem.User, status.ToString(), reason, LobbyRobot.Robot.GetDateTime());
if (NetConnectionStatus.Disconnected == status)
{
m_IsConnected = false;
m_WaitDisconnect = false;
m_CanSendMessage = false;
}
else if (NetConnectionStatus.Connected == status)
{
OnConnected(im.SenderConnection);
}
}
else
{
LogSystem.Debug("{0} Network Status Changed:{1} reason:{2}", Robot.LobbyNetworkSystem.User, status, reason);
}
break;
case NetIncomingMessageType.Data:
case NetIncomingMessageType.UnconnectedData:
if (!m_IsConnected && NetIncomingMessageType.Data == im.MessageType)
{
break;
}
try
{
byte[] data = im.ReadBytes(im.LengthBytes);
object msg = Serialize.Decode(data);
if (msg != null)
{
PushMsg(msg, im.SenderConnection);
}
}
catch (Exception ex)
{
LogSystem.Error("{0} Decode Message exception:{1}\n{2}", Robot.LobbyNetworkSystem.User, ex.Message, ex.StackTrace);
}
break;
default:
break;
}
m_NetClient.Recycle(im);
}
}
private void ProcessNetworkMessages()
{
NetIncomingMessage inc;
while ((inc = client.ReadMessage()) != null)
{
switch (inc.MessageType)
{
//Report changes in connection status
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)inc.ReadByte();
switch (status)
{
case NetConnectionStatus.Connected:
/*var message = new UpdatePlayerStateMessage(inc.SenderConnection.RemoteHailMessage);
* this.playerManager.AddPlayer(message.Id, message.Position, message.Velocity, message.Rotation, true);
* Console.WriteLine("Connected to {0}", inc.SenderEndPoint);*/
ConnectionSuccess("Connected to " + inc.SenderEndpoint);
break;
case NetConnectionStatus.Disconnected:
if (Entry.UserInterace != null && Entry.UserInterace.Chat != null)
{
Entry.UserInterace.Chat.Log("Lost connection to the server !");
}
string reason = "Unknown error !";
try
{
inc.ReadByte();
reason = inc.ReadString();
}
catch
{
}
ConnectionFailed(reason);
break;
case NetConnectionStatus.Disconnecting:
case NetConnectionStatus.InitiatedConnect:
case NetConnectionStatus.RespondedConnect:
Console.WriteLine(status.ToString());
break;
}
break;
case NetIncomingMessageType.ConnectionApproval:
break;
case NetIncomingMessageType.Data:
handler.Handle(inc);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(inc.ReadString());
break;
}
client.Recycle(inc);
}
}
private void processIncomingMessages()
{
if (_peer != null)
{
NetIncomingMessage im;
while ((im = _peer.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
string text = im.ReadString();
_game.addMessage(text);
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
if (status == NetConnectionStatus.Connected)
{
if (_role == NetRole.Client)
{
_game.addMessage("Connected to server!");
}
else
{
_game.addMessage("Client connected!");
}
}
else
{
_game.addMessage(status.ToString() + ": " + im.ReadString());
}
break;
case NetIncomingMessageType.Data:
MessageType messageType = (MessageType)im.ReadInt32();
if (messageType == MessageType.UpdateDynamicBodies)
{
receiveDynamicBodiesUpdate(im);
}
else if (messageType == MessageType.CreateMouseJoint)
{
receiveCreateMouseJoint(im);
}
else if (messageType == MessageType.DestroyMouseJoint)
{
receiveDestroyMouseJoint(im);
}
else if (messageType == MessageType.MoveMouseJoint)
{
receiveMoveMouseJoint(im);
}
break;
default:
_game.addMessage("Unhandled message type: " + im.MessageType);
break;
}
_peer.Recycle(im);
}
}
}
private INSTANCE_TYPE PrivInitialize()
{
Console.WriteLine("\n****************\nEnter IP Address\n****************\n");
Console.ForegroundColor = ConsoleColor.Yellow;
_server_ip = Console.ReadLine();
NetPeerConfiguration config = new NetPeerConfiguration("ServerClientClient");
config.AcceptIncomingConnections = true;
config.MaximumConnections = 100;
config.MaximumHandshakeAttempts = 3;
config.ResendHandshakeInterval = 0.5f;
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
_connection = new NetClient(config);
Debug.Assert(_connection != null);
_connection.Start();
System.Net.IPEndPoint ep = NetUtility.Resolve(_server_ip, _server_port);
NetIncomingMessage pInMsg;
_connection.Connect(ep);
bool connected = false;
while (connected == false)
{
if ((pInMsg = _connection.ReadMessage()) != null)
{
NetIncomingMessageType type = pInMsg.MessageType;
switch (type)
{
case NetIncomingMessageType.DebugMessage:
string debug1 = pInMsg.ReadString();
Debug.WriteLine(debug1);
break;
case NetIncomingMessageType.VerboseDebugMessage:
string debug2 = pInMsg.ReadString();
Debug.WriteLine(debug2);
break;
case NetIncomingMessageType.WarningMessage:
string warning = pInMsg.ReadString();
Debug.WriteLine(warning);
break;
case NetIncomingMessageType.ErrorMessage:
Debug.WriteLine(pInMsg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)pInMsg.ReadByte();
string reason = pInMsg.ReadString();
Debug.WriteLine(status.ToString() + ": " + reason);
if (status == NetConnectionStatus.Disconnected)
{
Debug.WriteLine("Server timeout. Becoming Server.");
_connection.Shutdown("");
InitializeServer();
connected = true;
}
else if (status == NetConnectionStatus.Connected)
{
Debug.WriteLine("Server found.");
InitializeClient();
connected = true;
}
break;
case NetIncomingMessageType.UnconnectedData:
Debug.WriteLine("Recv(" + pInMsg.SenderEndPoint + "): " + pInMsg.ReadString());
break;
case NetIncomingMessageType.DiscoveryResponse:
Debug.WriteLine("Found server at " + pInMsg.SenderEndPoint + " name: " + pInMsg.ReadString());
_connection.Connect(pInMsg.SenderEndPoint);
break;
}
}
_connection.Recycle(pInMsg);
}
return(_connection_type);
}
private void receiveMessage()
{
NetIncomingMessage im;
while ((im = session.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
Console.WriteLine(im.ReadString() + "\n");
break;
case NetIncomingMessageType.UnconnectedData:
Console.WriteLine(im.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
// When a new player connects, the host is charged to find a suitable default name between player1 and player4
// depending on what names are available. The host then sends the new list of player names to the other players
if (status == NetConnectionStatus.Connected)
{
/*packetWriter = session.CreateMessage();
* packetWriter.Write((Byte)ConnectedMessageType.Chat);
* packetWriter.Write("Hello");
* session.SendMessage(packetWriter, im.SenderConnection, NetDeliveryMethod.ReliableOrdered);*/
}
if (status == NetConnectionStatus.Disconnected)
{
}
// Don't need this for now
string reason = im.ReadString();
Console.WriteLine(status.ToString() + ": " + reason);
break;
case NetIncomingMessageType.Data:
ConnectedMessageType connectedMessageType = (ConnectedMessageType)im.ReadByte();
switch (connectedMessageType)
{
case ConnectedMessageType.EndRoundInfo:
packetWriter = session.CreateMessage();
packetWriter.Write((Byte)ConnectedMessageType.EndRoundInfo);
packetWriter.Write(im.ReadString());
session.SendMessage(packetWriter, im.SenderConnection, NetDeliveryMethod.ReliableOrdered);
break;
case ConnectedMessageType.Ping:
packetWriter = session.CreateMessage();
packetWriter.Write((Byte)ConnectedMessageType.PingReply);
session.SendMessage(packetWriter, session.Connections, NetDeliveryMethod.ReliableOrdered, 0);
break;
case ConnectedMessageType.PingReply:
pingSent = false;
Console.WriteLine(watch.ElapsedMilliseconds);
break;
}
break;
default:
Console.WriteLine("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes \n");
break;
}
}
}
public static int TimeToSaveDB; // temps d'interval pour sauveguarder la BDD
public static void Main(string[] args)
{
// initialisation PetaPoco
DataBase.DataTables.IniPetaPoco();
Console.WriteLine("Initialisation PetaPoco [ok]"); // BDD en interne sous forme de liste au lieu de se connecter a chaque fois à la BDD
CommonCode.ReadConfigFile();
NetPeerConfiguration config = new NetPeerConfiguration("the-morpher");
config.Port = Port;
config.MaximumConnections = MaximumConnections;
//config.PingInterval = 100;
//config.ConnectionTimeout = 600;
//config.PingInterval = 1F;
config.ConnectionTimeout = ConnectionTimeout;
netServer = new NetServer(config);
netServer.Start();
Console.WriteLine("Initialisatoin network [ok]");
// Thread pour supprimer les utilisateurs resté bloqués dans la table Connected
Thread tCleanTableConnected = new Thread(new ThreadStart(CleanTableConnected));
tCleanTableConnected.Start();
// Thread pour la supression des utilisateurs dans ClientData.Client qui ont dépassé le time stamp de 15min
Thread tChkConnUsr = new Thread(new ThreadStart(chkConnUsr));
tChkConnUsr.Start();
// thread pour l'augementation des pdv apres chaque 2 seconds
Thread tUpdatePdv = new Thread(new ThreadStart(UpdatePdv));
tUpdatePdv.Start();
// thread pour le lancement du combat apres x temps seulement si un combat est en mode initialisation
Thread tBattleLauncher = new Thread(new ThreadStart(BattleLauncher));
tBattleLauncher.Start();
Thread tCleanePlayersStats = new Thread(new ThreadStart(CleanPlayersStats));
tCleanePlayersStats.Start();
// nétoyage de la bdd
DataBase.DataTables.dataContext.Execute("TRUNCATE connected");
DataBase.DataTables.dataContext.Execute("TRUNCATE Logerror");
DataBase.DataTables.dataContext.Execute("TRUNCATE logCounter");
DataBase.DataTables.dataContext.Execute("delete from MapObj where state='dynamic'");
DataBase.DataTables.dataContext.Execute("update players set inBattle ='0', inBattleType ='', inBattleID=''");
Console.WriteLine("Nétoyage de la BDD [ok]");
Console.WriteLine((DataBase.DataTables.classes as List <mysql.classes>).Count + " classes chargés");
/*foreach (mysql.classes a in DataBase.DataTables.classes)
* Console.WriteLine("{0} - {1}", a.id, a.classeName);*/
Thread saveDB = new Thread(new ThreadStart(UpdateDB));
saveDB.Start();
Console.WriteLine("Boucle regénération Pdv [ok]");
Console.WriteLine("Lancement boucle réseau [ok]");
Console.WriteLine("____________________________________");
while (!Console.KeyAvailable)
{
NetIncomingMessage im;
while ((im = netServer.ReadMessage()) != null)
{
// handle incoming message
switch (im.MessageType)
{
case NetIncomingMessageType.DebugMessage:
//Console.WriteLine(im.ReadString());
//break;
case NetIncomingMessageType.ErrorMessage:
//Console.WriteLine(im.ReadString());
//break;
case NetIncomingMessageType.WarningMessage:
//Console.WriteLine(im.ReadString());
//break;
case NetIncomingMessageType.VerboseDebugMessage:
//Console.WriteLine(im.ReadString());
//break;
case NetIncomingMessageType.StatusChanged:
try
{
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
string reason = im.ReadString();
if (status.ToString() == "Connected")
{
server_NewConnection(im);
}
else if (status.ToString() == "Disconnected")
{
server_LostConnection(im, reason);
}
}
catch
{
//Console.WriteLine (ex.ToString ());
}
break;
case NetIncomingMessageType.Data:
im.Decrypt(algo);
Network.GetData(im);
break;
default:
Console.WriteLine("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes " + im.DeliveryMethod + "|" + im.SequenceChannel);
break;
}
}
Thread.Sleep(200);
}
Console.WriteLine("Le programme a sortie de la boucle réseau !!!!!!!!!!!\nRelancer le programme si c'est pas planifié");
tChkConnUsr.Abort();
tCleanTableConnected.Abort();
tUpdatePdv.Abort();
tBattleLauncher.Abort();
tCleanePlayersStats.Abort();
}
