public void ReceivePositionInformation(int hostId, int connectionId, PositionMessage message) { if (!GameStarted()) { return; } int lane = System.Convert.ToInt32(message.lane); Player player = players.FirstOrDefault(p => p.lane != null && p.lane.id == lane); if (player != null) { player.transform.position = message.position; player.SetHealth(System.Convert.ToInt32(message.hp)); } else { SpawnPlayer(lane); } P2PConnection connection = P2PConnectionManager.GetConnection(hostId, connectionId); if (connection != null) { connection.lane = lane; } }
public virtual void Initialize(P2PPeer peer, int networkConnectionId, HostTopology hostTopology) { this.m_Writer = new P2PNetworkWriter(); this.m_Reader = new P2PNetworkReader(); this.m_ConnectionId = networkConnectionId; this.m_Peer = peer; int channelCount = hostTopology.DefaultConfig.ChannelCount; int packetSize = (int)hostTopology.DefaultConfig.PacketSize; if (hostTopology.DefaultConfig.UsePlatformSpecificProtocols && Application.platform != RuntimePlatform.PS4) { throw new ArgumentOutOfRangeException("Platform specific protocols are not supported on this platform"); } this.m_Channels = new P2PChannelBuffer[channelCount]; for (int i = 0; i < channelCount; i++) { ChannelQOS channelQOS = hostTopology.DefaultConfig.Channels[i]; int bufferSize = packetSize; if (channelQOS.QOS == QosType.ReliableFragmented || channelQOS.QOS == QosType.UnreliableFragmented) { bufferSize = (int)(hostTopology.DefaultConfig.FragmentSize * 128); } this.m_Channels[i] = new P2PChannelBuffer(this, bufferSize, (byte)i, P2PConnection.IsReliableQoS(channelQOS.QOS)); } }
public static void OnJoinAnnounce(int hostId, int connectionId, JoinAnnounceMessage message) { Debug.Log("OnJoinAnnounce received"); P2PConnection connection = P2PConnectionManager.GetConnection(hostId, connectionId); connection.SuccessfullyConnect(); }
private async void button5_Click(object sender, RoutedEventArgs e) { List <PeerAddress> ips = await P2PConnectionManager.GetDNSSeedIPAddressesAsync(P2PNetworkParameters.DNSSeedHosts, _networkParameters); Thread threadLable = new Thread(new ThreadStart(() => { while (true) { Dispatcher.Invoke(() => { label.Content = "Inbound: " + P2PConnectionManager.GetInboundP2PConnections().Count + " Outbound: " + P2PConnectionManager.GetOutboundP2PConnections().Count; }); Thread.CurrentThread.Join(1000); } })); threadLable.IsBackground = true; threadLable.Start(); foreach (PeerAddress ip in ips) { Thread connectThread = new Thread(new ThreadStart(() => { P2PConnection p2p = new P2PConnection(ip.IPAddress, _networkParameters, new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)); p2p.ConnectToPeer(1); })); connectThread.IsBackground = true; connectThread.Start(); } }
public static P2PConnection GetConnection(int hostId, int connectionId) { P2PConnection connection = connections.FirstOrDefault(c => c.hostId == hostId && c.connectionId == connectionId); return(connection); }
public static P2PConnection GetConnection(string ip, int port) { P2PConnection connection = connections.FirstOrDefault(c => c.ip == ip && c.port == port); return(connection); }
private void SendBytesTo(int connection_id, byte[] bytes, int num_bytes, int channel_id) { P2PConnection p2PConnection = this.FindConnection(connection_id); if (p2PConnection == null) { return; } p2PConnection.SendBytes(bytes, num_bytes, channel_id); }
private void SendWriterTo(int connection_id, P2PNetworkWriter writer, int channel_id) { P2PConnection p2PConnection = this.FindConnection(connection_id); if (p2PConnection == null) { return; } p2PConnection.SendWriter(writer, channel_id); }
private void Disconnect(int connection_id) { P2PConnection p2PConnection = this.FindConnection(connection_id); if (p2PConnection == null) { return; } p2PConnection.Disconnect(); this.m_Connections[connection_id] = null; }
private void UpdateConnections() { for (int i = 0; i < this.m_Connections.Count; i++) { P2PConnection p2PConnection = this.m_Connections[i]; if (p2PConnection != null) { p2PConnection.FlushChannels(); } } }
private void OnConnectInternal(P2PConnection conn) { if (P2PLogFilter.logDebug) { Debug.Log("P2PSession:OnConnectInternal"); } if (conn.m_Peer.IsValid()) { this.SendPeerInfoOnConnectionEstablished(conn); } Replicator.Singleton.OnPeerConnected(conn.m_Peer); }
public static void ConnectEvent(int hostId, int connectionId) { int port; string ip; UnityEngine.Networking.Types.NetworkID netId; UnityEngine.Networking.Types.NodeID nodeId; NetworkTransport.GetConnectionInfo(hostId, connectionId, out ip, out port, out netId, out nodeId, out P2PController.error); P2PConnection connection = P2PConnectionManager.GetConnection(ip, port); if (connection == null) { //new connection from targeted ip or new player connection = new P2PConnection(hostId, connectionId); connection.ip = ip; connection.port = port; connections.Add(connection); Debug.Log("New connection with " + connection); if (!JoinRequestSend) //I'm wanting to join { Debug.Log("Sending Join Request"); JoinRequestSend = true; JoinRequestMessage message = new JoinRequestMessage(); P2PSender.Send(hostId, connectionId, P2PChannels.ReliableChannelId, message, MessageTypes.JoinRequest); } else if (JoinAnswerReceived && !p2PController.GameStarted()) { connection.SuccessfullyConnect(); } } else if (!connection.ConnectionSuccessful()) { //successfully connect to an existing player. Connection requested previously connection.hostId = hostId; connection.connectionId = connectionId; connection.SuccessfullyConnect(); JoinAnnounceMessage announceMessage = new JoinAnnounceMessage(); P2PSender.Send(hostId, connectionId, P2PChannels.ReliableChannelId, announceMessage, MessageTypes.JoinAnnounce); } if (!p2PController.GameStarted()) { if (JoinAnswerReceived) { CheckConnectionsStatus(); } } }
private bool SetConnectionAtIndex(P2PConnection conn) { while (this.m_Connections.Count <= conn.m_ConnectionId) { this.m_Connections.Add(null); } if (this.m_Connections[conn.m_ConnectionId] != null) { return(false); } this.m_Connections[conn.m_ConnectionId] = conn; conn.SetHandlers(this.m_MessageHandlers); return(true); }
public static void RemoveConnection(int hostId, int connectionId) { P2PConnection connection = P2PConnectionManager.GetConnection(hostId, connectionId); if (connection == null) { Debug.Log("Warning! Connection with " + connection + " doesn't exist"); } else { p2PController.DespawnPlayer(connection.lane); connections.Remove(connection); Debug.Log("Remove connection with " + connection); } }
private void CheckMasterOnDisconnection(P2PConnection disconnected_conn) { short hostId = this.LocalPeer.GetHostId(); for (int i = 0; i < this.m_Connections.Count; i++) { if (this.m_Connections[i] != null && this.m_Connections[i] != disconnected_conn && this.m_Connections[i].m_Peer.GetHostId() < hostId) { hostId = this.m_Connections[i].m_Peer.GetHostId(); } } if (P2PLogFilter.logDebug) { Debug.Log("P2PSession new master should be peer id: " + hostId); } this.m_AmIMaster = (this.LocalPeer.GetHostId() == hostId); }
public P2PChannelBuffer(P2PConnection conn, int bufferSize, byte cid, bool isReliable) { this.m_Connection = conn; this.m_MaxPacketSize = bufferSize - 100; this.m_CurrentPacket = new P2PChannelPacket(this.m_MaxPacketSize, isReliable); this.m_ChannelId = cid; this.m_MaxPendingPacketCount = 16; this.m_IsReliable = isReliable; if (isReliable) { this.m_PendingPackets = new Queue <P2PChannelPacket>(); if (P2PChannelBuffer.s_FreePackets == null) { P2PChannelBuffer.s_FreePackets = new List <P2PChannelPacket>(); } } }
public void DisconnectAllConnections() { this.m_AmIMaster = true; this.m_SpawnRefPosition = Vector3.zero; for (int i = 0; i < this.m_Connections.Count; i++) { P2PConnection p2PConnection = this.m_Connections[i]; if (p2PConnection != null) { this.m_RemotePeersInternal.Remove(p2PConnection.m_Peer); this.OnDisconnected(p2PConnection); this.m_Connections[p2PConnection.m_ConnectionId] = null; p2PConnection.Disconnect(); p2PConnection.Dispose(); } } this.m_RemotePeersInternal.Clear(); this.m_PendingPeers.Clear(); }
public void SendWriterTo(P2PPeer peer, P2PNetworkWriter writer, int channel_id) { P2PConnection p2PConnection = this.FindConnection(peer); if (p2PConnection == null || !p2PConnection.m_IsReady) { if (P2PLogFilter.logError) { if (p2PConnection == null) { Debug.LogError("Trying to send data without connection for peer: " + peer.GetHostId()); return; } Debug.LogError("Trying to send data on unready connection connection_id:" + p2PConnection.m_ConnectionId); } return; } p2PConnection.SendWriter(writer, channel_id); }
public bool SendToTransport(P2PConnection conn, int channelId) { bool result = true; byte b; if (!conn.TransportSend(this.m_Buffer, (int)((ushort)this.m_Position), channelId, out b) && (!this.m_IsReliable || b != 4)) { if (P2PLogFilter.logError) { Debug.LogError(string.Concat(new object[] { "Failed to send internal buffer channel:", channelId, " bytesToSend:", this.m_Position })); } result = false; } if (b != 0) { if (this.m_IsReliable && b == 4) { return(false); } if (P2PLogFilter.logError) { Debug.LogError(string.Concat(new object[] { "Send Error: ", b, " channel:", channelId, " bytesToSend:", this.m_Position })); } result = false; } this.m_Position = 0; return(result); }
private void OnPeerDisconnect(P2PNetworkMessage net_msg) { P2PConnection connection = net_msg.m_Connection; P2PPeer p2PPeer = (connection != null) ? connection.m_Peer : null; if (p2PPeer != null) { Dictionary <GameObject, Relevance> .Enumerator enumerator = this.m_Components.GetEnumerator(); while (enumerator.MoveNext()) { KeyValuePair <GameObject, Relevance> keyValuePair = enumerator.Current; Relevance value = keyValuePair.Value; if (value) { value.OnPeerDisconnected(p2PPeer); } } enumerator.Dispose(); } }
private void HandleData(int connection_id, int channel_id, int received_size, byte error) { P2PConnection p2PConnection = this.FindConnection(connection_id); if (p2PConnection == null) { if (P2PLogFilter.logError) { Debug.LogError("P2PSession HandleData Unknown connectionId:" + connection_id); } return; } if (error != 0) { this.OnDataError(p2PConnection, error); return; } this.m_MsgReader.SeekZero(); this.OnData(p2PConnection, received_size, channel_id); }
public override void Deserialize(NetworkReader reader) { lane = Convert.ToInt32(reader.ReadPackedUInt32()); int successfulConnectionsCount = Convert.ToInt32(reader.ReadPackedUInt32()); for (int i = 0; i < successfulConnectionsCount; i++) { byte[] bytes = reader.ReadBytesAndSize(); string ip = Encoding.UTF8.GetString(bytes); int port = Convert.ToInt32(reader.ReadPackedUInt32()); P2PConnection connection = new P2PConnection(ip, port); connection.lane = Convert.ToInt32(reader.ReadPackedUInt32()); successfulConnections.Add(connection); } r = Convert.ToInt32(reader.ReadPackedUInt32()); g = Convert.ToInt32(reader.ReadPackedUInt32()); b = Convert.ToInt32(reader.ReadPackedUInt32()); }
public void ApplyConsent(ConsentMessage message) { Debug.Log("P2P: Applying consent for: " + message.consentAction); if (message.consentAction == ConsentAction.SpawnRocket) { bool cheating = !gameController.lanes[message.parameters[1]].spawnManager.ValidIndex(message.result); if (!cheating) { gameController.lanes[message.parameters[1]].spawnManager.Spawn(message.result); } else { Debug.Log("Cheat!"); if (Recorder.session != null) { Recorder.session.cheatsPassed++; } } } else if (message.consentAction == ConsentAction.JoinGame) { P2PConnection connection = P2PConnectionManager.GetConnection(message.parameters[0], message.parameters[1]); if (connection != null) { JoinAnswerMessage answerMessage = new JoinAnswerMessage(); answerMessage.lane = message.result; answerMessage.successfulConnections = P2PConnectionManager.GetSuccessfulConnections(); answerMessage.r = Convert.ToInt32(gameColor.r * 255); answerMessage.g = Convert.ToInt32(gameColor.g * 255); answerMessage.b = Convert.ToInt32(gameColor.b * 255); P2PSender.Send(message.parameters[0], message.parameters[1], P2PChannels.ReliableChannelId, answerMessage, MessageTypes.JoinAnswer); connection.SuccessfullyConnect(); Debug.Log("Sending JoinAnswer with lane: " + answerMessage.lane + "and " + answerMessage.successfulConnections.Count + " connections"); } } }
private void button_Click(object sender, RoutedEventArgs e) { Thread connectThread = new Thread(new ThreadStart(() => { ushort port = 8333; if (_networkParameters.IsTestNet) { port = 18333; } p2p = new P2PConnection(IPAddress.Parse("82.45.214.119"), _networkParameters, new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp), port); bool success = p2p.ConnectToPeer(1); if (!success) { MessageBox.Show("Not connected"); } })); connectThread.IsBackground = true; connectThread.Start(); Thread threadLable = new Thread(new ThreadStart(() => { while (true) { Dispatcher.Invoke(() => { label.Content = "Inbound: " + P2PConnectionManager.GetInboundP2PConnections().Count + " Outbound: " + P2PConnectionManager.GetOutboundP2PConnections().Count; }); Thread.CurrentThread.Join(250); } })); threadLable.IsBackground = true; threadLable.Start(); }
public virtual void OnData(P2PConnection conn, int receivedSize, int channelId) { conn.TransportReceive(this.m_MsgBuffer, receivedSize, channelId); }
private void ConnectInternal(IP2PAddress address) { this.StartInternal(); this.m_AmIMaster = false; P2PAddressUnet p2PAddressUnet = address as P2PAddressUnet; if (p2PAddressUnet != null) { if (p2PAddressUnet.m_IP.Equals("localhost")) { p2PAddressUnet.m_IP = "127.0.0.1"; } else if (p2PAddressUnet.m_IP.IndexOf(":") != -1 && !P2PSession.IsValidIpV6(p2PAddressUnet.m_IP) && P2PLogFilter.logError) { Debug.LogError("Invalid ipv6 address " + p2PAddressUnet.m_IP); } } int networkConnectionId; if (this.m_UseSimulator) { int num = this.m_SimulatedLatency / 3; if (num < 1) { num = 1; } if (P2PLogFilter.logDebug) { Debug.Log(string.Concat(new object[] { "Connect Using Simulator ", this.m_SimulatedLatency / 3, "/", this.m_SimulatedLatency })); } ConnectionSimulatorConfig config = new ConnectionSimulatorConfig(num, this.m_SimulatedLatency, num, this.m_SimulatedLatency, this.m_PacketLoss); byte b; networkConnectionId = P2PTransportLayer.Instance.ConnectWithSimulator(address, out b, config); } else { byte b; networkConnectionId = P2PTransportLayer.Instance.Connect(address, out b); } P2PConnection p2PConnection = (P2PConnection)Activator.CreateInstance(typeof(P2PConnection)); p2PConnection.SetHandlers(this.m_MessageHandlers); P2PPeer p2PPeer = null; for (int i = 0; i < this.m_PendingPeers.Count; i++) { if (this.m_PendingPeers[i].IsSameAddress(address)) { p2PPeer = this.m_PendingPeers[i]; this.m_PendingPeers.RemoveAt(i); break; } } if (p2PPeer == null) { p2PPeer = new P2PPeer(); p2PPeer.m_Address = address; } if (!this.m_RemotePeersInternal.Contains(p2PPeer)) { this.m_RemotePeersInternal.Add(p2PPeer); } p2PConnection.Initialize(p2PPeer, networkConnectionId, P2PSession.s_HostTopology); this.SetConnectionAtIndex(p2PConnection); if (this.Status == P2PSession.ESessionStatus.Idle) { this.Status = P2PSession.ESessionStatus.Connecting; } }
public virtual void OnDisconnectError(P2PConnection conn, byte error) { Debug.LogError("OnDisconnectError error:" + error); }
public virtual void OnConnected(P2PConnection conn) { conn.m_IsReady = true; conn.InvokeHandlerNoData(32); }
public virtual void OnDisconnected(P2PConnection conn) { conn.InvokeHandlerNoData(33); }
public static async Task <bool> ListenForIncomingP2PConnectionsAsync(IPAddress ipInterfaceToBind, P2PNetworkParameters netParams) { if (!_listening) { if (netParams.ListenForPeers) { try { LingerOption lo = new LingerOption(false, 0); _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); _socket.LingerState = lo; _listening = true; _localEndPoint = new IPEndPoint(ipInterfaceToBind, netParams.P2PListeningPort); if (_socket.IsBound) { _socket.Close(); } _socket.Bind(_localEndPoint); _socket.Listen(1000); if (netParams.UPnPMapPort) { //try upnp port forward mapping await SetNATPortForwardingUPnPAsync(netParams.P2PListeningPort, netParams.P2PListeningPort); } _listenThread = new Thread(new ThreadStart(() => { while (_listening) { try { Socket newConnectedPeerSock = _socket.Accept(); //if we haven't reached maximum specified to connect to us, allow the connection if (GetInboundP2PConnections().Count < P2PNetworkParameters.MaxIncomingP2PConnections) { //we've accepted a new peer create a new P2PConnection object to deal with them and we need to be sure to mark it as incoming so it gets stored appropriately P2PConnection p2pconnecting = new P2PConnection(((IPEndPoint)newConnectedPeerSock.RemoteEndPoint).Address, netParams, newConnectedPeerSock, Convert.ToUInt16(((IPEndPoint)newConnectedPeerSock.RemoteEndPoint).Port), true); p2pconnecting.ConnectToPeer(0); } else { newConnectedPeerSock.Close(); } } catch (SocketException sex) { //trap the exception "A blocking operation was interrupted by a call to WSACancelBlockingCall" thrown when we kill the listening socket but throw any others if (sex.ErrorCode != 10004) { //he said sex hehehehehehe throw sex; } } } })); _listenThread.IsBackground = true; _listenThread.Start(); } #if (!DEBUG) catch { _listening = false; }