public BMSByte Receive(ref IPEndPoint remoteEP, ref string endpoint)
{
CheckDisposed();
recBuffer.Clear();
if (endPoint == null)
{
endPoint = new IPEndPoint(IPAddress.Any, 0);
}
int dataRead = socket.ReceiveFrom(recBuffer.byteArr, ref endPoint);
if (!connections.ContainsKey(endPoint))
{
connections.Add(endPoint, (((IPEndPoint)endPoint).Address.ToString() + HOST_PORT_CHARACTER_SEPARATOR + ((IPEndPoint)endPoint).Port.ToString()));
}
endpoint = connections[endPoint];
//if (dataRead < recBuffer.Size)
// recBuffer = CutArray(recBuffer, dataRead);
recBuffer.SetSize(dataRead);
remoteEP = (IPEndPoint)endPoint;
return(recBuffer);
}
private async void ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
BMSByte tmp = new BMSByte();
if (Connections >= MaxConnections)
{
ObjectMapper.MapBytes(tmp, "Max Players Reached On Server");
WriteAndClose(args.Socket, new NetworkingStream(Networking.ProtocolType.TCP).Prepare(this,
NetworkingStream.IdentifierType.Disconnect, null, tmp));
return;
}
// TODO: Setup name
string name = string.Empty;
NetworkingPlayer player = new NetworkingPlayer(ServerPlayerCounter, args.Socket.Information.RemoteAddress.CanonicalName, args.Socket, name);
Players.Add(player);
OnPlayerConnected(player);
tmp.Clear();
ObjectMapper.MapBytes(tmp, player.NetworkId);
Write(player, new NetworkingStream(Networking.ProtocolType.TCP).Prepare(this,
NetworkingStream.IdentifierType.Player, null, tmp));
}
protected BMSByte ReadBuffer(NetworkStream stream)
{
int count = 0;
while (stream.DataAvailable)
{
previousSize = backBuffer.Size;
backBuffer.SetSize(backBuffer.Size + 1024);
count += stream.Read(backBuffer.byteArr, previousSize, 1024);
backBuffer.SetSize(previousSize + count);
}
int size = BitConverter.ToInt32(backBuffer.byteArr, backBuffer.StartIndex());
readBuffer.Clear();
if (count == 0)
{
return(readBuffer);
}
readBuffer.BlockCopy(backBuffer.byteArr, backBuffer.StartIndex(4), size);
if (readBuffer.Size + 4 < backBuffer.Size)
{
backBuffer.RemoveStart(size + 4);
}
else
{
backBuffer.Clear();
}
return(readBuffer);
}
private void TellServerLevelLoaded(int level)
{
if (OwningNetWorker == null || OwningNetWorker.IsServer)
{
return;
}
loadLevelPing.Clear();
ObjectMapper.MapBytes(loadLevelPing, level);
Networking.WriteCustom(WriteCustomMapping.NETWORKING_MANAGER_PLAYER_LOADED_LEVEL, OwningNetWorker, loadLevelPing, true, NetworkReceivers.Server);
}
/// <summary>
/// Sends the forge transport object
/// </summary>
/// <param name="receivers">who will receive the transport object</param>
/// <param name="reliable">send the packet reliably/unreliably</param>
/// <remarks>
/// Serializes the forge transport object, then sends it to all clients specified by the receivers.
/// Subscribe a method to ForgeTransportObject.transportObject.transportFinished to decide what method should
/// be executed when the object is received.
/// </remarks>
public void Send(NetworkReceivers receivers = NetworkReceivers.Others, bool reliable = true)
{
lock (serializerMutex)
{
serializer.Clear();
ObjectMapper.MapBytes(serializer, id);
foreach (FieldInfo field in fields)
{
ObjectMapper.MapBytes(serializer, field.GetValue(this));
}
Networking.WriteCustom(WriteCustomMapping.TRANSPORT_OBJECT, Networking.PrimarySocket, serializer, reliable, receivers);
}
}
public BMSByte Serialized()
{
serializeBuffer.Clear();
foreach (var property in Properties)
{
object val = property.GetValue(this, null);
if (property.PropertyType == typeof(string))
{
serializeBuffer.Append(BitConverter.GetBytes(((string)val).Length));
}
ObjectMapper.MapBytes(serializeBuffer, val);
}
return(serializeBuffer);
}
/// <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 PollPlayers()
{
playerPollData.Clear();
if (!OwningNetWorker.IsServer)
{
return;
}
ObjectMapper.MapBytes(playerPollData, OwningNetWorker.Players.Count + 1);
// Send the server first
ObjectMapper.MapBytes(playerPollData, OwningNetWorker.Me.NetworkId, OwningNetWorker.Me.Name);
foreach (NetworkingPlayer player in OwningNetWorker.Players)
{
ObjectMapper.MapBytes(playerPollData, player.NetworkId, player.Name);
}
Networking.WriteCustom(WriteCustomMapping.NETWORKING_MANAGER_POLL_PLAYERS, OwningNetWorker, playerPollData, OwningNetWorker.CurrentStreamOwner, true);
}
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();
}
}
}
