public NetClientHelper()
 {
     NetPeerConfiguration config = new NetPeerConfiguration("CozyKxlol");
     config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
     client = new NetClient(config);
     client.Start();
 }

 /// <summary>
 /// MPCLient constructor with MPThreadStopCondition as a parameter.
 /// </summary>
 /// <param name="condition">The condition to stop the ProcessMessageThread.</param>
 public MPClient(MPSharedCondition condition)
 {
     StopMessageProcessingThread = condition ?? new MPSharedCondition(false);
     ResetConfig();
     netClient = new NetClient(config);
     pts = new ParameterizedThreadStart(this.ProcessMessage);
 }

        public Client(RenderWindow window, ImageManager imageManager)
            : base(window, imageManager)
        {
            this.window = window;
            world = new RenderImage(800, 600);

            inputManager = new InputManager(this);

            ticker = new Ticker();

            window.ShowMouseCursor (false);
            window.SetFramerateLimit (60);

            NetPeerConfiguration netConfiguration = new NetPeerConfiguration("2dThing");
            client = new NetClient(netConfiguration);

            uMsgBuffer = new UserMessageBuffer();
            otherClients = new Dictionary<int, NetworkClient>();
            chat = new Chat(this);

            LoadRessources();

            blockTypeDisplay = new Cube(blockType, imageManager);
            blockTypeDisplay.Position = new Vector2f(window.Width - 2*Cube.WIDTH, window.Height - 2* Cube.HEIGHT);
            layerDisplay = new LayerDisplay(imageManager);
            layerDisplay.Position = blockTypeDisplay.Position - new Vector2f(0, 50);

            mouse = new Sprite (imageManager.GetImage("mouse"));
        }

        public static void Connect(IPEndPoint endpoint, MMDevice device, ICodec codec)
        {
            var config = new NetPeerConfiguration("airgap");

            _client = new NetClient(config);
            _client.RegisterReceivedCallback(MessageReceived);

            _client.Start();

            _waveIn = new WasapiLoopbackCapture(device);
            _codec = codec;

            _sourceFormat = _waveIn.WaveFormat;
            _targetFormat = new WaveFormat(_codec.SampleRate, _codec.Channels); // format to convert to

            _waveIn.DataAvailable += SendData;
            _waveIn.RecordingStopped += (sender, args) => Console.WriteLine("Stopped");
            // TODO: RecordingStopped is called when you change the audio device settings, should recover from that

            NetOutgoingMessage formatMsg = _client.CreateMessage();
            formatMsg.Write(_targetFormat.Channels);
            formatMsg.Write(_targetFormat.SampleRate);
            formatMsg.Write(codec.Name);

            _client.Connect(endpoint, formatMsg);
        }

        public SpaceClient()
        {
            config = Constants.GetConfig();
            client = new NetClient(config);

            ClientStarted = false;
        }

 public void fireConnectionRejected(NetClient client, NetBuffer buffer)
 {
     if (ConnectionRejected != null)
     {
         ConnectionRejected(client, buffer);
     }
 }

        public void Connect()
        {
            client = new NetClient(config);
            client.Start();

            client.DiscoverLocalPeers(14242);
        }

 private NetworkManager()
 {
     NetPeerConfiguration config = new NetPeerConfiguration("SpireServer");
     config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
     config.NetworkThreadName = "Spire Client";
     client = new NetClient(config);
 }

        public void SetUpConnection()
        {
            configuration = new NetPeerConfiguration("PingPong");

            configuration.EnableMessageType(NetIncomingMessageType.WarningMessage);
            configuration.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
            configuration.EnableMessageType(NetIncomingMessageType.ErrorMessage);
            configuration.EnableMessageType(NetIncomingMessageType.Error);
            configuration.EnableMessageType(NetIncomingMessageType.DebugMessage);
            configuration.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
            configuration.EnableMessageType(NetIncomingMessageType.Data);

            switch (networkRole)
            {
                case GamerNetworkType.Client:
                    Client = new NetClient(configuration);
                    Client.Start();
                    Client.Connect(new IPEndPoint(NetUtility.Resolve(IP), Convert.ToInt32(Port)));
                    break;
                case GamerNetworkType.Server:
                    configuration.Port = Convert.ToInt32(Port);
                    Server = new NetServer(configuration);
                    Server.Start();
                    break;
                default:
                    throw new ArgumentException("Network type was not set");
            }
        }

 private void SetupClient()
 {
     NetPeerConfiguration config = new NetPeerConfiguration("dystopia");
     Client = new NetClient(config);
     Client.Start();
     Client.Connect(NetUtility.Resolve(ServerIP, ServerPort));
 }

        private void Client_Load(object sender, EventArgs e)
        {
            NetPeerConfiguration config = new NetPeerConfiguration("Testing");
            config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);

            client = new NetClient(config);
        }

 private static NetClient ConnectServer()
 {
     var config = new NetPeerConfiguration("pic") {EnableUPnP = true};
     var thisClient = new NetClient(config);
     thisClient.RegisterReceivedCallback(HandleMessage);
     return thisClient;
 }

        public void InitClients(int netClientcount)
        {
            m_NetClientCount = netClientcount;
            Nets = new NetClient[m_NetClientCount];
            TextNetMsgS = new string[m_NetClientCount];
            m_lastSent = new double[m_NetClientCount];
            TextNetMsgSB = new StringBuilder();
            System.Net.IPAddress mask = null;
            System.Net.IPAddress local = NetUtility.GetMyAddress(out mask);
            //
            for (int i = 0; i < Nets.Length; i++) {
                NetPeerConfiguration config = new NetPeerConfiguration("many");

                config.LocalAddress = local;
            #if DEBUG
            config.SimulatedLoss = 0.02f;
            #endif
                NetClient Net = new NetClient(config);
                Nets[i] = Net;
                Net.Start();
                //Net.Connect("localhost", 14242);
                Net.Connect(new System.Net.IPEndPoint(config.LocalAddress, 14242));
                //
                Application.DoEvents();
            }
        }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="numPorts"></param>
		/// <param name="timeout"></param>
		void StartDiscoveryInternal ( int numPorts, TimeSpan timeout )
		{
			lock (lockObj) {
				if (client!=null) {
					Log.Warning("Discovery is already started.");
					return;
				}

				this.timeout	=	timeout;

				var netConfig = new NetPeerConfiguration( Game.GameID );
				netConfig.EnableMessageType( NetIncomingMessageType.DiscoveryRequest );
				netConfig.EnableMessageType( NetIncomingMessageType.DiscoveryResponse );

				client	=	new NetClient( netConfig );
				client.Start();

				var svPort	=	Game.Network.Port;

				var ports = Enumerable.Range(svPort, numPorts)
							.Where( p => p <= ushort.MaxValue )
							.ToArray();

				Log.Message("Start discovery on ports: {0}", string.Join(", ", ports) );

				foreach (var port in ports) {
					client.DiscoverLocalPeers( port );
				}
			}
		}

 public void SendUpdates(NetClient client)
 {
     NetOutgoingMessage om = client.CreateMessage();
     om.Write(Helpers.TransferType.ProjectileUpdate);
     om.Write(new ProjectileTransferableData(client.UniqueIdentifier,ID,IsValid,Position,Angle));
     client.SendMessage(om, NetDeliveryMethod.UnreliableSequenced);
 }

        public static void Main(string[] args)
        {
            Console.WriteLine("[CLIENT] Testing Lidgren-Network-v3...");

            NetPeerConfiguration clientConfig = new NetPeerConfiguration("test");
            clientConfig.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
            NetClient client = new NetClient(clientConfig);
            client.Start();

            SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
            client.RegisterReceivedCallback(new SendOrPostCallback(GotMessage));

            Console.WriteLine("IP to connect to: ");
            String ip = Console.ReadLine();

            client.Connect(new System.Net.IPEndPoint(System.Net.IPAddress.Parse(ip), 12345));

            while(true) {
                string msg = Console.ReadLine();

                NetOutgoingMessage sendMsg = client.CreateMessage();
                sendMsg.Write("[CLIENT] " + msg);
                client.SendMessage(sendMsg, NetDeliveryMethod.ReliableOrdered);
            }
        }

        public WorldClientBase(string protocolVersion)
        {
            this.protocolVersion = protocolVersion;

            // Net configuration
            NetPeerConfiguration cfg = new NetPeerConfiguration("Asteria");
            cfg.MaximumConnections = 1;
            cfg.ReceiveBufferSize = 4095;
            cfg.MaximumTransmissionUnit = 4095;
            #if DEBUG
            try
            {
                cfg.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
            }
            catch
            {
                Logger.Output(this, "Running in debug mode but using release Lidgren library version, Lidgren debug messages disabled!");
            }
            #endif
            client = new NetClient(cfg);
            client.Start();

            // Create objects needed.
            sendingQ = new Queue<ClientToServerMessage>(64);
            receivingQ = new Queue<NetIncomingMessage>(128);
            newDataArrivedEvent = new AutoResetEvent(false);

            messages = new Dictionary<MessageType, List<ServerToClientMessage>>();
            serializer = new ClientToServerMessageSerializer();
            deserializer = new ServerToClientMessageSerializer();

            isRunning = true;
        }

        public NetworkMultiplayer(bool createServer = false)
            : base(GameModes.Network)
        {
            if(createServer)
                GameServer = new GameServer();

            //read network on each update
            Game.Instance.OnUpdate += ReadNetwork;

            //server config
            NetPeerConfiguration config = new NetPeerConfiguration("tank");
            config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);

            //server creation
            Client = new NetClient(config);
            Client.Start();

            if (!createServer)
            {
                //check whether the user has a known server
                ListMenu serverMenu = new ListMenu("Do you want to connect to a given IP (if yes, enter in console)?", "tank.Code.YESORNOCHOOSENOW", ConnectionMethodSelectionCallback);
                Scene.Add(serverMenu);
            }
            else//we know that a local server must exist
                Client.DiscoverLocalPeers(14242);
            //register handler for receiving data
            OnClientData += IncomingHandler;

            //are we client, or are we dancer?
            if(!createServer)
                Console.WriteLine("client");
        }

 public void fireDataRecieved(NetClient client, NetBuffer buffer)
 {
     if (DataRecieved != null)
     {
         DataRecieved(client, buffer);
     }
 }

 public Client()
 {
     NetPeerConfiguration config = new NetPeerConfiguration("CozyAnywhere");
     config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
     client                      = new NetClient(config);
     client.RegisterReceivedCallback(RecivePacket);
 }