private void SendDiscoveryResponse(IPEndPoint ip) { NetOutgoingMessage response; switch (_config.SysType) { case SysType.Peer: response = _netPeer.CreateMessage(); response.Write(_peerIDString); _netPeer.SendDiscoveryResponse(response, ip); break; case SysType.Client: response = _netClient.CreateMessage(); response.Write(_peerIDString); _netClient.SendDiscoveryResponse(response, ip); break; case SysType.Server: response = _netServer.CreateMessage(); response.Write(_peerIDString); _netServer.SendDiscoveryResponse(response, ip); break; } }
/// <summary> /// Reads every message in the queue and returns a list of data messages. /// Other message types just write a Console note. /// This should be called every update by the Game Screen /// The Game Screen should implement the actual handling of messages. /// </summary> /// <returns></returns> public List <NetIncomingMessage> CheckForMessages() { mIncomingMessages.Clear(); NetIncomingMessage incomingMessage; string output = ""; while ((incomingMessage = mPeer.ReadMessage()) != null) { switch (incomingMessage.MessageType) { case NetIncomingMessageType.DiscoveryRequest: mPeer.SendDiscoveryResponse(null, incomingMessage.SenderEndPoint); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: if (mRole == AgentRole.Server) { output += incomingMessage.ReadString() + "\n"; } break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)incomingMessage.ReadByte(); if (mRole == AgentRole.Server) { output += "Status Message: " + incomingMessage.ReadString() + " \n"; } if (status == NetConnectionStatus.Connected) { //PLAYER CONNECTED //Message to send the player their ID NetOutgoingMessage idMessage = mPeer.CreateMessage(); idMessage.Write((byte)MessageType.PlayerID); idMessage.Write(nextPlayerID++); mPeer.SendMessage(idMessage, incomingMessage.SenderConnection, NetDeliveryMethod.ReliableOrdered); IsPlayerConnected = true; } break; case NetIncomingMessageType.Data: mIncomingMessages.Add(incomingMessage); break; default: // unknown message type break; } } if (mRole == AgentRole.Server) { StreamWriter textOut = new StreamWriter(new FileStream("log.txt", FileMode.Append, FileAccess.Write)); textOut.Write(output); textOut.Close(); } return(mIncomingMessages); }
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); } }
////////////////////////////////////////////////////////////////////////////// #region Inheritance protected override bool HandleMessage(NetPeer peer, NetIncomingMessage msg) { if (base.HandleMessage(peer, msg)) { return(true); } switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: { if (m_respondsToDiscovery) { NetOutgoingMessage message = peer.CreateMessage(); PostNotificationImmediately(NetworkNotifications.LocalClientDiscovered, message); peer.SendDiscoveryResponse(message, msg.SenderEndPoint); return(true); } return(false); } } return(false); }
public Object Listener() // Listens for incoming messages on your peer port. { NetIncomingMessage message = peer.ReadMessage(); // Reads any incoming messages assuming there are any. if (message != null) // Makes sure there actually is a message. { switch (message.MessageType) // Checks for the message type that we grabbed above. { case NetIncomingMessageType.DiscoveryRequest: // Someone is looking for you because they requested this port number. NetOutgoingMessage res = peer.CreateMessage(); // Creates a response / packet to send back. res.Write("Here!"); // Replies with "Here!" in theory you could customize this for different networks to choose what to do peer.SendDiscoveryResponse(res, message.SenderEndPoint); break; case NetIncomingMessageType.DiscoveryResponse: // Your request was received and you got a response back. peer.Connect(message.SenderEndPoint); // Since you got a message back you connect to the end point. break; case NetIncomingMessageType.Data: // You received Data or an update from a peer return(DeserializeData(message.ReadBytes(message.LengthBytes))); } } return(null); }
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); } } }
static void Main(string[] args) { var config = new NetPeerConfiguration("MultiPlayer"); config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); config.EnableMessageType(NetIncomingMessageType.ConnectionApproval); config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); config.AcceptIncomingConnections = true; config.Port = 5002; var Me = new NetPeer(config); Me.Start(); Me.DiscoverLocalPeers(5001); while (true) { NetIncomingMessage message; while ((message = Me.ReadMessage()) != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: Console.WriteLine(message.ReadString()); break; case NetIncomingMessageType.DiscoveryRequest: var response = Me.CreateMessage("Uuum hi..?"); Me.SendDiscoveryResponse(response, message.SenderEndPoint); Console.WriteLine($"Someone at {message.SenderEndPoint.Address} is attempting to discover us!"); break; case NetIncomingMessageType.DiscoveryResponse: Me.Connect(message.SenderEndPoint); Console.WriteLine($"Peer discovered at {message.SenderEndPoint.Address}. Attempting to connect."); //TODO connect? break; case NetIncomingMessageType.ConnectionApproval: message.SenderConnection.Approve(); Console.WriteLine($"Uuum. Someone connected. I don't really know what to do now..."); break; case NetIncomingMessageType.StatusChanged: Console.WriteLine(message.ReadString()); break; default: Console.WriteLine(message.ReadString()); break; } } } }
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 List <NetIncomingMessage> ReadMessages() { _incomingMessages.Clear(); NetIncomingMessage msg; while ((msg = _peer.ReadMessage()) != null) { //Log("Received " + msg.MessageType + " message"); switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: _peer.SendDiscoveryResponse(null, msg.SenderEndpoint); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: if (_role == AgentRole.Server) { Log(msg.ReadString()); } break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); Log("Status message: " + msg.ReadString()); if (status == NetConnectionStatus.Connected) { OnPlayerConnect(msg.SenderConnection); } else if (status == NetConnectionStatus.Disconnected) { OnPlayerDisconnect(msg.SenderConnection); } break; case NetIncomingMessageType.Data: _incomingMessages.Add(msg); break; default: Log("ERROR: Unknown message type"); break; } } return(_incomingMessages); }
public void HandleMessage(NetIncomingMessage message, ref bool recycle) { Debug.Assert(!didDisconnect); RemotePeer senderRemotePeer = null; if (message.SenderConnection != null) { senderRemotePeer = message.SenderConnection.Tag as RemotePeer; } try { switch (message.MessageType) { case NetIncomingMessageType.DiscoveryRequest: // (Clients trying to find LAN games) { var response = NetPeer.CreateMessage(); DiscoveredGame.WriteDiscoveryResponse(owner.appConfig, response, owner.GameInfo, IsFull, owner.NetworkApplication.GetDiscoveryData()); NetPeer.SendDiscoveryResponse(response, message.SenderEndPoint); } break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)message.ReadByte(); switch (status) { case NetConnectionStatus.Connected: HandleConnection(message.SenderConnection); break; case NetConnectionStatus.Disconnected: HandleDisconnection(message.SenderConnection, message); break; } break; case NetIncomingMessageType.UnconnectedData: HandleUnconnectedMessage(message); break; case NetIncomingMessageType.Data: HandleNetworkManagementFromClient(message); break; } } catch (NetworkDataException exception) { NetworkDataError(senderRemotePeer, exception); } }
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); } }
internal static void SendRequestHostsResponse(NetPeer peer, IPEndPoint recipientEndPoint, bool localDiscovery, Guid guid, NetworkSessionPublicInfo publicInfo) { var response = peer.CreateMessage(); response.Write((byte)MasterServerMessageType.RequestHosts); response.Write((byte)MasterServerMessageResult.Ok); response.Write(guid.ToString()); publicInfo.Pack(response); if (localDiscovery) { peer.SendDiscoveryResponse(response, recipientEndPoint); } else { peer.SendUnconnectedMessage(response, recipientEndPoint); } }
public static void RecvMCS() { while (true) { Thread.Sleep(10); NetIncomingMessage msg; while ((msg = server.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.StatusChanged: Console.WriteLine(((NetConnectionStatus)msg.ReadByte()).ToString()); break; case NetIncomingMessageType.DiscoveryRequest: NetOutgoingMessage response = server.CreateMessage(); response.Write("Server InduZtry"); server.SendDiscoveryResponse(response, msg.SenderEndPoint); recipient = server.Connect(msg.SenderEndPoint); Console.WriteLine("Discovered Peer " + msg.SenderEndPoint); break; default: Console.WriteLine("Unhandled type: " + msg.MessageType); break; } server.Recycle(msg); } } }
public void messageStream() { while (isActive) { if (watch == null) { watch = Stopwatch.StartNew(); } else { watch.Reset(); } NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: addToLog("Discovery Request from ip: " + msg.SenderEndPoint.Address.ToString()); NetOutgoingMessage resp = peer.CreateMessage(); resp.Write(playerName); peer.SendDiscoveryResponse(resp, msg.SenderEndPoint); break; case NetIncomingMessageType.DiscoveryResponse: addToLog("Discovery Response from player: " + msg.ReadString()); peer.Connect(msg.SenderEndPoint); isConnected = true; break; case NetIncomingMessageType.ConnectionApproval: msg.SenderConnection.Approve(); NetOutgoingMessage send = this.createPeerInfo(msg.SenderEndPoint, ""); break; case NetIncomingMessageType.Data: try{ int messageType = (int)msg.ReadByte(); if (((MessageType)messageType) == MessageType.File) { string[] gameInfo = TransferLogic.getFileInfo(msg); //sets msg cursor at files contents TransferLogic logic = TransferLogic.instantiateTransfer(gameInfo); TransferLogic.createGameStructure(gameInfo[1]); user.CurrentGame = gameInfo[1]; if (logic != null) { byte[] contents = msg.ReadBytes(logic.length); logic.writeFile(contents); logic.copyToGameFile(); } } else if (((MessageType)messageType) == MessageType.FileUpdate) { string length = TransferLogic.getNextPart(msg); int len; if (int.TryParse(length, out len)) { TransferLogic logic = new TransferLogic("persistent.sfs", user.CurrentGame, FileType.PERSISTENT, len); logic.readSaveUpdate(msg); } } }catch (Exception e) { Console.WriteLine(e.Message); } break; case NetIncomingMessageType.UnconnectedData: break; case NetIncomingMessageType.StatusChanged: break; default: break; } } lock (_taskLock) { if (sendTasks.Count > 0) { MultiplayerTask send = sendTasks.Dequeue(); send.peer = new MultiplayerTask.Peer(); send.peer.playerName = this.playerName; send.peer.connect = false; NetOutgoingMessage snd = peer.CreateMessage(); snd.Write(JsonConvert.SerializeObject(send)); } } watch.Stop(); long elapsed = watch.ElapsedMilliseconds; Thread.Sleep(1000 / networkRate - (int)elapsed); } }
public void ProcessNet() { // read messages while (!shouldQuit) { NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { //Request from other peers case NetIncomingMessageType.DiscoveryRequest: if (allowDiscovery) { NetOutgoingMessage response = peer.CreateMessage(); response.Write(name); response.Write(peer.UniqueIdentifier.ToString()); //Send the response to the sender of the request peer.SendDiscoveryResponse(response, msg.SenderEndPoint); } break; case NetIncomingMessageType.DiscoveryResponse: string peerName = msg.ReadString(); string peerUniqueId; try { peerUniqueId = msg.ReadString(); } catch (Exception error) { peerUniqueId = "HighNoon"; } string myId = peer.UniqueIdentifier.ToString(); //returns "random" no. if (myId != peerUniqueId) // if (name == peerName) { msg.Write(peerName); msg.Write(peerUniqueId); if (isNewOpponent(peerName, peerUniqueId)) { } ; foundPeers.Add(msg); OpponentEventArgs opponent = new OpponentEventArgs(); opponent.opponentName = peerName; if (peerUniqueId == "HighNoon") { NetOutgoingMessage response = peer.CreateMessage(); response.Write(name); peer.SendDiscoveryResponse(response, msg.SenderEndPoint); } onOpponentDetected(opponent); } break; case NetIncomingMessageType.ConnectionApproval: //This means that we are being challenged if (allowDiscovery) { int charNum = 0; string challengerName = msg.ReadString(); try { charNum = msg.ReadInt32(); } catch (Exception ex) { } ChallengeEventArgs receivedChallenge = new ChallengeEventArgs(); receivedChallenge.challengerName = challengerName; receivedChallenge.characterNumber = charNum; msg.Write(challengerName); challenger = msg; onChallengeReceived(receivedChallenge); } else { msg.SenderConnection.Deny(); } break; case NetIncomingMessageType.StatusChanged: //Got rid of if statements here NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte(); ConnectionEventArgs connectionStatus = new ConnectionEventArgs(); if (status == NetConnectionStatus.Connected) { challenger = msg; allowDiscovery = false; connectionStatus.connected = true; connectionStatus.message = "Connected"; onConnected(connectionStatus); NetOutgoingMessage piece = peer.CreateMessage(); if (goFirst) { piece.Write((int)6); piece.Write("Light"); } else { piece.Write((int)6); piece.Write("Dark"); } piece.Write(name); peer.SendMessage(piece, challenger.SenderConnection, NetDeliveryMethod.ReliableOrdered); //MessageBox.Show("You are Connected!"); } if (status == NetConnectionStatus.Disconnected) { string reason = msg.ReadString(); allowDiscovery = true; connectionStatus.connected = false; connectionStatus.message = reason; onDisconnected(connectionStatus); //MessageBox.Show("Something happened :( " + reason); } break; case NetIncomingMessageType.Data: //Reads what kind of protocol inside the message received int command = msg.ReadInt32(); // Message transmission if (command == (int)Protocol.Type.chatMessage) { MessageEventArgs message = new MessageEventArgs(); message.text = msg.ReadString(); onMessageReceived(message); //MessageBox.Show("Message: " + message.text); } // Move transmission if (command == (int)Protocol.Type.move) { string playerName = msg.ReadString(); string gameType = msg.ReadString(); int fromRow; int fromCol; int toRow; int toCol; //Trying for Locomotion if (gameType == "Locomotion") { fromRow = msg.ReadInt32(); fromCol = msg.ReadInt32(); toRow = msg.ReadInt32(); toCol = msg.ReadInt32(); } else //If not { string HighNoonMove = msg.ReadString(); fromRow = 6 - int.Parse(HighNoonMove[0].ToString()); fromCol = int.Parse(HighNoonMove[1].ToString()); toRow = 6 - int.Parse(HighNoonMove[2].ToString()); toCol = int.Parse(HighNoonMove[3].ToString()); } MoveEventArgs move = new MoveEventArgs(); move.playerName = playerName; move.fromRow = fromRow; move.fromCol = fromCol; move.toRow = toRow; move.toCol = toCol; onMoveReceived(move); //MessageBox.Show("From:" + fromRow.ToString() + fromCol.ToString() + " to " + toRow.ToString() + toCol.ToString()); } break; default: // break; } } } //Console.WriteLine("Exiting net thread!"); }
/// <summary> Message loop to check type of message and handle it accordingly </summary> public void MessageLoop() { while ((_msg = _peer.ReadMessage()) != null) { s_bpsBytes += _msg.LengthBytes; switch (_msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: //Debug.WriteLine("ReceivePeersData DiscoveryRequest"); _peer.SendDiscoveryResponse(null, _msg.SenderEndPoint); break; case NetIncomingMessageType.DiscoveryResponse: // just connect to first server discovered //Debug.WriteLine("ReceivePeersData DiscoveryResponse CONNECT"); if (_peer.Connections.Any(x => x.RemoteEndPoint.Address.Equals(_msg.SenderEndPoint.Address))) { Debug.WriteLine("allreadyConnected"); } else { _peer.Connect(_msg.SenderEndPoint); } break; case NetIncomingMessageType.ConnectionApproval: //Debug.WriteLine("ReceivePeersData ConnectionApproval"); _msg.SenderConnection.Approve(); //broadcast this to all connected clients SendPeerInfo(_msg.SenderEndPoint.Address, _msg.SenderEndPoint.Port); break; case NetIncomingMessageType.Data: //another client sent us data //Read TypeData First Enums.MessageType mType = (Enums.MessageType)_msg.ReadByte(); if (mType == Enums.MessageType.String) { var metadata = _msg.ReadString(); if (metadata == "StartEvent") { var map = _msg.ReadString(); _isMaster = false; MasterNetConnection = _peer.Connections.FirstOrDefault(x => x.RemoteEndPoint.Address.ToString() == _msg.SenderEndPoint.Address.ToString()); Game1.Inst.Scene.Raise("startgame", map); } else if (metadata == "metadata") { Game1.Inst.Scene.Raise("network_data_text", _msg.ReadString()); } } else if (mType == Enums.MessageType.PeerInformation) { int byteLenth = _msg.ReadInt32(); byte[] addressBytes = _msg.ReadBytes(byteLenth); IPAddress ip = new IPAddress(addressBytes); int port = _msg.ReadInt32(); //connect IPEndPoint endPoint = new IPEndPoint(ip, port); Debug.WriteLine("Data::PeerInfo::Detecting if we're connected"); if (_peer.GetConnection(endPoint) == null) { //are we already connected? //Don't try to connect to ourself! if (_peer.Configuration.LocalAddress.GetHashCode() != endPoint.Address.GetHashCode() || _peer.Configuration.Port.GetHashCode() != endPoint.Port.GetHashCode()) { Debug.WriteLine(string.Format("Data::PeerInfo::Initiate new connection to: {0}:{1}", endPoint.Address.ToString(), endPoint.Port.ToString())); _peer.Connect(endPoint); } } } else if (mType == Enums.MessageType.Entity || mType == Enums.MessageType.EntityLight) { var cbody = new CBody(); var ctransform = new CTransform(); string modelname = ""; bool isPlayer = false; int id = 0; id = mType == Enums.MessageType.EntityLight ? _msg.ReadEntityLight(ref cbody, ref ctransform, ref modelname, ref isPlayer) : _msg.ReadEntity(ref cbody, ref ctransform, ref modelname, ref isPlayer); Game1.Inst.Scene.Raise("entityupdate", new EntitySync { ID = id, CBody = cbody, CTransform = ctransform, ModelFileName = modelname, IsPlayer = isPlayer }); } else if (mType == Enums.MessageType.CTransform) { var metadata = _msg.ReadString(); var data = _msg.ReadCTransform(); //Game1.Inst.Scene.Raise("network_data", data); } else if (mType == Enums.MessageType.Vector3) { var metadata = _msg.ReadString(); var data = _msg.ReadCTransform(); //Game1.Inst.Scene.Raise("network_data", data); } else if (mType == Enums.MessageType.CText) { var id = _msg.ReadInt32(); var data = _msg.ReadCText(); Game1.Inst.Scene.Raise("network_menu_data_received", new MenuItem { CText = data, Id = id }); } else if (mType == Enums.MessageType.Int32) { var metadata = _msg.ReadString(); var data = _msg.ReadInt32(); if (metadata == "network_game_end") { Game1.Inst.Scene.Raise("game_end", data); } } else if (mType == Enums.MessageType.PlayerInfo) { var date = _msg.ReadInt64(); if (!players.Any(x => x.IP == _msg.SenderEndPoint.Address.ToString() + " " + _msg.SenderEndPoint.Port.ToString())) { players.Add(new NetworkPlayer { IP = _msg.SenderEndPoint.Address.ToString() + " " + _msg.SenderEndPoint.Port.ToString(), Time = new DateTime(date), You = false }); Game1.Inst.Scene.Raise("update_peers", players.OrderBy(x => x.Time).ToList()); } } //Console.WriteLine("END ReceivePeersData Data"); break; case NetIncomingMessageType.UnconnectedData: Debug.WriteLine("UnconnectedData: " + _msg.ReadString()); break; case NetIncomingMessageType.VerboseDebugMessage: Debug.WriteLine(NetIncomingMessageType.VerboseDebugMessage + " " + _msg.ReadString()); break; case NetIncomingMessageType.DebugMessage: Debug.WriteLine(NetIncomingMessageType.DebugMessage + " " + _msg.ReadString()); break; case NetIncomingMessageType.WarningMessage: Debug.WriteLine(NetIncomingMessageType.WarningMessage + " " + _msg.ReadString()); break; case NetIncomingMessageType.ErrorMessage: Debug.WriteLine(NetIncomingMessageType.ErrorMessage + " " + _msg.ReadString()); break; default: Debug.WriteLine("ReceivePeersData Unknown type: " + _msg.MessageType.ToString()); try { Debug.WriteLine(_msg.SenderConnection); if (_msg.SenderConnection.Status == NetConnectionStatus.Disconnected) { //Maybe try to reconnect } Debug.WriteLine(_msg.ReadString()); } catch { Debug.WriteLine("Couldn't parse unknown to string."); } break; } } }
/// <summary> /// Handles when the server has received a message /// </summary> private void MessageReceived(object peer) { // Get the incoming message NetIncomingMessage inMsg = ((NetPeer)peer).ReadMessage(); // We don't want the server to crash on one bad packet try { // Determine the message type to correctly handle it switch (inMsg.MessageType) { // Handle when a client's status has changed case NetIncomingMessageType.StatusChanged: // Gets the status and reason NetConnectionStatus status = (NetConnectionStatus)inMsg.ReadByte(); string reason = inMsg.ReadString(); // Depending on the status, we handle players joining or leaving switch (status) { // A player has disconnected case NetConnectionStatus.Disconnected: PlayerLeft(myPlayers[inMsg.SenderConnection], reason); break; // A player is connecting case NetConnectionStatus.Connected: // Send the welcome packet SendWelcomePacket(myPlayers[inMsg.SenderConnection].PlayerId); break; } // Log the message Log("Connection status updated for connection from {0}: {1}", inMsg.SenderEndPoint, status); break; // Handle when a player is trying to join case NetIncomingMessageType.ConnectionApproval: if (IsSinglePlayerMode & (inMsg.SenderEndPoint.Address.ToString() != myAddress.ToString() || myPlayers.Where(X => !X.IsBot).Count() > 0)) { inMsg.SenderConnection.Deny("Server is in singleplayer mode"); break; } // Get the client's info an hashed password from the packet ClientTag clientTag = ClientTag.ReadFromPacket(inMsg); string hashedPass = inMsg.ReadString(); // Make sure we are in the lobby when joining new players if (myState == ServerState.InLobby) { // Check the password if applicable if ((myTag.PasswordProtected && myPassword.Equals(hashedPass)) | (!myTag.PasswordProtected)) { // Check to see if the lobby is full if (myPlayers.GetNextAvailableId() != -1) { // Go ahead and try to join that playa PlayerJoined(clientTag, inMsg.SenderConnection); Log("Player \"{0}\" joined from {1}", clientTag.Name, clientTag.Address); } else { // Deny connection if lobby is full inMsg.SenderConnection.Deny("Game is full"); Log("Player \"{0}\" was denied access to full game from {1}", clientTag.Name, clientTag.Address); } } else { // F**k you brah! inMsg.SenderConnection.Deny("Password authentication failed"); Log("Player \"{0}\" failed to connect (password failed) from {1}", clientTag.Name, clientTag.Address); } } else { // We are mid-way through a game inMsg.SenderConnection.Deny("Game has already started"); Log("Player \"{0}\" attempted to connect mid game from {1}", clientTag.Name, clientTag.Address); } break; // Handle when the server has received a discovery request case NetIncomingMessageType.DiscoveryRequest: // Make sure our tag is up to date myTag.PlayerCount = myPlayers.PlayerCount; myTag.SupportedPlayerCount = myPlayers.Count; if (!IsSinglePlayerMode && State == ServerState.InLobby) { // Prepare the response NetOutgoingMessage msg = myServer.CreateMessage(); // Write the tag to the response myTag.WriteToPacket(msg); // Send the response myServer.SendDiscoveryResponse(msg, inMsg.SenderEndPoint); Log("Pinged discovery response to {0}", inMsg.SenderEndPoint); } break; // Handles when the server has received data case NetIncomingMessageType.Data: HandleMessage(inMsg); break; } } // An exception has occured parsing the packet catch (Exception e) { // Log the exception Log("Encountered exception parsing packet from {0}:\n\t{1}", inMsg.SenderEndPoint, e); Logger.Write(e); } PumpMessages(); }
private void TimerUpdate(object sender, EventArgs e) { NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.Data: HandleIncomingMessage(msg); break; case NetIncomingMessageType.DiscoveryResponse: LogText("Connected to server: " + msg.SenderEndPoint); peer.Connect(msg.SenderEndPoint.Address.ToString(), mPort); foundServer = true; break; case NetIncomingMessageType.DiscoveryRequest: LogText("Client connected."); NetOutgoingMessage response = peer.CreateMessage(); peer.SendDiscoveryResponse(response, msg.SenderEndPoint); break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: LogText(msg.ReadString()); break; //case NetIncomingMessageType.StatusChanged: // msg.ReadByte(); // string reason = msg.ReadString(); // LogText(reason); // break; //default: // LogText(msg.MessageType.ToString()); // break; } } if (mReadyToSendMore) { if (mFileStreamIn != null) { SendSegment(); } else if (mFileQueue.Count > 0) { SendFile(mFileQueue[0]); mFileQueue.RemoveAt(0); } } if (!foundServer && stopWatch.Elapsed > TimeSpan.FromSeconds(1.0)) { stopWatch.Stop(); LogText("No server found, creating one."); StartServer(); } }
static void Main(string[] args) { Dictionary <long, IPEndPoint[]> registeredHosts = new Dictionary <long, IPEndPoint[]>(); NetPeerConfiguration config = new NetPeerConfiguration("master"); config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true); config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); config.Port = 15002; NetPeer peer = new NetPeer(config); peer.Start(); // keep going until ESCAPE is pressed Console.WriteLine("Press ESC to quit"); while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape) { NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.DiscoveryRequest: Console.WriteLine("Discover message from: " + msg.SenderEndPoint); // Create a response and write some example data to it NetOutgoingMessage response = peer.CreateMessage(); response.Write("master"); // Send the response to the sender of the request peer.SendDiscoveryResponse(response, msg.SenderEndPoint); break; case NetIncomingMessageType.UnconnectedData: // // We've received a message from a client or a host // // by design, the first byte always indicates action switch ((MasterServerMessageType)msg.ReadByte()) { case MasterServerMessageType.RegisterHost: // It's a host wanting to register its presence var id = msg.ReadInt64(); // server unique identifier Console.WriteLine("Got registration for host " + id); registeredHosts[id] = new IPEndPoint[] { msg.ReadIPEndPoint(), // internal msg.SenderEndPoint // external }; break; case MasterServerMessageType.RequestHostList: // It's a client wanting a list of registered hosts Console.WriteLine("Sending list of " + registeredHosts.Count + " hosts to client " + msg.SenderEndPoint); // Clear original list. NetOutgoingMessage outMsg = peer.CreateMessage(); outMsg.Write(true); peer.SendUnconnectedMessage(outMsg, msg.SenderEndPoint); foreach (var kvp in registeredHosts) { // send registered host to client NetOutgoingMessage om = peer.CreateMessage(); om.Write(false); om.Write(kvp.Key); om.Write(kvp.Value[0]); om.Write(kvp.Value[1]); peer.SendUnconnectedMessage(om, msg.SenderEndPoint); } break; case MasterServerMessageType.RequestIntroduction: // It's a client wanting to connect to a specific (external) host IPEndPoint clientInternal = msg.ReadIPEndPoint(); long hostId = msg.ReadInt64(); string token = msg.ReadString(); Console.WriteLine(msg.SenderEndPoint + " requesting introduction to " + hostId + " (token " + token + ")"); // find in list IPEndPoint[] elist; if (registeredHosts.TryGetValue(hostId, out elist)) { // found in list - introduce client and host to eachother Console.WriteLine("Sending introduction..."); peer.Introduce( elist[0], // host internal elist[1], // host external clientInternal, // client internal msg.SenderEndPoint, // client external token // request token ); } else { Console.WriteLine("Client requested introduction to nonlisted host!"); } break; case MasterServerMessageType.RemoveHost: long idRemove = msg.ReadInt64(); Console.WriteLine("De-register host " + idRemove); registeredHosts.Remove(idRemove); break; case MasterServerMessageType.HostConnected: long host = msg.ReadInt64(); Console.WriteLine("host: " + host + " is connected."); registeredHosts.Remove(host); // Remove this host. break; } break; case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: // print diagnostics message Console.WriteLine(msg.ReadString()); break; } } } peer.Shutdown("shutting down"); }
void ReadMessage() { NetIncomingMessage inMsg; if ((inMsg = peer.ReadMessage()) != null) { #if DEBUG Console.WriteLine($"msg: {inMsg.MessageType}"); #endif switch (inMsg.MessageType) { case NetIncomingMessageType.Data: // Handle custom messages Process(inMsg); break; case NetIncomingMessageType.DiscoveryResponse: try { // Parse game data FoundGame fg = ByteSerializer.ByteArrayToObject <FoundGame>(inMsg.Data); // skip if game is already discovered / up to date if (DiscoveredHosts.Contains(new KeyValuePair <IPEndPoint, FoundGame>(inMsg.SenderEndPoint, fg))) { break; } // Add server to list DiscoveredHosts.Add(inMsg.SenderEndPoint, fg); Console.WriteLine($"Discovered host at: {inMsg.SenderEndPoint}"); } catch { } break; case NetIncomingMessageType.DiscoveryRequest: if (isHost && !gameActive) { peer.SendDiscoveryResponse(PacketFactory.CreateFoundGameMessage(peer, FoundGame.CreateFromGrid(grid, peer.ConnectionsCount + 1)), inMsg.SenderEndPoint); } break; case NetIncomingMessageType.StatusChanged: // handle connection status messages if (isHost) { switch (inMsg.SenderConnection.Status) { case NetConnectionStatus.Connected: if (isHost) { PlayerConnection np = new PlayerConnection(Player.GetRandomisedPlayer(), inMsg.SenderConnection.RemoteEndPoint); peers.Add(np); players.Add(np.player); } Console.WriteLine($"{inMsg.SenderConnection.RemoteEndPoint} {inMsg.SenderConnection.Status}"); Console.WriteLine($"{peers.Count + 1} players currently connected"); break; case NetConnectionStatus.Disconnected: if (isHost) { PlayerConnection p = (from peer in peers where Equals(inMsg.SenderConnection.RemoteEndPoint, peer.ipEndPoint) select peer).Single(); peers.Remove(p); players.Remove(p.player); } Console.WriteLine($"{inMsg.SenderConnection.RemoteEndPoint} {inMsg.SenderConnection.Status}"); Console.WriteLine($"{peers.Count + 1} players currently connected"); break; } } else { switch (inMsg.SenderConnection.Status) { case NetConnectionStatus.Connected: case NetConnectionStatus.Disconnected: Console.WriteLine($"{inMsg.SenderConnection.RemoteEndPoint} {inMsg.SenderConnection.Status}"); Console.WriteLine($"{peer.Connections.Count + 1} players currently connected"); break; } } break; case NetIncomingMessageType.ConnectionApproval: if (isHost) { if (gameActive) { inMsg.SenderConnection.Deny("Game already started"); break; } // not max players if (grid.maxPlayers >= peer.ConnectionsCount + 1) { inMsg.SenderConnection.Approve(); } else { inMsg.SenderConnection.Deny("Game is full"); } } else { inMsg.SenderConnection.Approve(); // TODO: Validate with gameID } break; case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: Console.WriteLine(inMsg.ReadString()); break; default: throw new ArgumentOutOfRangeException(); } peer.Recycle(inMsg); } }
public void Update(GameTime gameTime) { nextSendUpdates = NetTime.Now; var listOfIncomingMessages = new List <NetIncomingMessage>(); var nMessages = peer.ReadMessages(listOfIncomingMessages); foreach (var message in listOfIncomingMessages) { sentDataGametime = gameTime.ElapsedGameTime.TotalMilliseconds; //RECIEVE DATA switch (message.MessageType) { case NetIncomingMessageType.DiscoveryRequest: // Create a response and write some example data to it NetOutgoingMessage response = peer.CreateMessage(); response.Write(NetworkHelper.GetCurrentIPAddress()); // Send the response to the sender of the request peer.SendDiscoveryResponse(response, message.SenderEndPoint); break; case NetIncomingMessageType.DiscoveryResponse: Console.WriteLine("Found server at " + message.SenderEndPoint + " name: " + message.ReadString()); break; case NetIncomingMessageType.Data: Console.WriteLine("Incoming game-data"); //Recieves data and puts it in the networkInputComponent for the remote player entity if (remotePlayerEntity != null) { var transformComponent = ComponentManager.Instance.GetComponentOfEntity <TransformComponent>(remotePlayerEntity); //Console.WriteLine(transformComponent.Position.ToString()); var velocityComponent = ComponentManager.Instance.GetComponentOfEntity <VelocityComponent>(remotePlayerEntity); var posx = message.ReadFloat(); var posy = message.ReadFloat(); var posz = message.ReadFloat(); var velx = message.ReadFloat(); var vely = message.ReadFloat(); var velz = message.ReadFloat(); velocityComponent.Velocity = new Vector3(velx, vely, velz); transformComponent.Position = new Vector3(posx, posy, posz); } break; case NetIncomingMessageType.StatusChanged: // handle connection status messages NetConnectionStatus status = (NetConnectionStatus)message.ReadByte(); if (status == NetConnectionStatus.RespondedConnect) { Console.WriteLine(NetUtility.ToHexString(message.SenderConnection.RemoteUniqueIdentifier) + " responded to connection!"); } if (status == NetConnectionStatus.Connected) { Console.WriteLine(NetUtility.ToHexString(message.SenderConnection.RemoteUniqueIdentifier) + " connected, yay!"); } if (status == NetConnectionStatus.Disconnecting) { Console.WriteLine(message.SenderConnection.RemoteUniqueIdentifier + " disconnected!"); //should we shut down th server if the client disconnects? peer.Shutdown("bye!"); } 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; } } /********************************************************************************************************/ /*********************************************SEND DATA**************************************************/ /********************************************************************************************************/ currentTime = NetTime.Now; if (currentTime > nextSendUpdates) { foreach (NetConnection player in peer.Connections) { NetOutgoingMessage om = peer.CreateMessage(); //sends data over the network to the host/client var transformComponent = ComponentManager.Instance.GetComponentOfEntity <TransformComponent>(localPlayerEntity); var velocityComponent = ComponentManager.Instance.GetComponentOfEntity <VelocityComponent>(localPlayerEntity); om.Write(transformComponent.Position.X); om.Write(transformComponent.Position.Y); om.Write(transformComponent.Position.Z); om.Write(velocityComponent.Velocity.X); om.Write(velocityComponent.Velocity.Y); om.Write(velocityComponent.Velocity.Z); peer.SendMessage(om, player, NetDeliveryMethod.UnreliableSequenced); if (runDiagnostics) { Diagnostics(om, gameTime); } } //send data 30 times per second nextSendUpdates += (1.0 / 30.0); } if (nMessages > 0) { Console.WriteLine(nMessages + " incoming messages!"); } }
private void waitForMessages() { while (peerOn) { if (DateTime.Now > nextPingTime) { for (int i = 0; i < availablePeers.Count; i++) //foreach (peerType p in availablePeers) { peerType p = availablePeers[i]; NetOutgoingMessage ping = peer.CreateMessage(); ping.Write((short)SentDataType.ping); peer.SendUnconnectedMessage(ping, p.address); } lastPingTime = DateTime.Now; nextPingTime = lastPingTime.AddSeconds(1); } for (int i = 0; i < availablePeers.Count; i++) //foreach (peerType p in availablePeers) { peerType p = availablePeers[i]; if (p.lastPing < DateTime.Now.AddSeconds(-2)) { availablePeers.Remove(p); PlayerRemoved(p, EventArgs.Empty); } } NetIncomingMessage msg; while ((msg = peer.ReadMessage()) != null) { switch (msg.MessageType) { case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: Console.WriteLine(msg.ReadString()); break; case NetIncomingMessageType.StatusChanged: // In case status changed // It can be one of these // NetConnectionStatus.Connected; // NetConnectionStatus.Connecting; // NetConnectionStatus.Disconnected; // NetConnectionStatus.Disconnecting; // NetConnectionStatus.None; // NOTE: Disconnecting and Disconnected are not instant unless client is shutdown with disconnect() Console.WriteLine(msg.SenderConnection.ToString() + " status changed. " + (NetConnectionStatus)msg.SenderConnection.Status); if (msg.SenderConnection.Status == NetConnectionStatus.Connected) { if (Connected != null) { foreach (peerType p in availablePeers) { if (p.address.Equals(peer.Connections[0].RemoteEndPoint)) { clientName = p.name; } } Connected(msg, EventArgs.Empty); } } if (msg.SenderConnection.Status == NetConnectionStatus.Disconnected) { if (Disconnected != null) { Disconnected(msg, EventArgs.Empty); } } break; case NetIncomingMessageType.ConnectionApproval: msg.SenderConnection.Approve(); iAmPlayer1 = false; break; case NetIncomingMessageType.DiscoveryRequest: #region old stuff //NetOutgoingMessage resp = peer.CreateMessage(); //resp.Write(peerName); //resp.Write(GAME_NAME); //peer.SendDiscoveryResponse(resp, msg.SenderEndPoint); //System.Net.IPAddress myAddress; //System.Net.IPAddress myAddressMask; //myAddress = NetUtility.GetMyAddress(out myAddressMask); //bool same = msg.SenderEndPoint.Address.Equals(myAddress); //if (!same) //{ // bool discoverSender = true; // foreach (peerType p in availablePeers) // { // if (p.address.Equals(msg.SenderEndPoint.Address)) // { // discoverSender = false; // break; // } // } // if (discoverSender) // { // peer.DiscoverKnownPeer(msg.SenderEndPoint); // } //} #endregion Console.WriteLine("Type = DiscoveryRequest; Sender = " + msg.SenderEndPoint.ToString()); getPeerId(msg.SenderEndPoint); if (!listContainsIPEndPoint(msg.SenderEndPoint) && msg.SenderEndPoint != myIPEndPoint) { peer.DiscoverKnownPeer(msg.SenderEndPoint); } break; case NetIncomingMessageType.DiscoveryResponse: Console.WriteLine("Type = DiscoveryResponse; Sender = " + msg.SenderEndPoint); string foundPeerName = msg.ReadString(); string foundGameName = msg.ReadString(); Console.WriteLine(foundPeerName); Console.WriteLine(foundGameName); addPeerToList(foundPeerName, foundGameName, msg.SenderEndPoint); Console.WriteLine("Available Peers:"); foreach (peerType p in availablePeers) { Console.WriteLine(p.name); } // Raise event causing lobby list to be updated. if (Discovered != null) { Discovered(msg, EventArgs.Empty); } break; case NetIncomingMessageType.Data: #region Data //Console.ForegroundColor = ConsoleColor.Cyan; //Console.WriteLine(msg.ReadString()); //Console.ResetColor(); short type = msg.ReadInt16(); //Console.WriteLine("Type = Data; Subtype = " + type + " Sender = " + msg.SenderEndPoint); if (type == (short)SentDataType.move) { Console.WriteLine("Type = move; Sender = " + msg.SenderEndPoint); moveType move = new moveType(); move.quad = msg.ReadInt16(); move.position = msg.ReadInt16(); move.isClockwise = msg.ReadBoolean(); if (MoveReceived != null) { MoveReceived(move, EventArgs.Empty); } } else if (type == (short)SentDataType.globalChat) { string message = msg.ReadString(); } else if (type == (short)SentDataType.privateChat) { string message = msg.ReadString(); } else if (type == (short)SentDataType.idRequest) { Console.WriteLine("Type = idRequest; Sender = " + msg.SenderEndPoint); sendId(msg.SenderEndPoint); } else if (type == (short)SentDataType.idResponse) { Console.WriteLine("Type = idResponse; Sender = " + msg.SenderEndPoint); otherId = msg.ReadInt32(); // Discovery Response if (otherId != myId) { NetOutgoingMessage resp = peer.CreateMessage(); resp.Write(peerName); resp.Write(GAME_NAME); peer.SendDiscoveryResponse(resp, msg.SenderEndPoint); } else { myIPEndPoint = msg.SenderEndPoint; } } break; #endregion case NetIncomingMessageType.UnconnectedData: #region Unconnected Data type = msg.ReadInt16(); if (type == (short)SentDataType.move) { Console.WriteLine("Type = move; Sender = " + msg.SenderEndPoint); short quadrant = msg.ReadInt16(); short position = msg.ReadInt16(); bool isClockwise = msg.ReadBoolean(); } else if (type == (short)SentDataType.globalChat) { string message = msg.ReadString(); } else if (type == (short)SentDataType.privateChat) { string message = msg.ReadString(); } else if (type == (short)SentDataType.idRequest) { Console.WriteLine("Type = idRequest; Sender = " + msg.SenderEndPoint); sendId(msg.SenderEndPoint); } else if (type == (short)SentDataType.idResponse) { Console.WriteLine("Type = idResponse; Sender = " + msg.SenderEndPoint); otherId = msg.ReadInt32(); // Discovery Response if (otherId != myId) { NetOutgoingMessage resp = peer.CreateMessage(); resp.Write(peerName); resp.Write(GAME_NAME); peer.SendDiscoveryResponse(resp, msg.SenderEndPoint); } else { myIPEndPoint = msg.SenderEndPoint; } } else if (type == (short)SentDataType.connectRequest) { // Raise event causing user to get connection request if (ConnectionRequest != null) { pendingConnectRequester = msg.SenderEndPoint; ConnectionRequest(msg.ReadString(), EventArgs.Empty); } } else if (type == (short)SentDataType.ping) { if (peer.Connections.Count == 0) { NetOutgoingMessage resp = peer.CreateMessage(); resp.Write((short)SentDataType.pingResponse); peer.SendUnconnectedMessage(resp, msg.SenderEndPoint); } } else if (type == (short)SentDataType.pingResponse) { foreach (peerType p in availablePeers) { if (p.address == msg.SenderEndPoint) { p.lastPing = DateTime.Now; } } } break; #endregion default: Console.WriteLine("Unhandled type: " + msg.MessageType); break; } peer.Recycle(msg); } } }