public ChatPeer(IPhotonPeerListener listener, ConnectionProtocol protocol) : base(listener, protocol)
        {
#if UNITY
#pragma warning disable 0162    // the library variant defines if we should use PUN's SocketUdp variant (at all)
            if (PhotonPeer.NoSocket)
            {
#if !UNITY_EDITOR && (UNITY_PS3 || UNITY_ANDROID)
                UnityEngine.Debug.Log("Using class SocketUdpNativeDynamic");
                this.SocketImplementation = typeof(SocketUdpNativeDynamic);
#elif !UNITY_EDITOR && UNITY_IPHONE
                UnityEngine.Debug.Log("Using class SocketUdpNativeStatic");
                this.SocketImplementation = typeof(SocketUdpNativeStatic);
#elif !UNITY_EDITOR && (UNITY_WINRT)
                // this automatically uses a separate assembly-file with Win8-style Socket usage (not possible in Editor)
#else
                Type udpSocket = Type.GetType("ExitGames.Client.Photon.SocketUdp, Assembly-CSharp");
                this.SocketImplementation = udpSocket;
                if (udpSocket == null)
                {
                    UnityEngine.Debug.Log("ChatClient could not find a suitable C# socket class. The Photon3Unity3D.dll only supports native socket plugins.");
                }
#endif
                if (this.SocketImplementation == null)
                {
                    UnityEngine.Debug.Log("No socket implementation set for 'NoSocket' assembly. Please contact Exit Games.");
                }
            }
#pragma warning restore 0162
			if (protocol == ConnectionProtocol.WebSocket || protocol == ConnectionProtocol.WebSocketSecure) {
            	UnityEngine.Debug.Log("Using SocketWebTcp");
            	this.SocketImplementation = Type.GetType("ExitGames.Client.Photon.SocketWebTcp, Assembly-CSharp");//typeof(SocketWebTcp);
			}
#endif
        }

    public NetworkingPeer(IPhotonPeerListener listener, string playername, ConnectionProtocol connectionProtocol)
        : base(listener, connectionProtocol)
    {
        #if UNITY_EDITOR || (!UNITY_IPHONE && !UNITY_ANDROID && !UNITY_PS3)
        Debug.Log("Using C# Socket");
        this.SocketImplementation = typeof(SocketUdp);
        #elif !UNITY_EDITOR && UNITY_PS3
        Debug.Log("Using class SocketUdpNativeDllImport");
        this.SocketImplementation = typeof(SocketUdpNativeDllImport);
        #elif !UNITY_EDITOR && UNITY_ANDROID
        Debug.Log("Using class SocketUdpNativeDynamic");
        this.SocketImplementation = typeof(SocketUdpNativeDynamic);
        #elif !UNITY_EDITOR && UNITY_IPHONE
        Debug.Log("Using class SocketUdpNativeStatic");
        this.SocketImplementation = typeof(SocketUdpNativeStatic);
        #endif

        this.Listener = this;

        // don't set the field directly! the listener is passed on to other classes, which get updated by the property set method
        this.externalListener = listener;
        this.PlayerName = playername;
        this.mLocalActor = new PhotonPlayer(true, -1, this.playername);
        this.AddNewPlayer(this.mLocalActor.ID, this.mLocalActor);

        // RPC shortcut lookup creation (from list of RPCs, which is updated by Editor scripts)
        rpcShortcuts = new Dictionary<string, int>(PhotonNetwork.PhotonServerSettings.RpcList.Count);
        for (int index = 0; index < PhotonNetwork.PhotonServerSettings.RpcList.Count; index++)
        {
            var name = PhotonNetwork.PhotonServerSettings.RpcList[index];
            rpcShortcuts[name] = index;
        }

        this.State = global::PeerState.PeerCreated;
    }

 public SessionData(string sessionName, string hostName, int port, ConnectionProtocol protocol, string sessionConfig)
 {
     SessionName = sessionName;
     Host = hostName;
     Port = port;
     Proto = protocol;
     PuttySession = sessionConfig;
 }

        public bool Connect(string address, ConnectionProtocol protocol)
        {
            if (this.UsedProtocol != protocol)
            {
                return false;
            }

            return true;
        }

 /// <summary>
 ///   Initializes a new instance of the <see cref = "TestClient" /> class.
 /// </summary>
 public TestClient(ConnectionProtocol connectionProtocol)
 {
     this.autoResetEventInit = new AutoResetEvent(false);
     this.OperationResponseQueue = new Queue<OperationResponse>(1000); 
     this.EventQueue = new Queue<EventData>(1000);
    
     this.PhotonClient = new LoadBalancingPeer(this, connectionProtocol) { DebugOut = DebugLevel.INFO };
     this.fiber.Start();
 }

 public LoadbalancingOnlineTests(string schemeName, ConnectionProtocol protocol)
     : base(new OnlineConnectPolicy(GetAuthScheme(schemeName), protocol))
 {
     if (schemeName == "TokenLessAuthForOldClients" || schemeName == "TokenAuthNoUserIds")
     {
         this.Player1 = null;
         this.Player2 = null;
         this.Player3 = null;
     }
 }

        /// <summary>
        ///   Initializes a new instance of the <see cref = "OnlineNUnitClient" /> class.
        /// </summary>
        public OnlineNUnitClient(ConnectionProtocol connectionProtocol, bool logPhotonClientMessages = false)
        {
            this.Id = Interlocked.Increment(ref curentId);
            this.LogPhotonClientMessages = logPhotonClientMessages;

            this.autoResetEventInit = new AutoResetEvent(false);
            this.OperationResponseQueue = new Queue<OperationResponse>(1000);
            this.EventQueue = new Queue<EventData>(1000);

            this.Peer = new PhotonPeer(this, connectionProtocol) { DebugOut = DebugLevel.INFO };
            this.fiber.Start();
        }

 public static ConnectPolicy GetPolicy(string policyName, ConnectionProtocol protocol)
 {
     switch (policyName)
     {
         case "DEV":
             //    return new OnlineConnectPolicy(new TokenAuthenticationScheme(), protocol)
         case "LIVE":
             //    return new OnlineConnectPolicy(new TokenAuthenticationScheme(), protocol);
         case "LOCAL":
         default:
             return new OnlineConnectPolicy(new TokenAuthenticationScheme(), protocol);
     }
 }

        public static Process Start(string serverAddress, string appId, ConnectionProtocol protocol, string photonCmdLine, string relativeWorkingDirectory)
        {
            if (CheckConnection(serverAddress, appId, protocol))
            {
                return null;
            }

            if (!IsLocalAddress(serverAddress))
            {
                throw new Exception(string.Format((string) "failed to establish connection to {0} using protocol {1}", serverAddress, protocol));
            }

            var path = FindPhoton();
            Environment.CurrentDirectory += relativeWorkingDirectory;

            return StartPhoton(serverAddress, appId, protocol, path, photonCmdLine);
        }

    public NetworkingPeer(IPhotonPeerListener listener, string playername, ConnectionProtocol connectionProtocol)
        : base(listener, connectionProtocol)
    {
        this.Listener = this;

        // don't set the field directly! the listener is passed on to other classes, which get updated by the property set method
        this.externalListener = listener;
        this.PlayerName = playername;
        this.mLocalActor = new PhotonPlayer(true, -1, this.playername);
        this.AddNewPlayer(this.mLocalActor.ID, this.mLocalActor);

        // RPC shortcut lookup creation (from list of RPCs, which is updated by Editor scripts)
        rpcShortcuts = new Dictionary<string, int>(PhotonNetwork.PhotonServerSettings.RpcList.Count);
        for (int index = 0; index < PhotonNetwork.PhotonServerSettings.RpcList.Count; index++)
        {
            var name = PhotonNetwork.PhotonServerSettings.RpcList[index];
            rpcShortcuts[name] = index;
        }

        this.State = global::PeerState.PeerCreated;
    }

        private static bool CheckConnection(string serverAddress, string appId, ConnectionProtocol protocol)
        {
            var listner = new PhotonListener(false);
            var peer = new PhotonPeer(listner, protocol);

            if (!peer.Connect(serverAddress, appId))
            {
                return false;
            }

            var counter = 100;
            while (--counter > 0)
            {
                peer.Service();
                if (listner.WaitForConnection(0))
                {
                    var res = peer.PeerState == PeerStateValue.Connected;
                    peer.Disconnect();
                    return res;
                }
                Thread.Sleep(50);
            }
            return false;
        }

 /// <summary>
 /// Creates a LitePeer instance to communicate with Photon with your selection of protocol.
 /// We recommend UDP.
 /// </summary>
 /// <param name="listener">Your IPhotonPeerListener implementation.</param>
 /// <param name="protocolType">Protocol to use to connect to Photon.</param>
 public LitePeer(IPhotonPeerListener listener, ConnectionProtocol protocolType) : base(listener, protocolType)
 {
 }

    /// <summary>
    /// Sends this app's appId and appVersion to identify this application server side.
    /// This is an async request which triggers a OnOperationResponse() call.
    /// </summary>
    /// <remarks>
    /// This operation makes use of encryption, if that is established before.
    /// See: EstablishEncryption(). Check encryption with IsEncryptionAvailable.
    /// This operation is allowed only once per connection (multiple calls will have ErrorCode != Ok).
    /// </remarks>
    /// <param name="appId">Your application's name or ID to authenticate. This is assigned by Photon Cloud (webpage).</param>
    /// <param name="appVersion">The client's version (clients with differing client appVersions are separated and players don't meet).</param>
    /// <param name="authValues">Optional authentication values. The client can set no values or a UserId or some parameters for Custom Authentication by a server.</param>
    /// <param name="regionCode">Optional region code, if the client should connect to a specific Photon Cloud Region.</param>
    /// <param name="encryptionMode"></param>
    /// <param name="expectedProtocol"></param>
    /// <returns>If the operation could be sent (has to be connected).</returns>
    public virtual bool OpAuthenticateOnce(string appId, string appVersion, AuthenticationValues authValues, string regionCode, EncryptionMode encryptionMode, ConnectionProtocol expectedProtocol)
    {
        if (this.DebugOut >= DebugLevel.INFO)
            {
                this.Listener.DebugReturn(DebugLevel.INFO, "OpAuthenticate()");
            }

            var opParameters = new Dictionary<byte, object>();

            // shortcut, if we have a Token
            if (authValues != null && authValues.Token != null)
            {
                opParameters[ParameterCode.Secret] = authValues.Token;
                return this.OpCustom(OperationCode.AuthenticateOnce, opParameters, true, (byte)0, false);   // we don't have to encrypt, when we have a token (which is encrypted)
            }

            if (encryptionMode == EncryptionMode.DatagramEncryption && expectedProtocol != ConnectionProtocol.Udp)
            {
                Debug.LogWarning("Expected protocol set to UDP, due to encryption mode DatagramEncryption. Changing protocol in PhotonServerSettings from: " + PhotonNetwork.PhotonServerSettings.Protocol);
                PhotonNetwork.PhotonServerSettings.Protocol = ConnectionProtocol.Udp;
                expectedProtocol = ConnectionProtocol.Udp;
            }

            opParameters[ParameterCode.ExpectedProtocol] = (byte)expectedProtocol;
            opParameters[ParameterCode.EncryptionMode] = (byte)encryptionMode;

            opParameters[ParameterCode.AppVersion] = appVersion;
            opParameters[ParameterCode.ApplicationId] = appId;

            if (!string.IsNullOrEmpty(regionCode))
            {
                opParameters[ParameterCode.Region] = regionCode;
            }

            if (authValues != null)
            {
                if (!string.IsNullOrEmpty(authValues.UserId))
                {
                    opParameters[ParameterCode.UserId] = authValues.UserId;
                }

                if (authValues.AuthType != CustomAuthenticationType.None)
                {
                    opParameters[ParameterCode.ClientAuthenticationType] = (byte)authValues.AuthType;
                    if (!string.IsNullOrEmpty(authValues.Token))
                    {
                        opParameters[ParameterCode.Secret] = authValues.Token;
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(authValues.AuthGetParameters))
                        {
                            opParameters[ParameterCode.ClientAuthenticationParams] = authValues.AuthGetParameters;
                        }
                        if (authValues.AuthPostData != null)
                        {
                            opParameters[ParameterCode.ClientAuthenticationData] = authValues.AuthPostData;
                        }
                    }
                }
            }

            return this.OpCustom(OperationCode.AuthenticateOnce, opParameters, true, (byte)0, this.IsEncryptionAvailable);
    }

    private readonly Dictionary<byte, object> opParameters = new Dictionary<byte, object>(); // used in OpRaiseEvent() (avoids lots of new Dictionary() calls)

    #endregion Fields

    #region Constructors

    /// <summary>
    /// Creates a Peer with selected connection protocol.
    /// </summary>
    /// <remarks>Each connection protocol has it's own default networking ports for Photon.</remarks>
    /// <param name="protocolType">The preferred option is UDP.</param>
    public LoadBalancingPeer(ConnectionProtocol protocolType)
        : base(protocolType)
    {
        // this does not require a Listener, so:
            // make sure to set this.Listener before using a peer!
    }

        private static Process StartPhoton(string serverAddress, string appId, ConnectionProtocol protocol, string path, string photonCmdLine)
        {
            var process = Process.Start(path, photonCmdLine);
            if (process == null)
            {
                throw new Exception("PhotonSocketServer.exe can not be started");
            }

            if (process.WaitForExit(6500))
            {
                throw new Exception(string.Format("'{0}' finished unexpectedly.", path));
            }

            // we try to connect to new process
            var count = 15;
            while (count-- > 0)
            {
                if (CheckConnection(serverAddress, appId, protocol))
                {
                    return process;
                }

                if (process.WaitForExit(1000))
                {
                    process.Close();
                    throw new Exception(string.Format("'{0}' finished unexpectedly", path));
                }
            }

            process.CloseMainWindow();
            if (!process.WaitForExit(1000))
            {
                process.Kill();
            }
            process.Close();
            throw new Exception(string.Format("Unable to connect to address={1} and process {0}", path, serverAddress));
        }

        public bool Connect(string address, ConnectionProtocol protocol, string appId, string appVersion, string userId, AuthenticationValues authValues)
        {
            if (!this.HasPeer)
            {
                this.chatPeer = new ChatPeer(this, protocol);
            }
            else
            {
                this.Disconnect();
                if (this.chatPeer.UsedProtocol != protocol)
                {
                    this.chatPeer = new ChatPeer(this, protocol);
                }
            }

            // #pragma warning disable 0162    // the library variant defines if we should use PUN's SocketUdp variant (at all)
            //             if (PhotonPeer.NoSocket)
            //             {
            // #if !UNITY_EDITOR && (UNITY_PS3 || UNITY_ANDROID)
            //                 UnityEngine.Debug.Log("Chat uses class SocketUdpNativeDynamic");
            //                 this.chatPeer.SocketImplementation = typeof(SocketUdpNativeDynamic);
            // #elif !UNITY_EDITOR && UNITY_IPHONE
            //                 UnityEngine.Debug.Log("Chat uses class SocketUdpNativeStatic");
            //                 this.chatPeer.SocketImplementation = typeof(SocketUdpNativeStatic);
            // #elif !UNITY_EDITOR && (UNITY_WINRT || UNITY_WP8)
            //                 // this automatically uses a separate assembly-file with Win8-style Socket usage (not possible in Editor)
            // #else
            //                 UnityEngine.Debug.Log("Chat uses class SocketUdp (default)");
            //                 this.chatPeer.SocketImplementation = typeof(SocketUdp);
            //                 // PhotonHandler.PingImplementation defaults to PingMono
            // #endif
            //
            //                 if (this.chatPeer.SocketImplementation == null)
            //                 {
            //                     UnityEngine.Debug.Log("No socket implementation set for 'NoSocket' assembly. Please contact Exit Games.");
            //                 }
            //             }
            // #pragma warning restore 0162

            this.chatPeer.TimePingInterval = 3000;
            this.DisconnectedCause = ChatDisconnectCause.None;

            this.CustomAuthenticationValues = authValues;
            this.UserId = userId;
            this.AppId = appId;
            this.AppVersion = appVersion;
            this.didAuthenticate = false;
            this.msDeltaForServiceCalls = 100;

            // clean all channels
            this.PublicChannels.Clear();
            this.PrivateChannels.Clear();

            if (!address.Contains(":"))
            {
                int port = 0;
                ProtocolToNameServerPort.TryGetValue(protocol, out port);
                address = string.Format("{0}:{1}", address, port);
            }

            bool isConnecting = this.chatPeer.Connect(address, "NameServer");
            if (isConnecting)
            {
                this.State = ChatState.ConnectingToNameServer;
            }
            return isConnecting;
        }

        private readonly Dictionary<byte, object> opParameters = new Dictionary<byte, object>(); // used in OpRaiseEvent() (avoids lots of new Dictionary() calls)

        #endregion Fields

        #region Constructors

        public LoadbalancingPeer(ConnectionProtocol protocolType)
            : base(protocolType)
        {
        }

    public NetworkingPeer(IPhotonPeerListener listener, string playername, ConnectionProtocol connectionProtocol) : base(listener, connectionProtocol)
    {
        #if !UNITY_EDITOR && (UNITY_WINRT)
        // this automatically uses a separate assembly-file with Win8-style Socket usage (not possible in Editor)
        Debug.LogWarning("Using PingWindowsStore");
        PhotonHandler.PingImplementation = typeof(PingWindowsStore);    // but for ping, we have to set the implementation explicitly to Win 8 Store/Phone
        #endif

        #pragma warning disable 0162    // the library variant defines if we should use PUN's SocketUdp variant (at all)
        if (PhotonPeer.NoSocket)
        {
            #if !UNITY_EDITOR && (UNITY_PS3 || UNITY_ANDROID)
            Debug.Log("Using class SocketUdpNativeDynamic");
            this.SocketImplementation = typeof(SocketUdpNativeDynamic);
            PhotonHandler.PingImplementation = typeof(PingNativeDynamic);
            #elif !UNITY_EDITOR && UNITY_IPHONE
            Debug.Log("Using class SocketUdpNativeStatic");
            this.SocketImplementation = typeof(SocketUdpNativeStatic);
            PhotonHandler.PingImplementation = typeof(PingNativeStatic);
            #elif !UNITY_EDITOR && (UNITY_WINRT)
            // this automatically uses a separate assembly-file with Win8-style Socket usage (not possible in Editor)
            #else
            this.SocketImplementation = typeof (SocketUdp);
            PhotonHandler.PingImplementation = typeof(PingMonoEditor);
            #endif

            if (this.SocketImplementation == null)
            {
                Debug.Log("No socket implementation set for 'NoSocket' assembly. Please contact Exit Games.");
            }
        }
        #pragma warning restore 0162

        if (PhotonHandler.PingImplementation == null)
        {
            PhotonHandler.PingImplementation = typeof(PingMono);
        }

        this.Listener = this;
        this.lobby = TypedLobby.Default;
        this.LimitOfUnreliableCommands = 40;

        // don't set the field directly! the listener is passed on to other classes, which get updated by the property set method
        this.externalListener = listener;
        this.PlayerName = playername;
        this.mLocalActor = new PhotonPlayer(true, -1, this.playername);
        this.AddNewPlayer(this.mLocalActor.ID, this.mLocalActor);

        // RPC shortcut lookup creation (from list of RPCs, which is updated by Editor scripts)
        rpcShortcuts = new Dictionary<string, int>(PhotonNetwork.PhotonServerSettings.RpcList.Count);
        for (int index = 0; index < PhotonNetwork.PhotonServerSettings.RpcList.Count; index++)
        {
            var name = PhotonNetwork.PhotonServerSettings.RpcList[index];
            rpcShortcuts[name] = index;
        }

        this.State = global::PeerState.PeerCreated;
    }

    /// <summary>
    /// While offline, the network protocol can be switched (which affects the ports you can use to connect).
    /// </summary>
    /// <remarks>
    /// When you switch the protocol, make sure to also switch the port for the master server. Default ports are:
    /// TCP: 4530
    /// UDP: 5055
    ///
    /// This could look like this:<br/>
    /// Connect(serverAddress, <udpport|tcpport>, appID, gameVersion)
    ///
    /// Or when you use ConnectUsingSettings(), the PORT in the settings can be switched like so:<br/>
    /// PhotonNetwork.PhotonServerSettings.ServerPort = 4530;
    ///
    /// The current protocol can be read this way:<br/>
    /// PhotonNetwork.networkingPeer.UsedProtocol
    ///
    /// This does not work with the native socket plugin of PUN+ on mobile!
    /// </remarks>
    /// <param name="cp">Network protocol to use as low level connection. UDP is default. TCP is not available on all platforms (see remarks).</param>
    public static void SwitchToProtocol(ConnectionProtocol cp)
    {
        if (networkingPeer.UsedProtocol == cp)
        {
            return;
        }
        try
        {
            networkingPeer.Disconnect();
            networkingPeer.StopThread();
        }
        catch
        {

        }

        // set up a new NetworkingPeer
        NetworkingPeer newPeer = new NetworkingPeer(photonMono, String.Empty, cp);
        newPeer.mAppVersion = networkingPeer.mAppVersion;
        newPeer.CustomAuthenticationValues = networkingPeer.CustomAuthenticationValues;
        newPeer.PlayerName= networkingPeer.PlayerName;
        newPeer.mLocalActor = networkingPeer.mLocalActor;
        newPeer.DebugOut = networkingPeer.DebugOut;
        newPeer.CrcEnabled = networkingPeer.CrcEnabled;
        newPeer.lobby = networkingPeer.lobby;
        newPeer.LimitOfUnreliableCommands = networkingPeer.LimitOfUnreliableCommands;
        newPeer.SentCountAllowance = networkingPeer.SentCountAllowance;
        newPeer.TrafficStatsEnabled = networkingPeer.TrafficStatsEnabled;

        networkingPeer = newPeer;
        Debug.LogWarning("Protocol switched to: " + cp + ".");
    }

 public static int GetDefaultPort(ConnectionProtocol protocol)
 {
     int port = 22;
     switch (protocol)
     {
         case ConnectionProtocol.Raw:
             break;
         case ConnectionProtocol.Rlogin:
             port = 513;
             break;
         case ConnectionProtocol.Serial:
             break;
         case ConnectionProtocol.Telnet:
             port = 23;
             break;
     }
     return port;
 }