/// <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); }
protected void SendPacket(NetOutgoingMessage msg, NetConnection connection, NetDeliveryMethod deliveryMethod = NetDeliveryMethod.ReliableOrdered) { if (connection != null) { _netPeer.SendMessage(msg, connection, deliveryMethod, 0); } }
private void SignalReadyForMore(bool endOfFile) { NetOutgoingMessage sendMsg = peer.CreateMessage(); sendMsg.Write((byte)MessageType.eReadyForMore); sendMsg.Write(endOfFile); peer.SendMessage(sendMsg, peer.Connections, NetDeliveryMethod.ReliableOrdered, 0); }
/// <summary> /// Sends a message based on data serialized by a serialize function. /// </summary> /// <param name="serialize">The function that serializes the data.</param> public void SendMessage(Action <NetOutgoingMessage> serialize) { if (peer.ConnectionsCount > 0) { NetOutgoingMessage sendMsg = peer.CreateMessage(); serialize(sendMsg); peer.SendMessage(sendMsg, peer.Connections, NetDeliveryMethod.ReliableOrdered, 0); } }
public void SendTorrentListUpdate(Torrent[] torList) { if (Peer.Connections.Count > 0) { NetOutgoingMessage newTorrentList = Peer.CreateMessage(); byte[] torBytes = TorrentSerializer.Serialize(torList); newTorrentList.Write((byte)MessageType.UpdateTorrentList); newTorrentList.Write(torBytes); Peer.SendMessage(newTorrentList, Peer.Connections, NetDeliveryMethod.ReliableOrdered, 0); } }
/// <inheritdoc /> public void ServerSendToAll(NetMessage message) { if (_netPeer == null || _netPeer.ConnectionsCount == 0) { return; } var packet = BuildMessage(message); var method = GetMethod(message.MsgGroup); _netPeer.SendMessage(packet, _netPeer.Connections, method, 0); }
public void Send(Packet packet, IList <NetConnection> connections, NetDeliveryMethod deliveryMethod = NetDeliveryMethod.Unreliable) { foreach (NetConnection netConnection in connections) { NetPeer.SendMessage(GetOutgoingMessageFromPacket(packet), netConnection, deliveryMethod); } }
public void Send(ServerOutgoingPacketType header, IList <NetConnection> connections, NetDeliveryMethod deliveryMethod = NetDeliveryMethod.Unreliable) { foreach (NetConnection netConnection in connections) { NetPeer.SendMessage(CreateMessageWithHeader((int)header), netConnection, deliveryMethod); } }
public void sendCreateMouseJoint(FixedMouseJoint mouseJoint) { NetOutgoingMessage om = _peer.CreateMessage(); Body body = mouseJoint.BodyA; Vector2 localAnchorA = body.GetLocalVector(mouseJoint.WorldAnchorA); Vector2 point = mouseJoint.WorldAnchorB; om.Write((int)MessageType.CreateMouseJoint); om.Write((int)body.UserData); // entityId om.Write(localAnchorA.X); om.Write(localAnchorA.Y); om.Write(point.X); om.Write(point.Y); _peer.SendMessage(om, _peer.Connections[0], NetDeliveryMethod.ReliableUnordered); }
public void SendCommand(Command command) { if (!connected) { return; } if (isServer && (command.PlayerId == 0 || command.PlayerId == -1)) { localCommands.Add(command); } if (command.PlayerId != 0) { foreach (NetConnection connection in peer.Connections) { if (command.PlayerId == -1 || (command.PlayerId > 0 && connection == connections[command.PlayerId - 1])) { NetOutgoingMessage sendMsg = peer.CreateMessage(); sendMsg.Write((Int32)command.Type); sendMsg.Write((Int32)command.SourcePlayerId); sendMsg.Write(command.Data); peer.SendMessage(sendMsg, connection, NetDeliveryMethod.ReliableOrdered); } } } }
void BecomeApplicationConnected(RemotePeer remotePeer) { Debug.Assert(!remotePeer.PeerInfo.IsApplicationConnected); remotePeer.PeerInfo.IsApplicationConnected = true; owner.Log("Application Connected: " + remotePeer.PeerInfo); owner.AddApplicationConnection(remotePeer); var listNotApplicationConnected = ListNotApplicationConnected(remotePeer.Connection); if (listNotApplicationConnected.Count > 0) { var notAppConnectedMessage = NetPeer.CreateMessage(); notAppConnectedMessage.Write(P2PServerMessage.PeerBecameApplicationConnected); notAppConnectedMessage.Write(remotePeer.PeerInfo.ConnectionId); NetPeer.SendMessage(notAppConnectedMessage, listNotApplicationConnected, NetDeliveryMethod.ReliableOrdered, 0); } var joinMessage = NetPeer.CreateMessage(); joinMessage.Write(P2PServerMessage.PeerBecameApplicationConnected); joinMessage.Write(remotePeer.PeerInfo.ConnectionId); var connectedMessage = NetPeer.CreateMessage(); connectedMessage.Write(P2PServerMessage.PeerBecameApplicationConnected); connectedMessage.Write(remotePeer.PeerInfo.ConnectionId); owner.NetworkApplication.JoinOnServer(remotePeer, joinMessage, connectedMessage); NetPeer.SendMessage(joinMessage, ListApplicationConnected(remotePeer.Connection), NetDeliveryMethod.ReliableOrdered, 0); NetPeer.SendMessage(connectedMessage, remotePeer.Connection, NetDeliveryMethod.ReliableOrdered, 0); }
void BecomeApplicationDisconnected(RemotePeer remotePeer) { Debug.Assert(remotePeer.PeerInfo.IsApplicationConnected); remotePeer.PeerInfo.IsApplicationConnected = false; owner.Log("Application Disconnected: " + remotePeer.PeerInfo); owner.RemoveApplicationConnection(remotePeer); var listNotApplicationConnected = ListNotApplicationConnected(remotePeer.Connection); if (listNotApplicationConnected.Count > 0) { var notAppConnectedMessage = NetPeer.CreateMessage(); notAppConnectedMessage.Write(P2PServerMessage.PeerLeftNetwork); notAppConnectedMessage.Write(remotePeer.PeerInfo.ConnectionId); NetPeer.SendMessage(notAppConnectedMessage, listNotApplicationConnected, NetDeliveryMethod.ReliableOrdered, 0); } var message = NetPeer.CreateMessage(); message.Write(P2PServerMessage.PeerLeftNetwork); message.Write(remotePeer.PeerInfo.ConnectionId); owner.NetworkApplication.LeaveOnServer(remotePeer, message); NetPeer.SendMessage(message, ListApplicationConnected(remotePeer.Connection), NetDeliveryMethod.ReliableOrdered, 0); }
public void sendTo(NetConnection conn, LimeMessage message) { var packet = lidgrenPeer.CreateMessage(); msgFactory.write(packet, message); lidgrenPeer.SendMessage(packet, conn, message.deliveryMethod); }
public static void SendMessage(NetPeer peer, NetworkMessageType networkMessageType, int data, NetConnection recipient) { NetOutgoingMessage message = peer.CreateMessage(); message.Write((byte)networkMessageType); message.Write(data, 32); peer.SendMessage(message, recipient, NetDeliveryMethod.ReliableUnordered); }
private void Send(NetPeer peer, NetConnection destination, NetDeliveryMethod method) { NetOutgoingMessage nom = peer.CreateMessage(InitialMessageSize()); nom.Write(this.GetType().FullName); this.WriteData(nom); peer.SendMessage(nom, destination, method); }
public void sendMove(string playerName, int fromRow, int fromCol, int toRow, int toCol) { NetOutgoingMessage move = peer.CreateMessage(); move.Write((int)Protocol.Type.move); move.Write(playerName); move.Write("Locomotion"); move.Write((int)fromRow); move.Write((int)fromCol); move.Write((int)toRow); move.Write((int)toCol); peer.SendMessage(move, NetWorker.challenger.SenderConnection, NetDeliveryMethod.ReliableOrdered); }
void Update() { if (Input.GetKeyDown(KeyCode.Escape)) { Application.Quit(); } NetIncomingMessage message; while ((message = peer.ReadMessage()) != null) { switch (message.MessageType) { case NetIncomingMessageType.Data: break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)message.ReadByte(); Debug.Log("status " + status); switch (status) { case NetConnectionStatus.Connected: Vector3 spawnPosition = Vector3.zero; Quaternion spawnRotation = Quaternion.identity; MyNetwork.SpawnPlayer(spawnPosition, spawnRotation); NetOutgoingMessage newMessage = peer.CreateMessage(); newMessage.Write((byte)NetDataType.SPAWN_PLAYER); newMessage.Write(spawnPosition); newMessage.Write(spawnRotation); NetSendResult result = peer.SendMessage(newMessage, message.SenderConnection, NetDeliveryMethod.ReliableUnordered); Debug.Log("sent: " + result); break; } break; case NetIncomingMessageType.WarningMessage: Debug.LogWarning(message.ReadString()); break; case NetIncomingMessageType.DebugMessage: Debug.Log(message.ReadString()); break; case NetIncomingMessageType.ConnectionApproval: { // TODO: Store connections message.SenderConnection.Approve(); break; } default: print("unhandled message with type: " + message.MessageType); break; } } }
public void UpdateRoom(RoomUpdateType type, Packet packet) { if (!IsHosting) { return; } if (type == RoomUpdateType.Additive) { foreach (string key in packet.Keys) { _serverRoom.Set(key, packet.Get(key)); } } else { _serverRoom = packet; } // Send update to Master NetOutgoingMessage outMessageM = _peer.CreateMessage(); outMessageM.Write((byte)DataType.Room); outMessageM.Write((byte)RoomCommand.Update); outMessageM.Write((byte)type); packet.Serialize(outMessageM); _master.NetConnection.SendMessage(outMessageM, NetDeliveryMethod.ReliableOrdered, 0); // Send update to connected Clients NetOutgoingMessage outMessageC = _peer.CreateMessage(); outMessageC.Write((byte)DataType.Room); outMessageC.Write((byte)RoomCommand.Update); _serverRoom.Serialize(outMessageC); NetConnection[] clientConns = _clientsCache. Where(x => x.Status == ConnectionStatus.Connected). Select(x => x.NetConnection).ToArray(); if (clientConns.Length > 0) { _peer.SendMessage(outMessageC, clientConns, NetDeliveryMethod.ReliableOrdered, 0); } }
public void Broadcast(NetOutgoingMessage message, NetDeliveryMethod deliveryMethod, int sequenceChannel) { if (deliveryMethod == NetDeliveryMethod.ReliableOrdered && sequenceChannel == 0) { throw new ArgumentException("ReliableOrdered channel 0 is reserved for P2P network management."); } netPeer.SendMessage(message, broadcastList, deliveryMethod, sequenceChannel); }
public static void SendMessage(NetOutgoingMessage message, NetDeliveryMethod method = NetDeliveryMethod.ReliableOrdered, int channel = 0) { if (connection != null) { peer.SendMessage(message, connection, method, channel); } }
public void SendMessageToClient(DataMessage msg) { if (server.ConnectionsCount > 0) { NetworkMessage sm = new NetworkMessage(); // Temporary switch (msg.type) { case DataMessage_Type.GAME_STATE: GameStateMessage gameStateMsg = msg as GameStateMessage; sm.Set_Data(gameStateMsg); break; case DataMessage_Type.PLAYER_UPDATE: PlayerUpdateMessage playerMsg = msg as PlayerUpdateMessage; sm.Set_Data(playerMsg); break; case DataMessage_Type.FENCE_HIT: FenceHitMessage fMsg = msg as FenceHitMessage; sm.Set_Data(fMsg); break; case DataMessage_Type.MISSLE_MINE: MissileMineMessage MMMsg = msg as MissileMineMessage; sm.Set_Data(msg); break; case DataMessage_Type.ROTATION: RotationMessage rMsg = msg as RotationMessage; sm.Set_Data(msg); break; case DataMessage_Type.MISSILEUPDATE: MissileUpdateMessage tmsg = msg as MissileUpdateMessage; sm.Set_Data(msg); break; case DataMessage_Type.GAME_OVER: GAMEOVERMESSAGE gomsg = msg as GAMEOVERMESSAGE; sm.Set_Data(msg); break; default: break; } NetOutgoingMessage om = server.CreateMessage(); om.Write(sm.Serialize()); server.SendMessage(om, server.Connections, NetDeliveryMethod.ReliableOrdered, 4); server.FlushSendQueue(); } }
private void RelayMessageToOtherClients(NetIncomingMessage msg, string msgBody) { var otherClients = OtherClients(msg); if (otherClients.Any()) { Net.SendMessage(Net.CreateMessage(msgBody), otherClients, NetDeliveryMethod.ReliableUnordered, 0); } }
public void SendMove(short quad, short position, bool isClockwise) { NetOutgoingMessage message = peer.CreateMessage(); message.Write((short)SentDataType.move); message.Write(quad); message.Write(position); message.Write(isClockwise); peer.SendMessage(message, peer.Connections[0], NetDeliveryMethod.ReliableOrdered); }
public void SendTo(Connection[] connections, Delivery delivery, Packet packet, Channel channel = Channel.Default) { try { NetOutgoingMessage outMessage = _peer.CreateMessage(); packet.Serialize(outMessage); _peer.SendMessage( outMessage, connections. Where(x => x.Status == ConnectionStatus.Connected). Select(x => x.NetConnection). ToArray(), (NetDeliveryMethod)delivery, (int)channel); } catch (NetException) { } }
/// <summary> /// Send the given message to the given recipients. /// </summary> /// <param name="recipient">The computers that should receive the message.</param> /// <param name="message">The message to send.</param> public void SendMessage(NetworkMessageRecipient recipient, INetworkMessage message) { switch (recipient) { case NetworkMessageRecipient.All: if (IsClient) { var msg = CreateMessage(LocalPlayer, message, broadcast: true); _client.SendMessage(msg, NetDeliveryMethod.ReliableOrdered); } else { var msg = CreateMessage(LocalPlayer, message, broadcast: false); Log <NetworkContext> .Info("Sending message {0} to all connections ({1})", SerializationHelpers.Serialize(message), string.Join(", ", _server.Connections.Select(c => ((Player)c.Tag).Name).ToArray())); _server.SendToAll(msg, NetDeliveryMethod.ReliableOrdered); _dispatcher.InvokeHandlers(LocalPlayer, message); } break; case NetworkMessageRecipient.Clients: { if (IsServer == false) { throw new InvalidOperationException("Only the server can send messages to clients"); } var msg = CreateMessage(LocalPlayer, message, broadcast: false); NetPeer peer = Peer; // only send the message if we have someone to send it to if (peer.ConnectionsCount > 0) { peer.SendMessage(msg, peer.Connections, NetDeliveryMethod.ReliableOrdered, 0); } break; } case NetworkMessageRecipient.Server: { if (IsServer) { _dispatcher.InvokeHandlers(LocalPlayer, message); } else { var msg = CreateMessage(LocalPlayer, message, broadcast: false); _client.ServerConnection.SendMessage(msg, NetDeliveryMethod.ReliableOrdered, 0); } break; } } }
//TODO: do this in other places public void Send(Packet v, NetDeliveryMethod DeliveryType) { lock (Lock) { var Message = myPeer.CreateMessage(); mySendFormatter.Serialize(myStream, v); Message.Write(myStream.ToArray()); myPeer.SendMessage(Message, myServerConnection, DeliveryType); //TODO: tweak this so it works for game and update myStream.SetLength(0); myStream.Position = 0; } }
public void SendMessage(ReliableMessage message, NetConnection connection) { idSendInterval = 0.0f; idSendTimer = connection.AverageRoundtripTime; messageBuffer.Add(message.ID, message); Debug.WriteLine("sending reliable massage (id " + message.ID + ")"); if (messageCount == ushort.MaxValue) { messageCount = 0; } messageCount++; message.SaveInnerMessage(); sender.SendMessage(message.InnerMessage, connection, NetDeliveryMethod.Unreliable, 0); recipient = connection; }
public void SendMessage(INetworkMessage msg, NetConnection recipient, bool guaranteed) { NetDeliveryMethod method = (guaranteed ? NetDeliveryMethod.ReliableOrdered : NetDeliveryMethod.UnreliableSequenced); // opt - tell the peer the message size NetOutgoingMessage outgoing = _peer.CreateMessage(); outgoing.Write((byte)msg.MessageType); msg.Encode(outgoing); _peer.SendMessage(outgoing, recipient, method); }
public void Send(ConnectionId connectionId, NetDeliveryMethod deliveryMethod, NetBuffer buffer) { var connection = _connectionsById[connectionId]; if (connection != null && connection.Status == NetConnectionStatus.Connected) { var message = _netPeer.CreateMessage(); //Debug.Log("sending data " + buffer.Data.ToHexString(0, buffer.LengthBytes) + " to " + connection.RemoteEndPoint); message.Write(buffer); _netPeer.SendMessage(message, connection, deliveryMethod); } }
private void InitializeServer() { _connection_type = INSTANCE_TYPE.SERVER_TYPE; NetPeerConfiguration config = new NetPeerConfiguration("ServerClientClient"); config.AcceptIncomingConnections = true; config.MaximumConnections = 2; config.Port = _server_port; config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); _connection = new NetServer(config); Debug.Assert(_connection != null); _connection.Start(); NetIncomingMessage pInMsg; bool ready = false; Console.ForegroundColor = ConsoleColor.Gray; Console.WriteLine("\nServer Instance\nWaiting for clients...\n"); int count = 0; while (!ready) { if ((pInMsg = _connection.ReadMessage()) != null && pInMsg.MessageType == NetIncomingMessageType.StatusChanged) { if ((NetConnectionStatus)pInMsg.ReadByte() == NetConnectionStatus.Connected) { NetOutgoingMessage m = _connection.CreateMessage(); m.Write(_connection.ConnectionsCount); _connection.SendMessage(m, _connection.Connections[_connection.ConnectionsCount - 1], NetDeliveryMethod.ReliableOrdered); if (count != _connection.ConnectionsCount) { count = _connection.ConnectionsCount; Console.WriteLine("\nClients connected: " + count + "\n"); } if (_connection.ConnectionsCount >= 2) { ready = true; } } } } }