internal static Boolean ShouldRun(this NetworkDestination dest)
{
Boolean isServer = NetworkServer.active;
Boolean isClient = NetworkClient.active;
return(isServer && (dest & NetworkDestination.Server) != 0 ? true : isClient && (dest & NetworkDestination.Clients) != 0);
}
/// <summary>
/// Send the passed command over the network
/// </summary>
/// <param name="command">Registered command</param>
/// <param name="destination">Destination of the command</param>
public static void Send(this INetCommand?command, NetworkDestination destination)
{
if (destination.ShouldRun())
{
command.OnReceived();
}
if (destination.ShouldSend())
{
var header = destination.GetHeader(NetworkingAPI.GetNetworkHash(command.GetType()));
if (NetworkServer.active)
{
for (int i = 0; i < NetworkServer.connections.Count; ++i)
{
NetworkConnection conn = NetworkServer.connections[i];
if (conn == null)
{
continue;
}
if (NetworkServer.localClientActive && NetworkServer.localConnections.Contains(conn))
{
continue;
}
SendCommand(header, conn);
}
}
else if (NetworkClient.active)
{
SendCommand(header, ClientScene.readyConnection);
}
}
}
internal static bool ShouldRun(this NetworkDestination dest)
{
var isServer = NetworkServer.active;
var isClient = NetworkClient.active;
return(isServer && (dest & NetworkDestination.Server) != 0 ||
isClient && (dest & NetworkDestination.Clients) != 0);
}
internal static Boolean ShouldSend(this NetworkDestination dest)
{
Boolean isServer = NetworkServer.active;
_ = NetworkClient.active;
return(!(isServer && dest == NetworkDestination.Server));
}
public static void Send <T>(this T message, NetworkDestination destination, Int32 recievedFrom = -1)
where T : INetMessage
{
if (destination.ShouldRun())
{
message.OnRecieved();
}
if (destination.ShouldSend())
{
Header header = destination.GetHeader(NetworkCore.GetNetworkCoreHash(typeof(T)));
if (NetworkServer.active)
{
for (Int32 i = 0; i < NetworkServer.connections.Count; ++i)
{
if (i == recievedFrom)
{
continue;
}
NetworkConnection conn = NetworkServer.connections[i];
if (conn == null)
{
continue;
}
if (NetworkServer.localClientActive && NetworkServer.localConnections.Contains(conn))
{
continue;
}
using (Writer netWriter = NetworkCore.GetWriter(NetworkCore.messageIndex, conn, NetworkCore.qos))
{
NetworkWriter writer = netWriter;
writer.Write(header);
writer.Write(message);
}
}
}
else if (NetworkClient.active)
{
using (Writer netWriter = NetworkCore.GetWriter(NetworkCore.messageIndex, ClientScene.readyConnection, NetworkCore.qos))
{
NetworkWriter writer = netWriter;
writer.Write(header);
writer.Write(message);
}
}
}
}
public static void Send <TRequest, TReply>(this TRequest request, NetworkDestination destination, Int32 recievedFrom = -1)
where TRequest : INetRequest <TRequest, TReply>
where TReply : INetRequestReply <TRequest, TReply>
{
if (destination.ShouldRun())
{
request.OnRequestRecieved().OnReplyRecieved();
}
if (destination.ShouldSend())
{
Header header = destination.GetHeader(NetworkCore.GetNetworkCoreHash(request.GetType()));
if (NetworkServer.active)
{
for (Int32 i = 0; i < NetworkServer.connections.Count; ++i)
{
if (i == recievedFrom)
{
continue;
}
NetworkConnection conn = NetworkServer.connections[i];
if (conn == null)
{
continue;
}
using (Writer netWriter = NetworkCore.GetWriter(NetworkCore.messageIndex, conn, NetworkCore.qos))
{
NetworkWriter writer = netWriter;
writer.Write(header);
writer.Write(request);
}
}
}
if (NetworkClient.active)
{
using (Writer netWriter = NetworkCore.GetWriter(NetworkCore.messageIndex, ClientScene.readyConnection, NetworkCore.qos))
{
NetworkWriter writer = netWriter;
writer.Write(header);
writer.Write(request);
}
}
}
}
public static void Send <TRequest, TReply>(this TRequest request, NetworkDestination destination)
where TRequest : INetRequest <TRequest, TReply>
where TReply : INetRequestReply <TRequest, TReply>
{
if (destination.ShouldRun())
{
request.OnRequestReceived().OnReplyReceived();
}
if (destination.ShouldSend())
{
var header = destination.GetHeader(NetworkingAPI.GetNetworkHash(request.GetType()));
if (NetworkServer.active)
{
for (var i = 0; i < NetworkServer.connections.Count; ++i)
{
NetworkConnection conn = NetworkServer.connections[i];
if (conn == null)
{
continue;
}
if (NetworkServer.localClientActive && NetworkServer.localConnections.Contains(conn))
{
continue;
}
using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.RequestIndex, conn, QosType.Reliable)) {
NetworkWriter writer = netWriter;
writer.Write(header);
writer.Write(request);
}
}
}
else if (NetworkClient.active)
{
using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.RequestIndex, ClientScene.readyConnection, QosType.Reliable)) {
NetworkWriter writer = netWriter;
writer.Write(header);
writer.Write(request);
}
}
}
}
public static void Send(this INetMessage?message, NetworkDestination destination)
{
if (destination.ShouldRun())
{
message.OnReceived();
}
if (destination.ShouldSend())
{
var header = destination.GetHeader(NetworkingAPI.GetNetworkHash(message.GetType()));
if (NetworkServer.active)
{
for (int i = 0; i < NetworkServer.connections.Count; ++i)
{
NetworkConnection conn = NetworkServer.connections[i];
if (conn == null)
{
continue;
}
if (NetworkServer.localClientActive && NetworkServer.localConnections.Contains(conn))
{
continue;
}
using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.MessageIndex, conn, QosType.Reliable)) {
NetworkWriter writer = netWriter;
writer.Write(header);
writer.Write(message);
}
}
}
else if (NetworkClient.active)
{
using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.MessageIndex, ClientScene.readyConnection, QosType.Reliable)) {
NetworkWriter writer = netWriter;
writer.Write(header);
writer.Write(message);
}
}
}
}
public static void Send(this INetCommand command, NetworkDestination destination)
{
if (destination.ShouldRun())
{
command.OnReceived();
}
if (destination.ShouldSend())
{
var header = destination.GetHeader(NetworkingAPI.GetNetworkHash(command.GetType()));
if (NetworkServer.active)
{
for (int i = 0; i < NetworkServer.connections.Count; ++i)
{
NetworkConnection conn = NetworkServer.connections[i];
if (conn == null)
{
continue;
}
using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.CommandIndex, conn, QosType.Reliable)) {
NetworkWriter writer = netWriter;
writer.Write(header);
}
}
}
if (NetworkClient.active)
{
using (var netWriter = NetworkingAPI.GetWriter(NetworkingAPI.CommandIndex, ClientScene.readyConnection, QosType.Reliable)) {
NetworkWriter writer = netWriter;
writer.Write(header);
}
}
}
}
/// <summary>
/// Send the passed request over the network
/// </summary>
/// <param name="request">Registered request</param>
/// <param name="destination">Destination of the request</param>
public static void Send <TRequest, TReply>(this TRequest request, NetworkDestination destination)
where TRequest : INetRequest <TRequest, TReply>
where TReply : INetRequestReply <TRequest, TReply>
{
if (destination.ShouldRun())
{
request.OnRequestReceived().OnReplyReceived();
}
if (destination.ShouldSend())
{
var header = destination.GetHeader(NetworkingAPI.GetNetworkHash(request.GetType()));
if (NetworkServer.active)
{
for (var i = 0; i < NetworkServer.connections.Count; ++i)
{
NetworkConnection conn = NetworkServer.connections[i];
if (conn == null)
{
continue;
}
if (NetworkServer.localClientActive && NetworkServer.localConnections.Contains(conn))
{
continue;
}
SendRequest <TRequest, TReply>(request, header, conn);
}
}
else if (NetworkClient.active)
{
SendRequest <TRequest, TReply>(request, header, ClientScene.readyConnection);
}
}
}
internal Header(int typeCode, NetworkDestination dest)
{
TypeCode = typeCode;
Destination = dest;
}
public void Deserialize(NetworkReader reader)
{
TypeCode = reader.ReadInt32();
Destination = (NetworkDestination)reader.ReadByte();
}
internal void RemoveDestination(NetworkDestination destination) => Destination &= ~destination;
internal static Header GetHeader(this NetworkDestination dest, int typeCode) => new Header(typeCode, dest);
internal static bool ShouldSend(this NetworkDestination dest)
{
var isServer = NetworkServer.active;
return(!(isServer && dest == NetworkDestination.Server));
}
internal Header(Int32 typeCode, NetworkDestination dest)
{
this.typeCode = typeCode;
this.destination = dest;
}
