/// <summary>
/// Creates a network stream for the method with the specified string name and returns the method info
/// </summary>
/// <param name="methodName">The name of the method to call from this class</param>
/// <param name="receivers">The players on the network that will be receiving RPC</param>
/// <param name="arguments">The list of arguments that will be sent for the RPC</param>
/// <returns></returns>
private int GetStreamRPC(string methodName, NetworkReceivers receivers, params object[] arguments)
{
foreach (KeyValuePair <int, KeyValuePair <MethodInfo, List <IBRPCIntercept> > > rpc in RPCs)
{
if (rpc.Value.Key.Name == methodName)
{
if (!NetworkingManager.IsOnline)
{
return(rpc.Key);
}
getStreamBuffer.Clear();
ObjectMapper.MapBytes(getStreamBuffer, rpc.Key);
#if UNITY_EDITOR
int argCount = 0;
foreach (var param in rpc.Value.Key.GetParameters())
{
if (param.ParameterType != typeof(MessageInfo))
{
argCount++;
}
}
if (arguments.Length != argCount)
{
throw new NetworkException("The number of arguments [" + arguments.Length + "] provided for the " + methodName + " RPC call do not match the method signature argument count [" + rpc.Value.Key.GetParameters().Length + "]");
}
#endif
if (arguments != null && arguments.Length > 0)
{
ObjectMapper.MapBytes(getStreamBuffer, arguments);
}
bool buffered = receivers == NetworkReceivers.AllBuffered || receivers == NetworkReceivers.OthersBuffered;
rpcNetworkingStream.SetProtocolType(OwningNetWorker is CrossPlatformUDP ? Networking.ProtocolType.UDP : Networking.ProtocolType.TCP);
rpcNetworkingStream.Prepare(OwningNetWorker, NetworkingStream.IdentifierType.RPC, this, getStreamBuffer, receivers, buffered);
return(rpc.Key);
}
}
throw new NetworkException(14, "No method marked with [BRPC] was found by the name " + methodName);
}
private void ConnectionLoop(object server)
{
while (true)
{
try
{
TcpClient client = ((TcpListener)server).AcceptTcpClient();
if (Connections >= MaxConnections)
{
lock (writeMutex)
{
writeBuffer.Clear();
ObjectMapper.MapBytes(writeBuffer, "Max Players Reached On Server");
staticWriteStream.SetProtocolType(Networking.ProtocolType.TCP);
WriteAndClose(client, staticWriteStream.Prepare(
this, NetworkingStream.IdentifierType.Disconnect, 0, writeBuffer, noBehavior: true));
}
return;
}
// TODO: Set the name
string name = string.Empty;
NetworkingPlayer player = new NetworkingPlayer(ServerPlayerCounter++, client.Client.RemoteEndPoint.ToString(), client, name);
lock (clientMutex)
{
Players.Add(player);
}
}
catch (Exception exception)
{
#if !BARE_METAL
UnityEngine.Debug.LogException(exception);
#endif
Disconnect();
}
}
}
private void Listen(object sender, DoWorkEventArgs e)
{
while (true)
{
if (listenWorker.CancellationPending)
{
e.Cancel = true;
break;
}
TcpListener tcpListener = (TcpListener)e.Argument;
try
{
for (int i = 0; i < Players.Count; i++)
{
if (!((TcpClient)Players[i].SocketEndpoint).Connected)
{
Players.RemoveAt(i--);
}
}
// Create a TCP socket.
// If you ran this server on the desktop, you could use
// Socket socket = tcpListener.AcceptSocket()
// for greater flexibility.
TcpClient tcpClient = tcpListener.AcceptTcpClient();
if (Connections >= MaxConnections)
{
lock (writeMutex)
{
writeBuffer.Clear();
ObjectMapper.MapBytes(writeBuffer, "Max Players Reached On Server");
staticWriteStream.SetProtocolType(Networking.ProtocolType.TCP);
WriteAndClose(tcpClient, staticWriteStream.Prepare(
this, NetworkingStream.IdentifierType.Disconnect, 0, writeBuffer, noBehavior: true));
}
return;
}
// TODO: Set the name
string name = string.Empty;
NetworkingPlayer player = new NetworkingPlayer(ServerPlayerCounter++, tcpClient.Client.RemoteEndPoint.ToString(), tcpClient, name);
lock (Players)
{
Players.Add(player);
}
listenWorker.ReportProgress(0, player);
}
catch (NetworkException exception)
{
#if !BARE_METAL
UnityEngine.Debug.LogException(exception);
#endif
Disconnect();
}
}
}