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(); } } }