internal void SendMessage(RoomMessageDefine id, object msg)
{
try {
if (!m_IsConnected)
{
return;
}
NetOutgoingMessage om = m_NetClient.CreateMessage();
byte[] bt = Serialize.Encode(msg, (int)id);
IncSendMessageCount((int)id, bt.Length);
om.Write(bt);
NetSendResult result = m_NetClient.SendMessage(om, NetDeliveryMethod.ReliableOrdered);
if (result == NetSendResult.FailedNotConnected)
{
m_IsConnected = false;
m_CanSendMessage = false;
LogSystem.Info("SendMessage FailedNotConnected");
}
else if (result == NetSendResult.Dropped)
{
LogSystem.Error("SendMessage {0} Dropped", msg.ToString());
}
m_NetClient.FlushSendQueue();
} catch (Exception ex) {
LogSystem.Error("NetworkSystem.SendMessage throw Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
private NetSendResult Send(Packet packet)
{
// Make sure we have a record if the packet
if (!sendAttempts.ContainsKey(packet))
{
sendAttempts[packet] = 0;
}
NetSendResult result = Networkmanager.Send(this, packet);
if (result == NetSendResult.Sent)
{
sendAttempts[packet]++;
}
// Send it 20 times
if (sendAttempts[packet] <= 20)
{
return(result);
}
int sentCount;
sendAttempts.TryRemove(packet, out sentCount);
return(result);
}
public bool SendToServer <T>(T packet, int capacity, NetDeliveryMethod method, int channel) where T : struct, IClientPacket
{
if (client == null)
{
return(false);
}
NetOutgoingMessage msg = client.CreateMessage(capacity);
msg.Write((byte)packet.Type);
packet.Write(msg);
#if DEBUG
if (msg.LengthBytes > capacity)
{
Log.Write(LogType.Warning, "Packet " + typeof(T).Name + " has underestimated capacity (" + msg.LengthBytes + "/" + capacity + ")");
}
#endif
NetSendResult result = client.SendMessage(msg, method, channel);
#if DEBUG
uploadPacketBytesLast += msg.LengthBytes;
#endif
#if NETWORK_DEBUG__
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write("Debug: ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("Send<" + typeof(T).Name + "> " + msg.LengthBytes + " bytes");
#endif
return(result == NetSendResult.Sent || result == NetSendResult.Queued);
}
public override void SendPassword(string password)
{
if (!isActive)
{
return;
}
if (initializationStep != ConnectionInitialization.Password)
{
return;
}
NetOutgoingMessage outMsg = netClient.CreateMessage();
outMsg.Write((byte)PacketHeader.IsConnectionInitializationStep);
outMsg.Write((byte)ConnectionInitialization.Password);
byte[] saltedPw = ServerSettings.SaltPassword(NetUtility.ComputeSHAHash(Encoding.UTF8.GetBytes(password)), passwordSalt);
outMsg.Write((byte)saltedPw.Length);
outMsg.Write(saltedPw, 0, saltedPw.Length);
NetSendResult result = netClient.SendMessage(outMsg, NetDeliveryMethod.ReliableUnordered);
if (result != NetSendResult.Queued && result != NetSendResult.Sent)
{
DebugConsole.NewMessage("Failed to send " + initializationStep.ToString() + " message to host: " + result);
}
}
protected override void SendMsgInternal(NetworkConnection conn, DeliveryMethod deliveryMethod, IWriteMessage msg)
{
LidgrenConnection lidgrenConn = conn as LidgrenConnection;
NetDeliveryMethod lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
switch (deliveryMethod)
{
case DeliveryMethod.Unreliable:
lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
break;
case DeliveryMethod.Reliable:
lidgrenDeliveryMethod = NetDeliveryMethod.ReliableUnordered;
break;
case DeliveryMethod.ReliableOrdered:
lidgrenDeliveryMethod = NetDeliveryMethod.ReliableOrdered;
break;
}
NetOutgoingMessage lidgrenMsg = netServer.CreateMessage();
lidgrenMsg.Write(msg.Buffer, 0, msg.LengthBytes);
NetSendResult result = netServer.SendMessage(lidgrenMsg, lidgrenConn.NetConnection, lidgrenDeliveryMethod);
if (result != NetSendResult.Sent && result != NetSendResult.Queued)
{
DebugConsole.NewMessage("Failed to send message to " + conn.Name + ": " + result.ToString(), Microsoft.Xna.Framework.Color.Yellow);
}
}
public void Initialize()
{
var serializedUsr = User;
var peerName = "asteroid";
Client = new NetClient(new NetPeerConfiguration(peerName)
{
EnableUPnP = true,
AutoFlushSendQueue = true
});
Client.Start();
Client.Connect(ServerIp, ServerPort);
NetSendResult res = NetSendResult.FailedNotConnected;
Messages.Add("Start status");
//send login
while (res != NetSendResult.Sent)
{
Messages.Add($"Sending.Try Nr:{LoginTries}");
res = Client.SendMessage
(
CreateMessage(NetworkCommandConstants.LoginCommand,
serializedUsr),
NetDeliveryMethod.Unreliable
);
Messages.Add($"Wait {SecondsToNextLoginTry} seconds...");
Task.Delay(TimeSpan.FromSeconds(SecondsToNextLoginTry)).Wait();
LoginTries++;
}
}
internal void SendMessage(object msg)
{
if (!m_IsConnected)
{
return;
}
NetOutgoingMessage om = m_NetClient.CreateMessage();
byte[] bt = Serialize.Encode(msg);
om.Write(bt);
NetSendResult result = m_NetClient.SendMessage(om, NetDeliveryMethod.ReliableOrdered);
if (result == NetSendResult.FailedNotConnected)
{
m_IsConnected = false;
m_WaitDisconnect = false;
m_CanSendMessage = false;
LogSystem.Debug("{0} SendMessage FailedNotConnected {1}", Robot.LobbyNetworkSystem.User, LobbyRobot.Robot.GetDateTime());
}
else if (result == NetSendResult.Dropped)
{
LogSystem.Error("{0} SendMessage {1} Dropped {2}", Robot.LobbyNetworkSystem.User, msg.ToString(), LobbyRobot.Robot.GetDateTime());
}
m_NetClient.FlushSendQueue();
}
public void SendMsg(string msg)
{
NetOutgoingMessage outMsg = this.client.CreateMessage();
outMsg.Write(msg);
NetSendResult sendResult = this.client.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered);
}
public void SendMessage(object msg)
{
try
{
if (!m_IsConnected)
{
return;
}
NetOutgoingMessage om = m_NetClient.CreateMessage();
//byte[] bt = ProtoNetSerialize.Encode(msg);
byte[] bt = new byte[10];
om.Write(bt);
NetSendResult result = m_NetClient.SendMessage(om, NetDeliveryMethod.ReliableOrdered);
if (result == NetSendResult.FailedNotConnected)
{
m_IsConnected = false;
m_CanSendMessage = false;
}
else if (result == NetSendResult.Dropped)
{
}
m_NetClient.FlushSendQueue();
}
#pragma warning disable CS0168 // The variable 'ex' is declared but never used
catch (Exception ex)
#pragma warning restore CS0168 // The variable 'ex' is declared but never used
{
}
}
public bool ResSend(NetConnection connection, Int16 ret, String ret_message, String to_id)
{
if (peer == null || connection == null)
{
return(false);
}
if (peer.ConnectionsCount < 1 ||
connection.Status != NetConnectionStatus.Connected)
{
return(false);
}
NetOutgoingMessage om = peer.CreateMessage();
om.Write((UInt32)203);
om.Write(ret);
om.Write(ret_message);
om.Write(to_id);
NetSendResult result = peer.SendMessage(om, connection,
NetDeliveryMethod.ReliableOrdered);
if (result == NetSendResult.FailedNotConnected ||
result == NetSendResult.Dropped)
{
return(false);
}
peer.FlushSendQueue();
return(true);
}
private void HandleStatusChanged(NetIncomingMessage inc)
{
if (netServer == null)
{
return;
}
DebugConsole.NewMessage(inc.SenderConnection.Status.ToString());
switch (inc.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
NetOutgoingMessage outMsg = netServer.CreateMessage();
outMsg.Write(OwnerSteamID);
outMsg.Write((byte)(PacketHeader.IsConnectionInitializationStep | PacketHeader.IsServerMessage));
NetSendResult result = netServer.SendMessage(outMsg, netConnection, NetDeliveryMethod.ReliableUnordered);
if (result != NetSendResult.Sent && result != NetSendResult.Queued)
{
DebugConsole.NewMessage("Failed to send connection confirmation message to owner: " + result.ToString(), Microsoft.Xna.Framework.Color.Yellow);
}
break;
case NetConnectionStatus.Disconnected:
DebugConsole.NewMessage("Owner disconnected: closing the server...");
GameServer.Log("Owner disconnected: closing the server...", ServerLog.MessageType.ServerMessage);
Close(DisconnectReason.ServerShutdown.ToString() + "/ Owner disconnected");
break;
}
}
/// <summary>
/// Send a message to a list of connections
/// </summary>
/// <param name="msg">The message to send</param>
/// <param name="recipients">The list of recipients to send to</param>
/// <param name="method">How to deliver the message</param>
/// <param name="sequenceChannel">Sequence channel within the delivery method</param>
/// <param name="except">Connection where message should not be sent, optional</param>
public void SendMessage(NetOutgoingMessage msg, List <NetConnection> recipients, NetDeliveryMethod method, int sequenceChannel, NetConnection except = null)
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
if (recipients == null)
{
throw new ArgumentNullException("recipients");
}
if (recipients.Count < 1)
{
throw new NetException("recipients must contain at least one item");
}
if (method == NetDeliveryMethod.Unreliable || method == NetDeliveryMethod.ReliableUnordered)
{
NetException.Assert(sequenceChannel == 0, "Delivery method " + method + " cannot use sequence channels other than 0!");
}
if (msg.m_isSent)
{
throw new NetException("This message has already been sent! Use NetPeer.SendMessage() to send to multiple recipients efficiently");
}
int mtu = GetMTU(recipients);
msg.m_isSent = true;
int len = msg.GetEncodedSize();
if (len <= mtu)
{
Interlocked.Add(ref msg.m_recyclingCount, except != null ? recipients.Count - 1 : recipients.Count);
foreach (NetConnection conn in recipients)
{
if (except != null && conn.RemoteUniqueIdentifier == except.RemoteUniqueIdentifier)
{
continue;
}
if (conn == null)
{
Interlocked.Decrement(ref msg.m_recyclingCount);
continue;
}
NetSendResult res = conn.EnqueueMessage(msg, method, sequenceChannel);
if (res != NetSendResult.Queued && res != NetSendResult.Sent)
{
Interlocked.Decrement(ref msg.m_recyclingCount);
}
}
}
else
{
// message must be fragmented!
SendFragmentedMessage(msg, recipients, method, sequenceChannel, except);
}
return;
}
private void SendTo(NetConnection conn, NetDeliveryMethod channel, byte[] data, int len, int channelSequence)
{
NetOutgoingMessage msg = this._lidgrenPeer.CreateMessage(data.Length);
Buffer.BlockCopy(data, 0, msg.Data, 0, len);
msg.LengthBytes = len;
NetSendResult result = this._lidgrenPeer.SendMessage(msg, conn, channel, channelSequence);
}
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;
}
}
}
/// <summary>
/// Send a message to a list of connections.
/// </summary>
/// <param name="message">The message to send</param>
/// <param name="recipients">The list of recipients to send to</param>
/// <param name="method">How to deliver the message</param>
/// <param name="sequenceChannel">Sequence channel within the delivery method</param>
public NetSendResult SendMessage(
NetOutgoingMessage message,
IEnumerable <NetConnection?> recipients,
NetDeliveryMethod method,
int sequenceChannel)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (recipients == null)
{
throw new ArgumentNullException(nameof(recipients));
}
NetConstants.AssertValidDeliveryChannel(
method, sequenceChannel, nameof(method), nameof(sequenceChannel));
message.AssertNotSent(nameof(message));
message._isSent = true;
int mtu = GetMTU(recipients, out int recipientCount);
if (recipientCount == 0)
{
Recycle(message);
return(NetSendResult.NoRecipients);
}
int length = message.GetEncodedSize();
if (length <= mtu)
{
Interlocked.Add(ref message._recyclingCount, recipientCount);
var retval = NetSendResult.Sent;
foreach (NetConnection?conn in recipients.AsListEnumerator())
{
if (conn == null)
{
continue;
}
NetSendResult result = conn.EnqueueMessage(message, method, sequenceChannel).Result;
if (result > retval)
{
retval = result; // return "worst" result
}
}
return(retval);
}
else
{
// message must be fragmented!
return(SendFragmentedMessage(message, recipients, method, sequenceChannel));
}
}
public void Send(NetClient nc)
{
var message = nc.CreateMessage();
message.Write("This is a test");
NetSendResult sr = nc.SendMessage(message, NetDeliveryMethod.ReliableOrdered);
Console.WriteLine(sr.ToString());
Console.ReadKey();
}
public void SendMsg(string msg, NetConnection clientConnection)
{
NetOutgoingMessage outMsg = this.server.CreateMessage();
outMsg.Write(msg);
if (clientConnection != null)
{
NetSendResult sendResult = this.server.SendMessage(outMsg, clientConnection, NetDeliveryMethod.ReliableOrdered);
}
}
public override void Send(IWriteMessage msg, NetworkConnection conn, DeliveryMethod deliveryMethod)
{
if (netServer == null)
{
return;
}
if (!(conn is SteamP2PConnection steamp2pConn))
{
return;
}
if (!connectedClients.Contains(steamp2pConn) && conn != OwnerConnection)
{
DebugConsole.ThrowError("Tried to send message to unauthenticated connection: " + steamp2pConn.SteamID.ToString());
return;
}
NetDeliveryMethod lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
switch (deliveryMethod)
{
case DeliveryMethod.Unreliable:
lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
break;
case DeliveryMethod.Reliable:
lidgrenDeliveryMethod = NetDeliveryMethod.ReliableUnordered;
break;
case DeliveryMethod.ReliableOrdered:
lidgrenDeliveryMethod = NetDeliveryMethod.ReliableOrdered;
break;
}
#if DEBUG
netPeerConfiguration.SimulatedDuplicatesChance = GameMain.Server.SimulatedDuplicatesChance;
netPeerConfiguration.SimulatedMinimumLatency = GameMain.Server.SimulatedMinimumLatency;
netPeerConfiguration.SimulatedRandomLatency = GameMain.Server.SimulatedRandomLatency;
netPeerConfiguration.SimulatedLoss = GameMain.Server.SimulatedLoss;
#endif
NetOutgoingMessage lidgrenMsg = netServer.CreateMessage();
byte[] msgData = new byte[msg.LengthBytes];
msg.PrepareForSending(ref msgData, out bool isCompressed, out int length);
lidgrenMsg.Write(conn.SteamID);
lidgrenMsg.Write((byte)((isCompressed ? PacketHeader.IsCompressed : PacketHeader.None) | PacketHeader.IsServerMessage));
lidgrenMsg.Write((UInt16)length);
lidgrenMsg.Write(msgData, 0, length);
NetSendResult result = netServer.SendMessage(lidgrenMsg, netConnection, lidgrenDeliveryMethod);
if (result != NetSendResult.Sent && result != NetSendResult.Queued)
{
DebugConsole.NewMessage("Failed to send message to " + conn.Name + ": " + result.ToString(), Microsoft.Xna.Framework.Color.Yellow);
}
}
public void TryLogin(string peerName, string serverIp, int port, string username, string password, int trySecondsInterval = 1)
{
if (Feeding)
{
return;
}
Client = new NetClient(new NetPeerConfiguration(peerName)
{
EnableUPnP = true,
AutoFlushSendQueue = true
});
Client.Start();
Client.Connect(serverIp, port);
NetSendResult res = NetSendResult.FailedNotConnected;
var userData = new UserData()
{
Username = username, Password = password
};
//var serializedUsr = JsonConvert.SerializeObject(userData);
//send login
int loginTries = 1;
int secondsLoginTry = trySecondsInterval;
while (res != NetSendResult.Sent)
{
Console.WriteLine($"Sending.Try Nr:{loginTries}");
res = Client.SendMessage
(
CreateMessage(NetworkCommandConstants.LoginCommand,
userData),
NetDeliveryMethod.Unreliable
);
Console.WriteLine($"Wait {secondsLoginTry} seconds...");
Task.Delay(TimeSpan.FromSeconds(secondsLoginTry)).Wait();
loginTries++;
}
Thread feedThread = new Thread(() => {
while (true)
{
Feed();
}
})
{
IsBackground = true
};
feedThread.Start();
}
protected override void SendMsgInternal(DeliveryMethod deliveryMethod, IWriteMessage msg)
{
NetOutgoingMessage lidgrenMsg = netClient.CreateMessage();
lidgrenMsg.Write(msg.Buffer, 0, msg.LengthBytes);
NetSendResult result = netClient.SendMessage(lidgrenMsg, NetDeliveryMethod.ReliableUnordered);
if (result != NetSendResult.Queued && result != NetSendResult.Sent)
{
DebugConsole.NewMessage("Failed to send message to host: " + result + "\n" + Environment.StackTrace);
}
}
/// <summary>
/// Send a message to a list of connections
/// </summary>
/// <param name="msg">The message to send</param>
/// <param name="recipients">The list of recipients to send to</param>
/// <param name="method">How to deliver the message</param>
/// <param name="sequenceChannel">Sequence channel within the delivery method</param>
public void SendMessage(NetOutgoingMessage msg, IList <NetConnection> recipients, NetDeliveryMethod method, int sequenceChannel)
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
if (recipients == null)
{
throw new ArgumentNullException("recipients");
}
if (method == NetDeliveryMethod.Unreliable || method == NetDeliveryMethod.ReliableUnordered)
{
NetException.Assert(sequenceChannel == 0, "Delivery method " + method + " cannot use sequence channels other than 0!");
}
if (msg.m_isSent)
{
throw new NetException("This message has already been sent! Use NetPeer.SendMessage() to send to multiple recipients efficiently");
}
int mtu = GetMTU(recipients);
msg.m_isSent = true;
int len = msg.LengthBytes;
if (len <= m_configuration.MaximumTransmissionUnit)
{
Interlocked.Add(ref msg.m_recyclingCount, recipients.Count);
foreach (NetConnection conn in recipients)
{
if (conn == null)
{
Interlocked.Decrement(ref msg.m_recyclingCount);
continue;
}
NetSendResult res = conn.EnqueueMessage(msg, method, sequenceChannel);
if (res == NetSendResult.Dropped)
{
LogDebug(msg + " dropped immediately due to full queues");
Interlocked.Decrement(ref msg.m_recyclingCount);
}
}
}
else
{
// message must be fragmented!
SendFragmentedMessage(msg, recipients, method, sequenceChannel);
}
return;
}
public void FlushQueue()
{
// Try to send all packets
foreach (Packet packet in sendAttempts.Keys)
{
NetSendResult result = Send(packet);
// Exit if we can't send a packet
if (result != NetSendResult.Sent)
{
break;
}
}
}
public override void Send(IWriteMessage msg, NetworkConnection conn, DeliveryMethod deliveryMethod)
{
if (netServer == null)
{
return;
}
if (!(conn is LidgrenConnection lidgrenConn))
{
return;
}
if (!connectedClients.Contains(lidgrenConn))
{
DebugConsole.ThrowError("Tried to send message to unauthenticated connection: " + lidgrenConn.IPString);
return;
}
NetDeliveryMethod lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
switch (deliveryMethod)
{
case DeliveryMethod.Unreliable:
lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
break;
case DeliveryMethod.Reliable:
lidgrenDeliveryMethod = NetDeliveryMethod.ReliableUnordered;
break;
case DeliveryMethod.ReliableOrdered:
lidgrenDeliveryMethod = NetDeliveryMethod.ReliableOrdered;
break;
}
NetOutgoingMessage lidgrenMsg = netServer.CreateMessage();
byte[] msgData = new byte[msg.LengthBytes];
msg.PrepareForSending(ref msgData, out bool isCompressed, out int length);
lidgrenMsg.Write((byte)(isCompressed ? PacketHeader.IsCompressed : PacketHeader.None));
lidgrenMsg.Write((UInt16)length);
lidgrenMsg.Write(msgData, 0, length);
NetSendResult result = netServer.SendMessage(lidgrenMsg, lidgrenConn.NetConnection, lidgrenDeliveryMethod);
if (result != NetSendResult.Sent && result != NetSendResult.Queued)
{
DebugConsole.NewMessage("Failed to send message to " + conn.Name + ": " + result.ToString(), Microsoft.Xna.Framework.Color.Yellow);
}
}
public static bool Send <T>(T packet, int capacity, NetConnection recipient, NetDeliveryMethod method, int channel) where T : struct, IServerPacket
{
NetOutgoingMessage msg = server.CreateMessage(capacity);
msg.Write((byte)packet.Type);
packet.Write(msg);
NetSendResult result = server.Send(msg, recipient, method, channel);
#if DEBUG__
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write("Debug: ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("Send<" + typeof(T).Name + "> " + msg.LengthBytes + " bytes");
#endif
return(result == NetSendResult.Sent || result == NetSendResult.Queued);
}
internal void SendPeerMessage(RoomPeer peer, RoomMessageDefine id, object msg)
{
try {
NetOutgoingMessage om = m_NetServer.CreateMessage();
om.Write(Serialize.Encode(msg, (int)id));
if (null != peer.GetConnection())
{
NetSendResult res = m_NetServer.SendMessage(om, peer.GetConnection(), NetDeliveryMethod.ReliableOrdered, 0);
if (res == NetSendResult.Dropped)
{
LogSys.Log(LOG_TYPE.ERROR, "SendPeerMessage {0} failed:dropped, User:{1}({2})", msg.ToString(), peer.Guid, peer.GetKey());
}
}
} catch (Exception ex) {
LogSys.Log(LOG_TYPE.ERROR, "Exception {0}\n{1}", ex.Message, ex.StackTrace);
}
}
public override void Send(IWriteMessage msg, DeliveryMethod deliveryMethod)
{
if (!isActive)
{
return;
}
NetDeliveryMethod lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
switch (deliveryMethod)
{
case DeliveryMethod.Unreliable:
lidgrenDeliveryMethod = NetDeliveryMethod.Unreliable;
break;
case DeliveryMethod.Reliable:
lidgrenDeliveryMethod = NetDeliveryMethod.ReliableUnordered;
break;
case DeliveryMethod.ReliableOrdered:
lidgrenDeliveryMethod = NetDeliveryMethod.ReliableOrdered;
break;
}
NetOutgoingMessage lidgrenMsg = netClient.CreateMessage();
byte[] msgData = new byte[msg.LengthBytes];
msg.PrepareForSending(ref msgData, out bool isCompressed, out int length);
lidgrenMsg.Write(selfSteamID);
lidgrenMsg.Write((byte)(isCompressed ? PacketHeader.IsCompressed : PacketHeader.None));
lidgrenMsg.Write((UInt16)length);
lidgrenMsg.Write(msgData, 0, length);
#if DEBUG
netPeerConfiguration.SimulatedDuplicatesChance = GameMain.Client.SimulatedDuplicatesChance;
netPeerConfiguration.SimulatedMinimumLatency = GameMain.Client.SimulatedMinimumLatency;
netPeerConfiguration.SimulatedRandomLatency = GameMain.Client.SimulatedRandomLatency;
netPeerConfiguration.SimulatedLoss = GameMain.Client.SimulatedLoss;
#endif
NetSendResult result = netClient.SendMessage(lidgrenMsg, lidgrenDeliveryMethod);
if (result != NetSendResult.Queued && result != NetSendResult.Sent)
{
DebugConsole.NewMessage("Failed to send own message to host: " + result);
}
}
public void Send(Message msg)
{
NetOutgoingMessage packet = _connection.Peer.CreateMessage();
lock (_globalLock)
{
_stream.Position = 0;
msg.Serialize(_writer);
int numBytes = (int)_stream.Position;
packet.Write(numBytes);
packet.Write(_buffer, 0, numBytes);
NetSendResult result = _connection.SendMessage(packet, Convert(msg.Reliability), 0);
if (result == NetSendResult.FailedNotConnected)
{
throw new Exception("NetSendResult.FailedNotConnected");
}
}
}
/// <summary>
/// This translates <see cref="NetSendResult"/> to GladNet <see cref="SendResult"/>
/// Information related to this translation can be found here https://code.google.com/p/lidgren-network-gen3/wiki/Basics
/// </summary>
/// <param name="result">The value to be used for translation.</param>
/// <exception cref="ArgumentException">Throws an exception if the <see cref="NetSendResult"/> is undefined.</exception>
/// <returns>The equivalent <see cref="SendResult"/> for the given <see cref="NetSendResult"/> value.</returns>
public static SendResult ToGladNet(this NetSendResult result)
{
switch (result)
{
case NetSendResult.FailedNotConnected:
return(SendResult.FailedNotConnected);
case NetSendResult.Sent:
return(SendResult.Sent);
case NetSendResult.Queued:
return(SendResult.Queued);
case NetSendResult.Dropped:
return(SendResult.Invalid);
default:
throw new InvalidOperationException($"Failed to map {nameof(NetSendResult)} value: {result} to GladnEt {nameof(SendResult)}.");
}
}
public static void SendStringToUniqueID(Scene scene, string message, long UniqueID, MessageType type)
{
MessageTemplate temp = new MessageTemplate(message, type);
NetOutgoingMessage mvmntMessage = ServerNetworkSceneComponent.GetNetServer().CreateMessage(Newtonsoft.Json.JsonConvert.SerializeObject(temp));
var connections = ServerNetworkSceneComponent.GetNetServer().Connections;
NetConnection reciever = connections.Find(c => c.RemoteUniqueIdentifier.Equals(UniqueID));
if (reciever != null)
{
NetSendResult result = reciever.SendMessage(mvmntMessage, NetDeliveryMethod.ReliableUnordered, 1);
int size;
int free;
reciever.GetSendQueueInfo(NetDeliveryMethod.ReliableUnordered, 1, out size, out free);
if (free < -size)
{
DisconnectConnection(reciever, scene);
}
}
}
private void OnAuthChange(ulong steamID, ulong ownerID, ClientAuthStatus status)
{
RemotePeer remotePeer = remotePeers.Find(p => p.SteamID == steamID);
DebugConsole.Log(steamID + " validation: " + status + ", " + (remotePeer != null));
if (remotePeer == null)
{
return;
}
if (remotePeer.Authenticated)
{
if (status != ClientAuthStatus.OK)
{
DisconnectPeer(remotePeer, DisconnectReason.SteamAuthenticationFailed.ToString() + "/ Steam authentication status changed: " + status.ToString());
}
return;
}
if (status == ClientAuthStatus.OK)
{
remotePeer.Authenticated = true;
remotePeer.Authenticating = false;
foreach (var msg in remotePeer.UnauthedMessages)
{
NetSendResult result = netClient.SendMessage(msg.Second, msg.First);
if (result != NetSendResult.Queued && result != NetSendResult.Sent)
{
DebugConsole.NewMessage("Failed to send unauthed message to host: " + result);
}
}
remotePeer.UnauthedMessages.Clear();
}
else
{
DisconnectPeer(remotePeer, DisconnectReason.SteamAuthenticationFailed.ToString() + "/ Steam authentication failed: " + status.ToString());
return;
}
}
