public PhotonPeer(PeerConnectionInformation serverConnectionInformation,
                          ConnectionProtocol connectionProtocol, DebugLevel debugLevel, ICoroutinesExecutor coroutinesExecuter)
        {
            NetworkTrafficState = NetworkTrafficState.Flowing;

            this.serverConnectionInformation = serverConnectionInformation;

            RawPeer = new ExitGames.Client.Photon.PhotonPeer(this, connectionProtocol)
            {
                ChannelCount = 4
            };

            #if UNITY_WEBGL || UNITY_XBOXONE || WEBSOCKET
            if (connectionProtocol == ConnectionProtocol.WebSocket ||
                connectionProtocol == ConnectionProtocol.WebSocketSecure)
            {
                var websocketType = typeof(SocketWebTcpCoroutine);
                RawPeer.SocketImplementationConfig[ConnectionProtocol.WebSocket] = websocketType;
            }
            #endif

            RawPeer.DebugOut = debugLevel;

            coroutinesExecuter.StartCoroutine(UpdateEngine());

            eventsBuffer             = new Queue <RawMessageData>(10);
            operationResponsesBuffer = new Queue <Tuple <RawMessageResponseData, short> >(10);
            optionsBuffer            = new Queue <BufferOption>(10);
        }
        private async Task Connect(IYield yield, PeerConnectionInformation connectionInformation)
        {
            isConnecting = true;

            try
            {
                outboundServerPeer = await serverConnectorProvider.GetServerConnector().Connect(yield, connectionInformation);
            }
            catch (CouldNotConnectToPeerException exception)
            {
                if (exception.Message != string.Empty && !exception.Message.Equals(exceptionMessage))
                {
                    LogUtils.Log($"Failed connect to {connectionInformation.Ip}:{connectionInformation.Port}. Details: {exception.Message}");
                    exceptionMessage = exception.Message;
                }
            }
            finally
            {
                if (IsConnected())
                {
                    SetNetworkTrafficState(NetworkTrafficState.Flowing);

                    connectContinuously?.Dispose();
                    onConnected?.Invoke(outboundServerPeer);
                }
            }

            isConnecting = false;
        }
        public void Connect(string serverName, Action onAuthorized, PeerConnectionInformation peerConnectionInformation)
        {
            this.serverName   = serverName;
            this.onAuthorized = onAuthorized;

            var serverConnectionInformation = GetServerConnectionInformation(ServerType.Game, peerConnectionInformation);

            CoroutinesExecutor.StartTask((yield) => Connect(yield, serverConnectionInformation));
        }
        private IEnumerator <IYieldInstruction> ConnectContinuously(PeerConnectionInformation connectionInformation)
        {
            const int DELAY_TIME = 10;

            outboundServerPeer = null;

            while (true)
            {
                yield return(new WaitForSeconds(DELAY_TIME));

                if (!isConnecting && !IsConnected())
                {
                    coroutinesManager.StartTask((yield) => Connect(yield, connectionInformation));
                }
            }
        }
        public async Task <IServerPeer> ConnectAsync(IYield yield, PeerConnectionInformation connectionInformation, ConnectionDetails connectionDetails)
        {
            var coroutinesExecuter = coroutinesExecuterProvider.Invoke();
            var photonPeer         = new PhotonPeer(connectionInformation, connectionDetails.ConnectionProtocol, connectionDetails.DebugLevel, coroutinesExecuter);

            photonPeer.Connect();

            var statusCode = await WaitForStatusCodeChange(yield, photonPeer);

            if (statusCode == StatusCode.Connect)
            {
                return(photonPeer);
            }

            LogUtils.Log($"Connecting to {connectionInformation.Ip}:{connectionInformation.Port} failed. Status Code: {statusCode}");
            return(null);
        }
Beispiel #6
0
 protected ServerConnectionInformation GetServerConnectionInformation(ServerType serverType, PeerConnectionInformation peerConnectionInformation)
 {
     return(new ServerConnectionInformation(serverType, peerConnectionInformation));
 }
Beispiel #7
0
 public ServerConnectionInformation(ServerType serverType, PeerConnectionInformation peerConnectionInformation)
 {
     ServerType = serverType;
     PeerConnectionInformation = peerConnectionInformation;
 }
 public void Connect(PeerConnectionInformation connectionInformation)
 {
     connectContinuously = coroutinesManager.StartCoroutine(ConnectContinuously(connectionInformation));
 }