static void AppLoop(object sender, EventArgs e) { while (NativeMethods.AppStillIdle) { // read any incoming messages NetIncomingMessage im; while ((im = Peer.ReadMessage()) != null) { switch (im.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: MainForm.richTextBox1.AppendText(im.ReadString() + Environment.NewLine); break; case NetIncomingMessageType.UnconnectedData: MainForm.richTextBox1.AppendText("Received from " + im.SenderEndPoint + ": " + im.ReadString() + Environment.NewLine); Peer.Recycle(im); break; } Peer.Recycle(im); } System.Threading.Thread.Sleep(1); } }
public void RecycleMessage(NetIncomingMessage msg) { if (msg != null && peer != null) { peer.Recycle(msg); } }
public void Update() { NetIncomingMessage msg; while ((msg = Net.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: Log(msg.ReadString()); break; case NetIncomingMessageType.StatusChanged: OnStatusChanged(msg); break; case NetIncomingMessageType.Data: OnData(msg); break; default: Log($"Unknown Message Type: {msg.MessageType}"); break; } Net.Recycle(msg); } }
public static async void Start() { var config = new NetPeerConfiguration("masterserver") { AutoFlushSendQueue = false, //Set it to false so lidgren doesn't wait until msg.size = MTU for sending Port = Port, SuppressUnreliableUnorderedAcks = true, PingInterval = 500, ConnectionTimeout = ServerMsTimeout }; config.EnableMessageType(NetIncomingMessageType.UnconnectedData); var peer = new NetPeer(config); peer.Start(); CheckMasterServerListed(); ConsoleLogger.Log(LogLevels.Normal, $"Master server {LmpVersioning.CurrentVersion} started! Поехали!"); RemoveExpiredServers(); while (RunServer) { NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.VerboseDebugMessage: ConsoleLogger.Log(LogLevels.Debug, msg.ReadString()); break; case NetIncomingMessageType.WarningMessage: ConsoleLogger.Log(LogLevels.Warning, msg.ReadString()); break; case NetIncomingMessageType.ErrorMessage: ConsoleLogger.Log(LogLevels.Error, msg.ReadString()); break; case NetIncomingMessageType.UnconnectedData: if (FloodControl.AllowRequest(msg.SenderEndPoint.Address)) { var message = GetMessage(msg); if (message != null && !message.VersionMismatch) { HandleMessage(message, msg, peer); message.Recycle(); } peer.Recycle(msg); } break; } } await Task.Delay(ServerMsTick); } peer.Shutdown("Goodbye and thanks for all the fish!"); }
/// <summary> /// Called when [update frame] occurs. /// </summary> public void OnUpdateFrame() { NetIncomingMessage msg; if (_netPeer != null) { while ((msg = _netPeer.ReadMessage()) != null) { IncomingMsg.Add(ReadMessage(msg)); _netPeer.Recycle(msg); } } if (_netClient != null) { while ((msg = _netClient.ReadMessage()) != null) { IncomingMsg.Add(ReadMessage(msg)); _netClient.Recycle(msg); } } if (_netServer != null) { while ((msg = _netServer.ReadMessage()) != null) { IncomingMsg.Add(ReadMessage(msg)); _netServer.Recycle(msg); } } }
static void UdpMain(GameList gameList) { var config = new NetPeerConfiguration("SpagAachen.Ballz"); config.Port = 43117; config.EnableMessageType(NetIncomingMessageType.UnconnectedData); var peer = new NetPeer(config); peer.Start(); while (true) { Thread.Sleep(10); NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.UnconnectedData: gameList.RequestAddGame(msg); break; } peer.Recycle(msg); } } }
void ReadInData() { NetworkMessage client_input = new NetworkMessage(); NetIncomingMessage im; while ((im = server.ReadMessage()) != null) { switch (im.MessageType) { case NetIncomingMessageType.Data: byte[] msg = im.ReadBytes(im.LengthBytes); client_input = NetworkMessage.Deserialize(msg); OutputQueue.AddToQueue(client_input.GetData()); Debug.WriteLine(msg); break; case NetIncomingMessageType.DiscoveryRequest: // Create a response NetOutgoingMessage om = server.CreateMessage(); om.Write("Connecting to DOG server"); server.SendDiscoveryResponse(om, im.SenderEndPoint); break; case NetIncomingMessageType.UnconnectedData: Debug.WriteLine("Received from " + im.SenderEndPoint + ": " + im.ReadString() + Environment.NewLine); break; } server.Recycle(im); } }
protected void Update() { NetIncomingMessage msg; while ((msg = instance.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.Data: var index = msg.ReadUInt32(); methods[index].Invoke(msg); break; default: Console.WriteLine("Unhandled type: " + msg.MessageType); break; } instance.Recycle(msg); } }
public void MessagePump() { NetIncomingMessage nim; while ((nim = netpeer.ReadMessage()) != null) { switch (nim.MessageType) { case NetIncomingMessageType.StatusChanged: OnStatusChanged(nim); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.Error: OnDebugMessage(nim); break; default: OnUnknownMessage(nim); break; } netpeer.Recycle(nim); } }
public bool ReceiveOne() { NetIncomingMessage message = Peer.ReadMessage(); if (message != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: onDataMessage(message); break; case NetIncomingMessageType.StatusChanged: onStatusChanged(message); break; default: onInternalMessage(message); break; } Peer.Recycle(message); return(true); } return(false); }
internal Task ProcessNetworkMessages(NetPeer peer) { return(Task.Run(async() => { NetIncomingMessage im; peer.MessageReceivedEvent.WaitOne(); while ((im = peer.ReadMessage()) != null) { if (im.SenderConnection != null) { if (connectionHandler.HasKey(im.SenderConnection)) { await connectionHandler[im.SenderConnection].Invoke(im.MessageType, im); } } foreach (var handler in globalHandler.GetAll) { await handler(im.MessageType, im); } if (messageHandlers.HasKey(im.MessageType)) { await messageHandlers[im.MessageType].Invoke(im); } peer.Recycle(im); } })); }
static private void ParseMessage(NetIncomingMessage message) { Console.WriteLine("Received message with type: " + message.MessageType); switch (message.MessageType) { case NetIncomingMessageType.Data: ParseMessage_Data(message); break; case NetIncomingMessageType.StatusChanged: ParseMessage_Status(message); break; case NetIncomingMessageType.DebugMessage: // handle debug messages // (only received when compiled in DEBUG mode) Console.WriteLine(message.ReadString()); break; /* .. */ default: Console.WriteLine("unhandled message with type: " + message.MessageType); break; } NetworkHandler.Recycle(message); }
public void HandleWebConnections() { NetIncomingMessage message; while ((message = peer.ReadMessage()) != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: HandleData(message); break; case NetIncomingMessageType.StatusChanged: switch (message.SenderConnection.Status) { case NetConnectionStatus.Connected: Debug.WriteLine("Connected!"); break; case NetConnectionStatus.Disconnected: Debug.WriteLine("Disconnected..."); break; } break; case NetIncomingMessageType.ConnectionApproval: message.SenderConnection.Approve(); break; case NetIncomingMessageType.DiscoveryResponse: peer.Connect(message.SenderEndPoint); connecting = false; break; case NetIncomingMessageType.DiscoveryRequest: var msg = peer.CreateMessage(); msg.Write("hi"); peer.SendDiscoveryResponse(msg, message.SenderEndPoint); peer.Connect(message.SenderEndPoint); isServer = true; break; case NetIncomingMessageType.DebugMessage: Debug.WriteLine(message.ReadString()); break; case NetIncomingMessageType.WarningMessage: Debug.WriteLine(message.ReadString()); break; default: Debug.WriteLine("unhandled message with type: " + message.MessageType); break; } peer.Recycle(message); } }
private static void Main(string[] args) { map.generate(); Console.WriteLine(("Enter Server name:")); var name = Console.ReadLine(); var config = new NetPeerConfiguration("PythonRouge") { Port = 32078 }; config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); Server = new NetServer(config); Server.Start(); Console.WriteLine("Ready"); NetIncomingMessage msg; while (true) { while ((msg = Server.ReadMessage()) != null) { Console.WriteLine("Got Message"); switch (msg.MessageType) { case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); string reason = msg.ReadString(); Console.WriteLine(status + " " + reason); break; case NetIncomingMessageType.ConnectionApproval: Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.Data: msgHandler(msg); break; case NetIncomingMessageType.ErrorMessage: Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.DiscoveryRequest: // Create a response and write some example data to it NetOutgoingMessage response = Server.CreateMessage(); Console.WriteLine("Client request"); response.Write(name); // Send the response to the sender of the request Server.SendDiscoveryResponse(response, msg.SenderEndPoint); break; default: Console.WriteLine("Unhandled type: " + msg.MessageType); break; } Server.Recycle(msg); } } }
protected void ReadMessages() { if (peer != null) { NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.Data: byte messageId = msg.ReadByte(); Action <NetIncomingMessage> handler = null; if (messageHandlers.TryGetValue(messageId, out handler)) { handler(msg); } else { Debug.LogWarning("No handler for message id " + messageId); } break; case NetIncomingMessageType.StatusChanged: switch (msg.SenderConnection.Status) { case NetConnectionStatus.Connected: if (Connected != null) { Connected(msg.SenderConnection); } break; case NetConnectionStatus.Disconnected: if (Disconnected != null) { Disconnected(msg.SenderConnection); } break; } Debug.Log("Status on " + msg.SenderConnection + " changed to " + msg.SenderConnection.Status); break; case NetIncomingMessageType.ErrorMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.VerboseDebugMessage: Debug.Log("Lidgren: " + msg.ReadString()); break; } peer.Recycle(msg); } } }
protected void ReadMessages() { if (peer == null) { return; } NetIncomingMessage netIncomingMessage; while ((netIncomingMessage = peer.ReadMessage()) != null) { switch (netIncomingMessage.MessageType) { case NetIncomingMessageType.Data: { byte b = netIncomingMessage.ReadByte(); Action <NetIncomingMessage> value = null; if (messageHandlers.TryGetValue(b, out value)) { value(netIncomingMessage); } else { Debug.LogWarning("No handler for message id " + b); } break; } case NetIncomingMessageType.StatusChanged: switch (netIncomingMessage.SenderConnection.Status) { case NetConnectionStatus.Connected: if (this.Connected != null) { this.Connected(netIncomingMessage); } break; case NetConnectionStatus.Disconnected: if (this.Disconnected != null) { this.Disconnected(netIncomingMessage); } break; } Debug.Log(string.Concat("Status on ", netIncomingMessage.SenderConnection, " changed to ", netIncomingMessage.SenderConnection.Status)); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: Debug.Log("Lidgren: " + netIncomingMessage.ReadString()); break; } peer.Recycle(netIncomingMessage); } }
public void Update() { NetIncomingMessage message; while ((message = _peer.ReadMessage()) != null) { ReadMessage(message); _peer.Recycle(message); } }
/// <summary> /// Reads incoming messages. To be called continuously. /// </summary> public virtual void Update(int msElapsed) { NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { HandleIncomingMessage(msg); peer.Recycle(msg); } }
public Client(string ip, int port) { try { ecdhrsaProvider = new ECDHRSAProvider(); NetPeerConfiguration config = new NetPeerConfiguration("GJABD_GAME"); config.EnableUPnP = true; config.LocalAddress = IPAddress.Any; /* FOR PRODUCTION * config.PingInterval = 5f; * config.ConnectionTimeout = 10f; * config.ResendHandshakeInterval = 1f; * config.MaximumHandshakeAttempts = 2; */ netPeer = new NetPeer(config); netPeer.Start(); // needed for initialization Console.WriteLine("started peer"); NetOutgoingMessage sendMsg = netPeer.CreateMessage(); sendMsg.Write("RELEASE_GAME_WEB"); sendMsg.Write(ClientConstants.version.ToString()); //send authentication public key and verifications. SecureMessageEncoder sem = new SecureMessageEncoder(sendMsg); sem.WriteBytes(ecdhrsaProvider.GetECDHPublicKey()); sem.WriteBytes(ecdhrsaProvider.GetSignedHash()); sem.WriteBytes(ecdhrsaProvider.GetRSAPublicKey()); sendMsg = sem.PackAndGet(); IPEndPoint ipEnd = new IPEndPoint(IPAddress.Parse(ip), port); NetConnection connection = netPeer.Connect(ipEnd, sendMsg); Console.WriteLine("connected to server"); // in your separate thread while (netPeer.MessageReceivedEvent.WaitOne()) { NetIncomingMessage msg = netPeer.ReadMessage(); CMessageParseManager.parseMessage(msg, this); netPeer.Recycle(msg); Console.WriteLine("Unique identifier is " + NetUtility.ToHexString(netPeer.UniqueIdentifier)); } } catch (Exception e) { Console.WriteLine(e); } }
/// <summary> /// Always checks if there's a incoming message and tells the manager. /// </summary> public void ProcessMessages() { while (Listening) { Thread.Sleep(1); NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { //Server only Messages case NetIncomingMessageType.DiscoveryRequest: ((NetServerManager)manager).OnDiscoverRequest(msg); break; case NetIncomingMessageType.ConnectionApproval: ((NetServerManager)manager).OnConnectionApproval(msg); break; //Client only Messages case NetIncomingMessageType.DiscoveryResponse: ((NetClientManager)manager).OnDiscoverResponse(msg); break; //Server and Client Messages case NetIncomingMessageType.Data: //Data messages are converted in packets and then transmitted further var packet = Packet.ToPacket(msg); manager.RecievePacket(packet); break; case NetIncomingMessageType.StatusChanged: manager.StatusChange(msg); break; //Error Messages case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: Debug.WriteLine(msg.ReadString()); break; default: Debug.WriteLine(Properties.strings.listenerUnhandledMessage, msg.MessageType); break; } peer.Recycle(msg); } } Debug.WriteLine(Properties.strings.listenerThreadFinished); }
/// <summary> /// Reads any messages in the queue and updates Entities accordingly. /// Usually called in the game loop. /// Read messages are recycled at each iteration. /// </summary> public void Update() { lastUpdateDelta = ServerTime - lastUpdateTime; lastUpdateTime = ServerTime; // early out, don't update if network not running // allows generic update call in main gameloop before // network has initialized if (network == null || network.Status != NetPeerStatus.Running) { return; } NetIncomingMessage msg; while ((msg = network.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: log.Debug(msg.ReadString()); break; case NetIncomingMessageType.WarningMessage: log.Warning(msg.ReadString()); break; case NetIncomingMessageType.ErrorMessage: log.Error(msg.ReadString()); break; case NetIncomingMessageType.StatusChanged: ProcessStatusChangedMessage(msg); break; case NetIncomingMessageType.Data: ProcessDataMessage(msg); break; } network.Recycle(msg); } if (Configuration.DeadReckonSeconds > 0) { timeToDeadReckon -= lastUpdateDelta; if (timeToDeadReckon <= 0) { DeadReckon(); timeToDeadReckon = Configuration.DeadReckonSeconds; } } }
/// <summary> /// Process incoming packets. /// </summary> public void ProcessPackets() { // client does not always have its networking running, for example on main menu if (IsClient && _netPeer == null) { return; } // server on the other hand needs it to be running DebugTools.Assert(_netPeer != null); NetIncomingMessage msg; while ((msg = _netPeer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.VerboseDebugMessage: Logger.DebugS("net", msg.ReadString()); break; case NetIncomingMessageType.DebugMessage: Logger.InfoS("net", msg.ReadString()); break; case NetIncomingMessageType.WarningMessage: Logger.WarningS("net", msg.ReadString()); break; case NetIncomingMessageType.ErrorMessage: Logger.ErrorS("net", msg.ReadString()); break; case NetIncomingMessageType.ConnectionApproval: HandleApproval(msg); break; case NetIncomingMessageType.Data: DispatchNetMessage(msg); break; case NetIncomingMessageType.StatusChanged: HandleStatusChanged(msg); break; default: Logger.WarningS("net", "{msg.SenderConnection.RemoteEndPoint.Address}: Unhandled incoming packet type: {msg.MessageType}"); break; } _netPeer.Recycle(msg); } }
public void PeerListener(NetPeer peer) { while (true) { NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { NetConnection connection = msg.SenderConnection; switch (msg.MessageType) { case NetIncomingMessageType.StatusChanged: switch (msg.SenderConnection.Status) { case NetConnectionStatus.Connected: logger.Info("{0}: connected", connection.RemoteEndPoint.Address.ToString()); ExecuteCommand(new CmdInitOk(connection)); break; case NetConnectionStatus.Disconnected: logger.Info("{0}: disconnected", connection.RemoteEndPoint.Address.ToString()); break; case NetConnectionStatus.Disconnecting: logger.Info("{0}: disconnecting", connection.RemoteEndPoint.Address.ToString()); break; } break; case NetIncomingMessageType.Data: msg.Decrypt(new NetRC2Encryption(peer, connection.CryptoKey)); string[] OpData = msg.ReadString().Split('&'); var OpCode = (LoginOperation)Enum.Parse(typeof(LoginOperation), OpData[0]); switch (OpCode) { case LoginOperation.AuthLog: string[] authData = OpData[1].Split('#'); string login = authData[0]; string pass = authData[1]; ExecuteCommand(new CmdLoginOkFail(connection, login, pass)); break; } break; } peer.Recycle(msg); } } }
public static void HandlePeerMessages(object peer) { if (peer is NetPeer) { NetPeer p = ((NetPeer)peer); NetIncomingMessage msg = ((NetPeer)peer).ReadMessage(); string machineName; switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: if (!peers.ContainsKey(msg.SenderEndpoint)) { Console.WriteLine("DiscoveryRequest from " + msg.SenderEndpoint.Address + " port: " + msg.SenderEndpoint.Port); NetOutgoingMessage requestResponse = p.CreateMessage(); requestResponse.Write(Environment.MachineName); p.SendDiscoveryResponse(requestResponse, msg.SenderEndpoint); } break; case NetIncomingMessageType.DiscoveryResponse: machineName = msg.ReadString(); Boolean connectedToPeer = false; foreach (NetConnection conn in p.Connections) { if (conn.RemoteEndpoint == msg.SenderEndpoint) { connectedToPeer = true; } } if (!connectedToPeer) { if (!peers.ContainsKey(msg.SenderEndpoint)) { Console.WriteLine("DiscoveryResponse from " + msg.SenderEndpoint.Address + " port: " + msg.SenderEndpoint.Port + " machine name: " + machineName); peers.Add(msg.SenderEndpoint, machineName); } NetOutgoingMessage hailMessage = p.CreateMessage(); hailMessage.Write(Environment.MachineName); NetConnection senderConn = p.Connect(msg.SenderEndpoint, hailMessage); } break; } p.Recycle(msg); } }
public void Refresh() { NetIncomingMessage message; while ((message = peer.ReadMessage()) != null) { switch (message.MessageType) { } peer.Recycle(message); } }
public bool TryGetInboundBuffer(out IBuffer buffer, out IConnection connection) { buffer = default(IBuffer); connection = default(IConnection); var message = TryHandleInboundMessage(); if (message == null) { return(true); } var lidgrenId = message.SenderConnection?.RemoteUniqueIdentifier ?? -1; Debug.Assert(mGuidLookup != null, "mGuidLookup != null"); if (!mGuidLookup.TryGetValue(lidgrenId, out var guid)) { Log.Error($"Missing connection: {guid}"); mPeer.Recycle(message); return(false); } connection = mNetwork.FindConnection(guid); if (connection != null) { var lidgrenConnection = connection as LidgrenConnection; if (lidgrenConnection?.Aes == null) { Log.Error("No provider to decrypt data with."); return(false); } if (!lidgrenConnection.Aes.Decrypt(message)) { Log.Error($"Error decrypting inbound Lidgren message [Connection:{connection.Guid}]."); return(false); } } else { Log.Warn($"Received message from an unregistered endpoint."); } buffer = new LidgrenBuffer(message); return(true); }
void HandleWebConnections() { NetIncomingMessage message; while ((message = peer.ReadMessage()) != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: // data code break; case NetIncomingMessageType.StatusChanged: switch (message.SenderConnection.Status) { case NetConnectionStatus.Connected: Debug.WriteLine("Connected!"); break; case NetConnectionStatus.Disconnected: ship2 = null; Debug.WriteLine("Disconnected..."); break; } break; case NetIncomingMessageType.DiscoveryResponse: peer.Connect("176.135.163.41", 8000, peer.CreateMessage("yes")); break; case NetIncomingMessageType.DiscoveryRequest: var msg = peer.CreateMessage(); msg.Write("hi"); peer.SendDiscoveryResponse(msg, message.SenderEndPoint); break; case NetIncomingMessageType.DebugMessage: Console.WriteLine(message.ReadString()); break; default: Console.WriteLine("unhandled message with type: " + message.MessageType); break; } peer.Recycle(message); } }
/// <summary> /// Reads incoming messages. Call in a game loop. /// </summary> /// <param name="msgHandler">A function that handles data messages.</param> /// <param name="statusHandler">A function that handles status messages.</param> public void ReadMessages(Action <NetIncomingMessage> msgHandler, Action <NetConnectionStatus> statusHandler) { NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); if (status == NetConnectionStatus.Connected) { connected = true; } statusHandler(status); break; case NetIncomingMessageType.ConnectionApproval: if (connected) { msg.SenderConnection.Deny(); } else { msg.SenderConnection.Approve(); } break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.Error: logMessage(msg.ReadString()); break; case NetIncomingMessageType.Data: msgHandler(msg); break; default: logMessage($"Unhandled type: {msg.MessageType}"); break; } peer.Recycle(msg); } }
/// <summary> /// Process incoming packets. /// </summary> public void ProcessPackets() { Debug.Assert(_netPeer != null); NetIncomingMessage msg; while ((msg = _netPeer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.VerboseDebugMessage: Logger.Debug($"[NET] {msg.ReadString()}"); break; case NetIncomingMessageType.DebugMessage: Logger.Info("[NET] " + msg.ReadString()); break; case NetIncomingMessageType.WarningMessage: Logger.Warning("[NET] " + msg.ReadString()); break; case NetIncomingMessageType.ErrorMessage: Logger.Error("[NET] " + msg.ReadString()); break; case NetIncomingMessageType.ConnectionApproval: HandleApproval(msg); break; case NetIncomingMessageType.Data: DispatchNetMessage(msg); break; case NetIncomingMessageType.StatusChanged: HandleStatusChanged(msg); break; default: Logger.Warning($"[NET] {msg.SenderConnection.RemoteEndPoint.Address}: Unhandled incoming packet type: {msg.MessageType}"); break; } _netPeer.Recycle(msg); } }
private void OnMessageReceivedCallback(object netPeerObject) { // It could be a library message var incomingMessage = netPeer.ReadMessage(); switch (incomingMessage.MessageType) { case NetIncomingMessageType.StatusChanged: HandleStatusChangeMessage(incomingMessage); break; case NetIncomingMessageType.UnconnectedData: HandleUnconnectedDataMessage(incomingMessage); break; case NetIncomingMessageType.NatIntroductionSuccess: HandleNatIntroductionSuccessMessage(incomingMessage); break; case NetIncomingMessageType.Data: HandleDataMessage(incomingMessage); break; case NetIncomingMessageType.DebugMessage: HandleDebugMessage(incomingMessage); break; case NetIncomingMessageType.VerboseDebugMessage: HandleDebugMessage(incomingMessage); break; case NetIncomingMessageType.WarningMessage: HandleDebugMessage(incomingMessage); break; case NetIncomingMessageType.ErrorMessage: HandleDebugMessage(incomingMessage); break; } netPeer.Recycle(incomingMessage); }