예제 #1
0
        public override void DisconnectRemoteClient(ulong clientId)
        {
            if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
            {
                NetworkLog.LogInfo("SteamP2PTransport - DisconnectRemoteClient clientId: " + clientId);
            }

            if (!connectedUsers.ContainsKey(clientId))
            {
                if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                {
                    NetworkLog.LogError("SteamP2PTransport - Can't disconect client, client not connected, clientId: " + clientId);
                }
                return;
            }

            SteamNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, new byte[] { 0 }, 1, (int)InternalChannelType.Disconnect, P2PSend.Reliable);
            SteamId steamId = connectedUsers[clientId].SteamId;

            NetworkingManager.Singleton.StartCoroutine(Delay(100, () =>
            { //Need to delay the closing of the p2p sessions to not block the disconect message before it is sent.
                SteamNetworking.CloseP2PSessionWithUser(steamId);
                if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
                {
                    NetworkLog.LogInfo("SteamP2PTransport - DisconnectRemoteClient - has Closed P2P Session With clientId: " + clientId);
                }
            }));

            connectedUsers.Remove(clientId);
        }
        /// <summary>
        /// Cleans up our instance count and warns if there instantiation issues
        /// </summary>
        public void Dispose()
        {
            Shutdown();

#if UNITY_EDITOR || DEVELOPMENT_BUILD
            if (s_RpcQueueContainerInstances > 0)
            {
                if (NetworkLog.CurrentLogLevel == LogLevel.Developer)
                {
                    NetworkLog.LogInfo($"[Instance : {s_RpcQueueContainerInstances}] {nameof(RpcQueueContainer)} disposed.");
                }

                s_RpcQueueContainerInstances--;
            }
            else //This should never happen...if so something else has gone very wrong.
            {
                if (NetworkLog.CurrentLogLevel >= LogLevel.Normal)
                {
                    NetworkLog.LogError($"[*** Warning ***] {nameof(RpcQueueContainer)} is being disposed twice?");
                }

                throw new Exception("[*** Warning ***] System state is not stable!  Check all references to the Dispose method!");
            }
#endif
        }
예제 #3
0
 public override void DisconnectLocalClient()
 {
     if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
     {
         NetworkLog.LogInfo("SteamP2PTransport - DisconnectLocalClient");
     }
     SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, (int)InternalChannelType.Disconnect, P2PSend.Reliable);
 }
예제 #4
0
 /// <summary>
 /// TODO
 /// </summary>
 public void ResetParameterOptions()
 {
     if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
     {
         NetworkLog.LogInfo("ResetParameterOptions");
     }
     parameterSendBits  = 0;
     animatorParameters = null;
 }
예제 #5
0
 private void OnP2PSessionConnectFail(SteamId connectionAttemptFailedClientId, P2PSessionError request)
 {
     if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
     {
         NetworkLog.LogInfo("SteamP2PTransport - OnP2PSessionConnectFail - m_steamIDRemote: " + connectionAttemptFailedClientId + " Error: " + request.ToString());
     }
     connectionAttemptFailed = true;
     this.connectionAttemptFailedClientId = connectionAttemptFailedClientId;
 }
예제 #6
0
        private void OnP2PSessionRequest(SteamId userId)
        {
            if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
            {
                NetworkLog.LogInfo("SteamP2PTransport - OnP2PSessionRequest - m_steamIDRemote: " + userId);
            }

            //Todo: Might want to check if we expect the user before just accepting it.
            SteamNetworking.AcceptP2PSessionWithUser(userId);
        }
 /// <summary>
 /// Puts a PooledNetworkWriter back into the pool
 /// </summary>
 /// <param name="writer">The writer to put in the pool</param>
 public static void PutBackInPool(PooledNetworkWriter writer)
 {
     if (s_Writers.Count < 64)
     {
         s_Writers.Enqueue(writer);
     }
     else if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
     {
         NetworkLog.LogInfo($"{nameof(NetworkWriterPool)} already has 64 queued. Throwing to GC. Did you forget to dispose?");
     }
 }
예제 #8
0
 /// <summary>
 /// Puts a PooledBitReader back into the pool
 /// </summary>
 /// <param name="reader">The reader to put in the pool</param>
 public static void PutBackInPool(PooledBitReader reader)
 {
     if (readers.Count < 64)
     {
         readers.Enqueue(reader);
     }
     else if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
     {
         NetworkLog.LogInfo("BitReaderPool already has 64 queued. Throwing to GC. Did you forget to dispose?");
     }
 }
예제 #9
0
        /// <summary>
        /// Retrieves an expandable PooledBitStream from the pool
        /// </summary>
        /// <returns>An expandable PooledBitStream</returns>
        public static PooledBitStream GetStream()
        {
            if (streams.Count == 0)
            {
                if (overflowStreams.Count > 0)
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
                    {
                        NetworkLog.LogInfo("Retrieving PooledBitStream from overflow pool. Recent burst?");
                    }

                    object weakStream = null;
                    while (overflowStreams.Count > 0 && ((weakStream = overflowStreams.Dequeue().Target) == null))
                    {
                        ;
                    }

                    if (weakStream != null)
                    {
                        PooledBitStream strongStream = (PooledBitStream)weakStream;

                        strongStream.SetLength(0);
                        strongStream.Position = 0;

                        return(strongStream);
                    }
                }

                if (createdStreams == 254)
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
                        NetworkLog.LogWarning("255 streams have been created. Did you forget to dispose?");
                    }
                }
                else if (createdStreams < 255)
                {
                    createdStreams++;
                }

                return(new PooledBitStream());
            }

            PooledBitStream stream = streams.Dequeue();

            stream.SetLength(0);
            stream.Position = 0;

            return(stream);
        }
예제 #10
0
        /// <summary>
        /// Retrieves an expandable PooledNetworkBuffer from the pool
        /// </summary>
        /// <returns>An expandable PooledNetworkBuffer</returns>
        public static PooledNetworkBuffer GetBuffer()
        {
            if (s_Buffers.Count == 0)
            {
                if (s_OverflowBuffers.Count > 0)
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
                    {
                        NetworkLog.LogInfo($"Retrieving {nameof(PooledNetworkBuffer)} from overflow pool. Recent burst?");
                    }

                    object weakBuffer = null;
                    while (s_OverflowBuffers.Count > 0 && ((weakBuffer = s_OverflowBuffers.Dequeue().Target) == null))
                    {
                        ;
                    }

                    if (weakBuffer != null)
                    {
                        PooledNetworkBuffer strongBuffer = (PooledNetworkBuffer)weakBuffer;

                        strongBuffer.SetLength(0);
                        strongBuffer.Position = 0;

                        return(strongBuffer);
                    }
                }

                if (s_CreatedBuffers == k_MaxBitPoolBuffers)
                {
                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                    {
                        NetworkLog.LogWarning($"{k_MaxBitPoolBuffers} buffers have been created. Did you forget to dispose?");
                    }
                }
                else if (s_CreatedBuffers < k_MaxBitPoolBuffers)
                {
                    s_CreatedBuffers++;
                }

                return(new PooledNetworkBuffer());
            }

            PooledNetworkBuffer buffer = s_Buffers.Dequeue();

            buffer.SetLength(0);
            buffer.Position = 0;

            return(buffer);
        }
        /// <summary>
        /// RpcQueueContainer - Constructor
        /// Note about processExternally: this values determines if it will register with the Network Update Loop
        /// or not.  If not, then most likely unit tests are being preformed on this class.  The default value is false.
        /// </summary>
        /// <param name="maxFrameHistory"></param>
        /// <param name="processExternally">determines if it handles processing externally</param>
        public RpcQueueContainer(NetworkManager networkManager, uint maxFrameHistory = 0, bool processExternally = false)
        {
            NetworkManager = networkManager;

#if UNITY_EDITOR || DEVELOPMENT_BUILD
            //Keep track of how many instances we have instantiated
            s_RpcQueueContainerInstances++;

            if (NetworkLog.CurrentLogLevel == LogLevel.Developer)
            {
                NetworkLog.LogInfo($"[Instance : {s_RpcQueueContainerInstances}] {nameof(RpcQueueContainer)} Initialized");
            }
#endif

            m_ProcessUpdateStagesExternally = processExternally;
            Initialize(maxFrameHistory);
        }
예제 #12
0
 private void CloseP2PSessions()
 {
     foreach (User user in connectedUsers.Values)
     {
         SteamNetworking.CloseP2PSessionWithUser(user.SteamId);
     }
     if (serverUser != null)
     {
         SteamNetworking.CloseP2PSessionWithUser(serverUser.SteamId);
     }
     connectedUsers.Clear();
     serverUser = null;
     if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
     {
         NetworkLog.LogInfo("SteamP2PTransport - CloseP2PSessions - has Closed P2P Sessions With all Users");
     }
 }
예제 #13
0
        public override SocketTasks StartServer()
        {
            isServer = true;

            // setup the callback method
            SteamNetworking.OnP2PSessionRequest   += OnP2PSessionRequest;
            SteamNetworking.OnP2PConnectionFailed += OnP2PSessionConnectFail;


            OnConnected();

            if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
            {
                NetworkLog.LogInfo("SteamP2PTransport - StartServer - ConnectToCSteamID: " + SteamClient.SteamId.ToString());
            }

            return(SocketTask.Done.AsTasks());
        }
예제 #14
0
 /// <summary>
 /// Puts a PooledBitStream back into the pool
 /// </summary>
 /// <param name="stream">The stream to put in the pool</param>
 public static void PutBackInPool(PooledBitStream stream)
 {
     if (streams.Count > 16)
     {
         // The user just created lots of streams without returning them in between.
         // Streams are essentially byte array wrappers. This is valuable memory.
         // Thus we put this stream as a weak reference incase of another burst
         // But still leave it to GC
         if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
         {
             NetworkLog.LogInfo("Putting PooledBitStream into overflow pool. Did you forget to dispose?");
         }
         overflowStreams.Enqueue(new WeakReference(stream));
     }
     else
     {
         streams.Enqueue(stream);
     }
 }
예제 #15
0
        /// <summary>
        /// Puts a PooledNetworkBuffer back into the pool
        /// </summary>
        /// <param name="buffer">The buffer to put in the pool</param>
        public static void PutBackInPool(PooledNetworkBuffer buffer)
        {
            if (s_Buffers.Count > k_MaxCreatedDelta)
            {
                // The user just created lots of buffers without returning them in between.
                // Buffers are essentially byte array wrappers. This is valuable memory.
                // Thus we put this buffer as a weak reference incase of another burst
                // But still leave it to GC
                if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
                {
                    NetworkLog.LogInfo($"Putting {nameof(PooledNetworkBuffer)} into overflow pool. Did you forget to dispose?");
                }

                s_OverflowBuffers.Enqueue(new WeakReference(buffer));
            }
            else
            {
                s_Buffers.Enqueue(buffer);
            }
        }
예제 #16
0
        public override void Shutdown()
        {
            if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
            {
                NetworkLog.LogInfo("SteamP2PTransport - Shutdown");
            }

            SteamNetworking.OnP2PSessionRequest   -= OnP2PSessionRequest;
            SteamNetworking.OnP2PConnectionFailed -= OnP2PSessionConnectFail;
            if (clientOnFail != default)
            {
                SteamNetworking.OnP2PConnectionFailed -= clientOnFail;
                clientOnFail = default;
            }

            sendPings = false;
            isServer  = false;
            connectionAttemptFailed = false;
            channelSendTypes.Clear();
            channelCounter     = 0;
            currentPollChannel = 0;

            sentPings.Clear();
            pingIdCounter = 0;

            if (NetworkingManager.Singleton != null)
            {
                NetworkingManager.Singleton.StartCoroutine(Delay(100, () =>
                {//Need to delay the closing of the p2p sessions to not block the disconect message before it is sent.
                    CloseP2PSessions();
                }));
            }
            else
            {
                CloseP2PSessions();
            }
        }
        /// <summary>
        /// Flushes the internal messages
        /// Removes itself from the network update loop
        /// Disposes readers, writers, clears the queue history, and resets any parameters
        /// </summary>
        private void Shutdown()
        {
#if UNITY_EDITOR || DEVELOPMENT_BUILD
            if (NetworkLog.CurrentLogLevel == LogLevel.Developer)
            {
                NetworkLog.LogInfo($"[Instance : {s_RpcQueueContainerInstances}] {nameof(RpcQueueContainer)} shutting down.");
            }
#endif
            //As long as this instance is using the pre-defined update stages
            if (!m_ProcessUpdateStagesExternally)
            {
                //Remove ourself from the network loop update system
                this.UnregisterAllNetworkUpdates();
            }

            //Make sure any remaining internal messages are sent before completely shutting down.
            m_RpcQueueProcessor.InternalMessagesSendAndFlush(NetworkManager.IsListening);

            //Dispose of any readers and writers
            foreach (var queueHistorySection in m_QueueHistory)
            {
                foreach (var queueHistoryItemByStage in queueHistorySection.Value)
                {
                    foreach (var queueHistoryItem in queueHistoryItemByStage.Value)
                    {
                        queueHistoryItem.Value.QueueWriter?.Dispose();
                        queueHistoryItem.Value.QueueReader?.Dispose();
                        queueHistoryItem.Value.QueueBuffer?.Dispose();
                    }
                }
            }

            //Clear history and parameters
            m_QueueHistory.Clear();

            ClearParameters();
        }