/// <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;
}
}
}
}
}
