public NetClientHelper() { NetPeerConfiguration config = new NetPeerConfiguration("CozyKxlol"); config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); client = new NetClient(config); client.Start(); }
static void Main(string[] args) { SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); Console.WriteLine("This is the client."); Players = new List<Player>(); Config = new NetPeerConfiguration("MyGame"); Console.WriteLine("Created client configuration"); Client = new NetClient(Config); Console.WriteLine("Initialized client socket"); Client.RegisterReceivedCallback(new SendOrPostCallback(ReceiveData)); Client.Start(); Console.WriteLine("Started client."); Client.Connect("localhost", 7777); Console.WriteLine("Requesting connection to server"); new Thread(new ThreadStart(delegate { string input; while ((input = Console.ReadLine()) != null) { Console.WriteLine("New input."); string[] prms = input.Split(' '); switch (prms[0]) { case "/changename": break; } } })).Start(); }
public CozyClient(string ClientName) { NetPeerConfiguration config = new NetPeerConfiguration(ClientName); config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); InnerClient = new NetClient(config); InnerClient.RegisterReceivedCallback(RecivePacket); }
/// <summary> /// Server constructor, starts the server and connects to all region servers. /// </summary> /// <remarks> /// TODO: Make the config file be able to be in a different location. Load from command line. /// </remarks> public MasterServer() { //Load this region server's junk from xml XmlSerializer deserializer = new XmlSerializer(typeof(MasterConfig)); MasterConfig masterconfig = (MasterConfig)deserializer.Deserialize(XmlReader.Create(@"C:\Users\Addie\Programming\Mobius\Mobius.Server.MasterServer\bin\Release\MasterData.xml")); //Start it with the name MobiusMasterServer, and let connection approvals be enabled var config = new NetPeerConfiguration(masterconfig.ServerName); config.Port = masterconfig.ServerPort; config.MaximumConnections = masterconfig.MaxConnections; config.EnableMessageType(NetIncomingMessageType.ConnectionApproval); LidgrenServer = new NetServer(config); RegionServers = new Dictionary<ushort, NetClient>(); foreach(RegionInfo info in masterconfig.RegionServers) { NetClient region = new NetClient(new NetPeerConfiguration(info.ServerName)); region.Start(); region.Connect(info.ServerIp, info.ServerPort); RegionServers.Add(info.RegionId, region); } //Initialize our data structures Users = new Dictionary<Guid, User>(); UserIdToCharacters = new Dictionary<Guid, List<Character>>(); //Start the server LidgrenServer.Start(); }
public Client() { NetPeerConfiguration config = new NetPeerConfiguration("CozyAnywhere"); config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); client = new NetClient(config); client.RegisterReceivedCallback(RecivePacket); }
/// <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 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 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 Boolean Connect() { var result = true; if (nethandler == null || netaddress == null || netport == 0) { result = false; } else { if (netconn == null) { netconfig = new NetPeerConfiguration("AuthServer"); netconn = new Lidgren.Network.NetClient(netconfig); netconn.RegisterReceivedCallback(new SendOrPostCallback(nethandler), new SynchronizationContext()); } try { netconn.Start(); var hail = netconn.CreateMessage("Coming in hot!"); var conn = netconn.Connect(netaddress, netport, hail); result = true; } catch { result = false; } } return(result); }
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")); }
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 ); } } }
/// <summary> /// Joining an existing lobby /// </summary> /// <param name="client">Existing client (created in JoinScreen)</param> public LobbyScreen(NetClient client) : base("Lobby") { host = false; _characterMenuEntry = new MenuEntry(string.Empty); SetMenuEntryText(); var playTest = new MenuEntry("Play"); var back = new MenuEntry("Back"); _firstPlayer = new MenuEntry("First Player: Not Connected"); _secondPlayer = new MenuEntry("Second Player: Not Connected"); _thirdPlayer = new MenuEntry("Third Player: Not Connected"); _fourthPlayer = new MenuEntry("Fourth Player: Not Connected"); _characterMenuEntry.Selected += _characterMenuEntry_Selected; Global.GameInProgress.Exiting += GameInProgress_Exiting; back.Selected += back_Selected; playTest.Selected += playTest_Selected; MenuEntries.Add(_characterMenuEntry); MenuEntries.Add(_firstPlayer); MenuEntries.Add(_secondPlayer); MenuEntries.Add(_thirdPlayer); MenuEntries.Add(_fourthPlayer); MenuEntries.Add(playTest); MenuEntries.Add(back); _menuEntryArray = new[] { _firstPlayer, _secondPlayer, _thirdPlayer, _fourthPlayer }; Client = client; }
public void StartClientConnection(string ip, string port) { _config = new NetPeerConfiguration(GameConfiguration.NetworkAppIdentifier) { #if DEBUG //PingInterval = 1f, // send ping every 1 second //SimulatedLoss = 0.5f, // from 0 to 1 SimulatedMinimumLatency = GameConfiguration.SimulatedMinimumLatency, #endif }; _config.EnableMessageType(NetIncomingMessageType.ConnectionLatencyUpdated); _hasStarted = true; _connected = false; _disconnected = false; // Client initialize _client = new NetClient(_config); _client.Start(); _messagePool = new Queue<NetIncomingMessage>(); var threadStart = new ThreadStart(MessagePooling); _messagePooling = new Thread(threadStart); _messagePooling.Start(); TryToConnect(ip, port); }
public Client_Model2() { _netconfig = new NetPeerConfiguration("SkyNet"); _client = new NetClient(_netconfig); _assembly = new SuperAssembly("Client"); _listen=new Thread(Listen); }
public static void StatusChangeHandler(NetClient client, NetBuffer buffer) { string status_msg = buffer.ReadString(); NetConnectionStatus status = (NetConnectionStatus)buffer.ReadByte(); if (status == NetConnectionStatus.Connected) { Console.WriteLine("Client: Connected"); Console.Write("Client: Starting IOS"); int i; for (i = 0; i < 10; i++) { Console.Write("."); Thread.Sleep(500); } Console.WriteLine(""); //Show the IOS Master form System.Windows.Forms.Application.EnableVisualStyles(); System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false); System.Windows.Forms.Application.Run(new MasterForm()); } if (status == NetConnectionStatus.Disconnected) { Console.WriteLine("Client: Disconnected - " + status_msg); } }
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(); Console.WriteLine("IP to connect to: "); String ip = Console.ReadLine(); client.Connect("192.168.1.2", 80); while (true) { if (client.ServerConnection != null) { string msg = Console.ReadLine(); NetOutgoingMessage sendMsg = client.CreateMessage(); sendMsg.Write(msg); client.SendMessage(sendMsg, NetDeliveryMethod.ReliableOrdered); } } }
public SpaceClient() { config = Constants.GetConfig(); client = new NetClient(config); ClientStarted = false; }
public NetworkClient(string Host, int Port) { Config = new NetPeerConfiguration("GameServer01"); ClientConnection = new NetClient(Config); ClientConnection.Start(); ClientConnection.Connect(Host, Port); }
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 void fireDataRecieved(NetClient client, NetBuffer buffer) { if (DataRecieved != null) { DataRecieved(client, buffer); } }
public void Connect() { client = new NetClient(config); client.Start(); client.DiscoverLocalPeers(14242); }
public void fireConnectionRejected(NetClient client, NetBuffer buffer) { if (ConnectionRejected != null) { ConnectionRejected(client, buffer); } }
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 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); }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); s_mainForm = new Form1(); NetConfiguration config = new NetConfiguration("stress"); config.ThrottleBytesPerSecond = 3500; s_client = new NetClient(config); // 100 ms simulated roundtrip latency s_client.SimulatedMinimumLatency = 0.1f; // ... + 0 to 50 ms s_client.SimulatedLatencyVariance = 0.05f; // 10% loss (!) // s_client.SimulatedLoss = 0.1f; // 5% duplicated messages (!) // s_client.SimulatedDuplicates = 0.05f; s_readBuffer = s_client.CreateBuffer(); s_sentUntil = NetTime.Now; s_nextDisplay = NetTime.Now; Application.Idle += new EventHandler(OnAppIdle); Application.Run(s_mainForm); s_client.Shutdown("Application exiting"); }
public long Connect(string host, ushort port) { var netClient = new Lidgren.Network.NetClient(_peerConfig); netClient.Start(); _clients.Add(netClient.UniqueIdentifier, netClient); var conn = netClient.Connect(host, port); return(netClient.UniqueIdentifier); }
/// <summary> /// Queries the current network for all servers running on their default ports, waiting /// 1 second to aggregate responses. /// </summary> /// <returns></returns> public static Task <DiscoveryResponse[]> DoDiscoveryAsync() { return(Task.Run(async() => { var responses = new List <DiscoveryResponse>(); var client = new Lidgren.Network.NetClient(new NetPeerConfiguration("MPTANKS")); client.Configuration.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); client.Configuration.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); client.DiscoverLocalPeers(33132); //DEFAULT PORT await Task.Delay(1000); // 5 second timeout NetIncomingMessage msg; while ((msg = client.ReadMessage()) != null) { if (msg.MessageType == NetIncomingMessageType.DiscoveryResponse) { try { responses.Add(Read(msg)); } catch { } } } responses.Add(new DiscoveryResponse { Address = "HELP", Port = 555, AllowsHotJoin = false, GamemodeDescription = "BEEP", GamemodeName = "JEEP", HasPassword = false, MapName = "MEEP", MaxPlayers = 44, Mods = new Modding.ModInfo[] { new Modding.ModInfo() { ModName = "COREASSETS" } }, PlayerCount = 5, ServerName = "RIP" }); return responses.ToArray(); })); }
private void HandleEvent(Lidgren.Network.NetClient netClient) { NetIncomingMessage netMessage; while ((netMessage = netClient.ReadMessage()) != null) { switch (netMessage.MessageType) { case NetIncomingMessageType.Data: var receivedData = netMessage.ReadBytes(netMessage.LengthBytes); OnNetworkReceive(netClient.UniqueIdentifier, receivedData); break; case NetIncomingMessageType.StatusChanged: NetConnectionStatus status = (NetConnectionStatus)netMessage.ReadByte(); if (status == NetConnectionStatus.Connected) { //Log.Debug(this, $"Connected {netMessage.SenderConnection.Peer.UniqueIdentifier}"); OnPeerConnected(netClient.UniqueIdentifier); } else if (status == NetConnectionStatus.Disconnected) { //Log.Debug(this, $"Disconnected {netMessage.SenderConnection.Peer.UniqueIdentifier}"); OnPeerDisconnected(netClient.UniqueIdentifier); } break; case NetIncomingMessageType.VerboseDebugMessage: case NetIncomingMessageType.DebugMessage: case NetIncomingMessageType.WarningMessage: case NetIncomingMessageType.ErrorMessage: //Log.Debug(this, netMessage.ReadString()); break; default: //Log.Debug(this, $"Unhandled message: {netMessage.MessageType}"); break; } } }
/// <summary> /// Requests the information from a server with a 10 second timeout. If a response is not /// received, it returns null. Otherwise, it returns the information provided by the server. /// </summary> /// <param name="server"></param> /// <param name="port"></param> /// <returns></returns> public static Task <DiscoveryResponse> RequestServerInfo(string server, ushort port) { return(Task.Run(() => { var client = new Lidgren.Network.NetClient(new NetPeerConfiguration("MPTANKS")); client.Configuration.EnableMessageType(NetIncomingMessageType.DiscoveryRequest); client.Configuration.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); client.DiscoverKnownPeer(server, port); var msg = client.WaitMessage(10000); if (msg == null) { return null; } if (msg.MessageType == NetIncomingMessageType.DiscoveryResponse) { try { return Read(msg); } catch { } } return null; })); }
public void Reset() { netconn = null; }