public void StartServer(int port) { EventBasedNetListener listener = new EventBasedNetListener(); listener.ConnectionRequestEvent += OnConnectionRequest; listener.PeerConnectedEvent += OnPeerConnected; listener.PeerDisconnectedEvent += OnPeerDisconnected; listener.NetworkReceiveEvent += OnNetworkReceive; server = new NetManager(listener) { AutoRecycle = true, #if DEBUG SimulateLatency = true, SimulatePacketLoss = true, SimulationMinLatency = 50, SimulationMaxLatency = 100, #endif }; PlayerManager = new PlayerManager(); PacketProcessor = new NetPacketProcessor(); LiteNetLibUtils.RegisterAllPacketNestedTypes(PacketProcessor); LiteNetLibUtils.RegisterAllPacketProcessorsInCallingAssembly(PacketProcessor); server.Start(port); SimulatedWorld.Initialize(); LocalPlayer.SetNetworkProvider(this); LocalPlayer.IsMasterClient = true; // TODO: Load saved player info here LocalPlayer.SetPlayerData(new PlayerData(PlayerManager.GetNextAvailablePlayerId(), new Float3(1.0f, 0.6846404f, 0.243137181f))); }
public void Start() { // not if already started if (server != null) { logger.LogWarning("LiteNetLib: server already started."); return; } logger.Log("LiteNet SV: starting..."); // create server EventBasedNetListener listener = new EventBasedNetListener(); server = new NetManager(listener); server.UpdateTime = updateTime; server.DisconnectTimeout = disconnectTimeout; // set up events listener.ConnectionRequestEvent += Listener_ConnectionRequestEvent; listener.PeerConnectedEvent += Listener_PeerConnectedEvent; listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent; listener.PeerDisconnectedEvent += Listener_PeerDisconnectedEvent; listener.NetworkErrorEvent += Listener_NetworkErrorEvent; // start listening server.Start(port); }
private void InitAsClient(string address, int port, int maxConnections, string version, bool enableNatPunch) { Debug.Log("InitAsClient"); Profiler.BeginSample("InitAsClient"); _listener = new EventBasedNetListener(); _manager = new NetManager(_listener, maxConnections, version); _manager.NatPunchEnabled = enableNatPunch; _manager.UpdateTime = 0; InitializeEvents(); RespondToPings(); if (!_manager.Start()) { throw new ConnectionException($"Could not connect to {address}:{port}."); } Debug.Log("Connecting"); _manager.Connect(address, port); // TODO: support more players LocalClientRef.ClientId = 2; Server.ClientId = 1; _isServer = false; var firstPeer = _manager.GetFirstPeer(); if (firstPeer != null) { AddClient(new Client(_isServer ? 2 : 1), false); } Profiler.EndSample(); }
public void StartHost(GameObject canvas) { canvas.SetActive(false); Debug.LogError("starting host"); netListener = new EventBasedNetListener(); netListener.PeerConnectedEvent += (client) => { Debug.LogError($"Connected to client: {client}"); Debug.LogError("Sending InitialTickPacket"); SendPacket(new InitialTickPacket { tick = Tick }, DeliveryMethod.ReliableUnordered); }; netListener.ConnectionRequestEvent += (request) => { request.Accept(); }; netListener.NetworkReceiveEvent += (peer, reader, deliveryMethod) => { packetProcessor.ReadAllPackets(reader); }; packetProcessor = new NetPacketProcessor(); writer = new NetDataWriter(); PacketRegistrar.RegisterPackets(packetProcessor); netManager = new NetManager(netListener); netManager.Start(12345); ticking = true; }
public void Init(string ip, int port, string key) { _key = key; this._ip = ip; this._port = port; _listener = new EventBasedNetListener(); _listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => { OnNetMsg(dataReader.GetRemainingBytes()); dataReader.Recycle(); }; _listener.PeerConnectedEvent += (peer) => { UnityEngine.Debug.Log("Connected!!"); _peer = peer; OnConnected?.Invoke(); }; _listener.PeerDisconnectedEvent += (peer, disconnectInfo) => { UnityEngine.Debug.Log("DisConnected!!"); }; _client = new NetManager(_listener) { DisconnectTimeout = 300000 }; _isInit = true; Debug.Log($"Try Connect to {ip}:{port}"); }
public static void Start() { Config(); if (bIsCheck) { if (client == null) { EventBasedNetListener listener = new EventBasedNetListener(); client = new NetManager(listener); client.Start(); client.Connect(server /* host ip or name */, port /* port */, "SomeConnectionKey" /* text key or NetDataWriter */); listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => { Console.WriteLine("We got: {0}", dataReader.GetString(100 /* max length of string */)); dataReader.Recycle(); }; } while (!Console.KeyAvailable) { client.PollEvents(); Thread.Sleep(15); } } }
private void Awake() { netListener = new EventBasedNetListener(); netManager = new NetManager(netListener); audioSource = GetComponent <AudioSource>(); }
private void RequestNtpService(string ntpService) { Console.WriteLine($"Request time from \"{ntpService}\" service"); var ntpComplete = false; EventBasedNetListener listener = new EventBasedNetListener(); listener.NtpResponseEvent += ntpPacket => { if (ntpPacket != null) { Console.WriteLine("[MAIN] NTP time test offset: " + ntpPacket.CorrectionOffset); } else { Console.WriteLine("[MAIN] NTP time error"); } ntpComplete = true; }; NetManager nm = new NetManager(listener); nm.Start(); nm.CreateNtpRequest(ntpService); while (!ntpComplete) { Thread.Yield(); } }
public void Connect(string address, int maxConnectAttempts, bool ipv6Enabled, string connectKey) { // not if already connected or connecting if (client != null) { logger.LogWarning("LiteNet: client already connected/connecting."); return; } logger.Log("LiteNet CL: connecting..."); // create client EventBasedNetListener listener = new EventBasedNetListener(); client = new NetManager(listener); client.UpdateTime = updateTime; client.DisconnectTimeout = disconnectTimeout; client.MaxConnectAttempts = maxConnectAttempts; // DualMode seems to break some addresses, so make this an option so that it can be turned on when needed if (ipv6Enabled) { client.IPv6Enabled = IPv6Mode.DualMode; } // set up events listener.PeerConnectedEvent += Listener_PeerConnectedEvent; listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent; listener.PeerDisconnectedEvent += Listener_PeerDisconnectedEvent; listener.NetworkErrorEvent += Listener_NetworkErrorEvent; // start & connect client.Start(); client.Connect(address, port, connectKey); }
public void ConnectionDualMode() { var listener = new EventBasedNetListener(); var server = new NetManager(listener, new Crc32cLayer()); server.IPv6Mode = IPv6Mode.DualMode; server.Start(DefaultPort); listener.ConnectionRequestEvent += request => request.AcceptIfKey(DefaultAppKey); var client1 = ManagerStack.Client(1); var client2 = ManagerStack.Client(2); client1.Connect("127.0.0.1", DefaultPort, DefaultAppKey); client2.Connect("::1", DefaultPort, DefaultAppKey); while (server.ConnectedPeersCount != 2 || client1.ConnectedPeersCount != 1 || client2.ConnectedPeersCount != 1) { Thread.Sleep(15); server.PollEvents(); } Assert.AreEqual(2, server.ConnectedPeersCount); Assert.AreEqual(1, client1.ConnectedPeersCount); Assert.AreEqual(1, client2.ConnectedPeersCount); server.Stop(false); }
public NetworkBase(NetworkLogger logger) { this.Listener = new EventBasedNetListener(); this.NetManager = new NetManager(this.Listener) { NatPunchEnabled = true, DisconnectTimeout = (int)TimeSpan.FromSeconds(60).TotalMilliseconds, }; this.processor = new NetPacketProcessor(); // TODO: somehow register all types via dependency injection? this.processor.RegisterNestedType(Vector3Serializer.Write, Vector3Serializer.Read); this.processor.SubscribeReusable <NetCommand, NetPeer>(this.OnCommandReceived); this.Writer = new NetDataWriter(); this.Logger = logger; this.RegisterHandlers(); this.Listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => { this.processor.ReadAllPackets(dataReader, fromPeer); }; }
public void Start(string ipAddress, int serverPort) { Log.Info("Initializing LiteNetLibClient..."); SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); netPacketProcessor.SubscribeReusable <WrapperPacket, NetPeer>(OnPacketReceived); EventBasedNetListener listener = new EventBasedNetListener(); listener.PeerConnectedEvent += Connected; listener.PeerDisconnectedEvent += Disconnected; listener.NetworkReceiveEvent += ReceivedNetworkData; client = new NetManager(listener) { UpdateTime = 15, UnsyncedEvents = true, //experimental feature, may need to replace with calls to client.PollEvents(); #if DEBUG DisconnectTimeout = 300000 //Disables Timeout (for 5 min) for debug purpose (like if you jump though the server code) #endif }; client.Start(); client.Connect(ipAddress, serverPort, "nitrox"); connectedEvent.WaitOne(2000); connectedEvent.Reset(); }
public EchoClient(int id, Configuration config, BenchmarkStatistics benchmarkStatistics) : base(config) { this.id = id; this.config = config; this.benchmarkStatistics = benchmarkStatistics; deliveryMethod = LiteNetLibBenchmark.GetDeliveryMethod(config.Transmission); listener = new EventBasedNetListener(); netManager = new NetManager(listener); if (!config.Address.Contains(':')) { // For LiteNetLib 1.0 and above //netManager.IPv6Mode = IPv6Mode.Disabled; // LiteNetLib up to 0.9.4 netManager.IPv6Enabled = IPv6Mode.Disabled; } netManager.UpdateTime = Utilities.CalculateTimeout(config.ClientTickRate); netManager.UnsyncedEvents = true; netManager.DisconnectTimeout = 10000; isConnected = false; isDisposed = false; listener.PeerConnectedEvent += OnPeerConnected; listener.PeerDisconnectedEvent += OnPeerDisconnected; listener.NetworkReceiveEvent += OnNetworkReceive; listener.NetworkErrorEvent += OnNetworkError; }
public static void TryConnect(IPAddress address, int port) { EventBasedNetListener listener = new EventBasedNetListener(); Multiplayer.session = new MultiplayerSession(); NetManager netClient = new NetManager(listener); netClient.Start(); netClient.ReconnectDelay = 300; netClient.MaxConnectAttempts = 8; listener.PeerConnectedEvent += peer => { IConnection conn = new MpNetConnection(peer); conn.username = Multiplayer.username; conn.State = ConnectionStateEnum.ClientJoining; Multiplayer.session.client = conn; MpLog.Log("Net client connected"); }; listener.PeerDisconnectedEvent += (peer, info) => { string reason; if (info.AdditionalData.AvailableBytes > 0) { reason = info.AdditionalData.GetString(); } else { reason = DisconnectReasonString(info.Reason); if (info.SocketErrorCode != SocketError.Success) { reason += ": " + info.SocketErrorCode; } } Multiplayer.session.disconnectNetReason = reason; ConnectionStatusListeners.TryNotifyAll_Disconnected(); OnMainThread.StopMultiplayer(); MpLog.Log("Net client disconnected"); }; listener.NetworkReceiveEvent += (peer, reader, method) => { byte[] data = reader.GetRemainingBytes(); Multiplayer.HandleReceive(new ByteReader(data), method == DeliveryMethod.ReliableOrdered); }; listener.NetworkErrorEvent += (endpoint, error) => { Log.Warning($"Net client error {error}"); }; Multiplayer.session.netClient = netClient; netClient.Connect(address.ToString(), port, ""); }
public ServerBrowser() { EventBasedNetListener listener = new EventBasedNetListener(); listener.NetworkReceiveUnconnectedEvent += (endpoint, data, type) => { if (type != UnconnectedMessageType.DiscoveryRequest) { return; } string s = Encoding.UTF8.GetString(data.GetRemainingBytes()); if (s == "mp-server") { AddOrUpdate(endpoint); } }; net = new NetManager(listener); net.DiscoveryEnabled = true; net.ReuseAddress = true; net.Start(5100); doCloseX = true; closeOnAccept = false; }
private void InitEvents() { _listener = new EventBasedNetListener(); _listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => { _peer.HandleDataReceived(dataReader.GetRemainingBytes(), 0); dataReader.Recycle(); }; _listener.PeerConnectedEvent += (peer) => { Status = EConnectionStatus.Connected; var pe = new PeerLn(peer); pe.SetConnectedState(true); pe.MessageReceived += HandleMessage; _peer = pe; Peer = pe; Connected?.Invoke(); }; _listener.PeerDisconnectedEvent += (peer, disconnectInfo) => { if (Peer != null) { Peer.MessageReceived -= HandleMessage; } _peer?.SetConnectedState(false); Status = EConnectionStatus.Disconnected; Disconnected?.Invoke(); }; _netManager = new NetManager(_listener) { DisconnectTimeout = 300000 }; _netManager.Start(); }
public void Start(string ipaddress, int port) { listener = new EventBasedNetListener(); clientUDP = new NetManager(listener, "ConnectionKey"); clientUDP.UnsyncedEvents = true; clientUDP.Start(); clientUDP.Connect(ipaddress, port); listener.PeerDisconnectedEvent += (c, i) => { Client client = GetClientRecord(c); onDisconnectCallBack.Invoke(client); }; listener.PeerConnectedEvent += c => { Client client = new Client(c.EndPoint.Host, c.EndPoint.Port); ClientToNetPeerMap.Add(client, c); onConnectCallBack?.Invoke(client); }; listener.NetworkReceiveEvent += (fromPeer, dataReader) => { Client client = GetClientRecord(fromPeer); var payload = dataReader.GetString(); ReceivedMessage receivedMessage = new ReceivedMessage(client, payload); onReceiveCallback.Invoke(receivedMessage); }; clientUDP.PollEvents(); WaitTillConnectionMade(); this._LocalPort = clientUDP.LocalPort; }
public ServerBrowser() { EventBasedNetListener listener = new EventBasedNetListener(); listener.NetworkReceiveUnconnectedEvent += (endpoint, data, type) => { if (type != UnconnectedMessageType.DiscoveryRequest) { return; } string s = Encoding.UTF8.GetString(data.GetRemainingBytes()); if (s == "mp-server") { AddOrUpdate(endpoint); } }; byte ipSupport = 0; IPAddress[] allIPs = Dns.GetHostAddresses(Dns.GetHostName()); foreach (IPAddress ip in allIPs) { switch (ip.AddressFamily) { case AddressFamily.InterNetworkV6: ipSupport &= 1; break; case AddressFamily.InterNetwork: ipSupport &= 2; break; } } net = new NetManager(listener) { DiscoveryEnabled = true, ReuseAddress = true }; if ((ipSupport | 3) == 3) { Log.Message($"Starting with DualStack"); net.Start(5100); } else if ((ipSupport | 1) == 1 && (ipSupport | 2) == 0) { Log.Message($"Starting with IPv4 only"); net.Start(IPAddress.Any, IPAddress.IPv6None, 5100); } else if ((ipSupport | 1) == 0 && (ipSupport | 2) == 2) { Log.Message($"Starting with IPv6 only"); net.Start(IPAddress.None, IPAddress.IPv6Any, 5100); } doCloseX = true; closeOnAccept = false; }
internal static void ConnectClient(string code) { try { if (LiteNetLib4MirrorCore.State == LiteNetLib4MirrorCore.States.Discovery) { LiteNetLib4MirrorCore.StopTransport(); } EventBasedNetListener listener = new EventBasedNetListener(); LiteNetLib4MirrorCore.Host = new NetManager(listener); listener.NetworkReceiveEvent += OnNetworkReceive; listener.NetworkErrorEvent += OnNetworkError; listener.PeerConnectedEvent += OnPeerConnected; listener.PeerDisconnectedEvent += OnPeerDisconnected; LiteNetLib4MirrorCore.SetOptions(false); LiteNetLib4MirrorCore.Host.Start(); LiteNetLib4MirrorCore.Host.Connect(LiteNetLib4MirrorUtils.Parse(LiteNetLib4MirrorTransport.Singleton.clientAddress, LiteNetLib4MirrorTransport.Singleton.port), code); LiteNetLib4MirrorTransport.Polling = true; LiteNetLib4MirrorCore.State = LiteNetLib4MirrorCore.States.ClientConnecting; } catch (Exception ex) { LiteNetLib4MirrorCore.State = LiteNetLib4MirrorCore.States.Idle; LiteNetLib4MirrorUtils.LogException(ex); } }
public void Start(string ipaddress, int port) { listener = new EventBasedNetListener(); //Create a new server and only allow 32 connections server = new NetManager(listener, 32, "ConnectionKey"); server.UnsyncedEvents = true; server.Start(port); LocalPort = server.LocalPort; listener.PeerDisconnectedEvent += (c, i) => { Client client = GetClientRecord(c); onDisconnectCallBack?.Invoke(client); }; listener.PeerConnectedEvent += c => { Client client = new Client(c.EndPoint.Host, c.EndPoint.Port); ClientToNetPeerMap.Add(client, c); onConnectCallBack?.Invoke(client); }; listener.NetworkReceiveEvent += (fromPeer, dataReader) => { Client client = GetClientRecord(fromPeer); var payload = dataReader.GetString(); ReceivedMessage receivedMessage = new ReceivedMessage(client, payload); onReceiveCallback.Invoke(receivedMessage); }; }
public void Server() { EventBasedNetListener listener = new EventBasedNetListener(); NetManager server = new NetManager(listener); server.Start(9050 /* port */); listener.ConnectionRequestEvent += request => { if (server.ConnectedPeersCount < 10 /* max connections */) { request.AcceptIfKey("SomeConnectionKey"); } else { request.Reject(); } }; listener.PeerConnectedEvent += peer => { Console.WriteLine("We got connection: {0}", peer.EndPoint); // Show peer ip NetDataWriter writer = new NetDataWriter(); // Create writer class writer.Put("Hello client!"); // Put some string peer.Send(writer, DeliveryMethod.ReliableOrdered); // Send with reliability }; while (!Console.KeyAvailable) { server.PollEvents(); Thread.Sleep(15); } server.Stop(); }
public bool Start(NewPlayerInfo playerInfo, int port) { listener = new EventBasedNetListener(); server = new NetManager(listener); localPacketProcessor = new NetPacketProcessor(); Console.WriteLine("started instances..."); localPacketProcessor.SubscribeReusable <ZeroGPacket, NetPeer>(OnDataRecieve); if (!server.Start(port)) { Console.WriteLine("Failed to start server"); //return false; throw new Exception("Failed to start server..."); } newPlayerData = playerInfo; listener.ConnectionRequestEvent += Listener_ConnectionRequestEvent; listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent; listener.PeerConnectedEvent += Listener_PeerConnectedEvent; listener.PeerDisconnectedEvent += Listener_PeerDisconnectedEvent; zeroPacketProcessor = new ProcessPacket(); InstanceKeeper.SetServerinstance(this); GetEvents(); // while (/*!Console.KeyAvailable*/1-1==0) //{ // server.PollEvents(); // Thread.Sleep(15); // } // this.server.Stop(); return(true); }
public void Start() { listener = new EventBasedNetListener(); listener.PeerConnectedEvent += (peer) => { Console.WriteLine("[DEBUG] Connected peer"); SetState(State.Online); }; listener.PeerDisconnectedEvent += (peer, disconnetInfo) => { Console.WriteLine( "Disconnected: {0}, Reason: {1}", peer.EndPoint, disconnetInfo.Reason ); SetState(State.Offline); }; listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => { packetProcessor.ReadAllPackets(dataReader, fromPeer); }; client = new NetManager(listener); client.Start(); }
void UpdateNetwork() { networkListener = new EventBasedNetListener(); networkListener.NetworkReceiveEvent += ReceivePackage; client = new NetManager(networkListener); client.Start(); client.Connect("localhost", 9050, "SomeConnectionKey"); NetDataWriter writer = new NetDataWriter(); while (true) { foreach (var obj in NetworkObjects) { if (obj.Value.networkId == MyNetworkId) { if (!obj.Value.CheckChanges()) { writer.Reset(); obj.Value.WriteData(writer); Send(writer, DeliveryMethod.Unreliable); } } } client.PollEvents(); Thread.Sleep(16); } client.Stop(); }
public RUdp() : base(NetworkProtocol.RUDP) { listener = new EventBasedNetListener(); client = new NetManager(listener) { DisconnectTimeout = 20 * 1000 }; client.UpdateTime = 15; listener.PeerConnectedEvent += (NetPeer peer) => { LogProxy.WriteLine("Connect Success : " + peer.EndPoint); this.peer = peer; fireCompleteConnect(); }; listener.PeerDisconnectedEvent += (NetPeer peer, DisconnectInfo disconnectInfo) => { client.Flush(); client.Stop(); fireCompleteDisconnect(); }; listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => { byte[] packet = new byte[dataReader.AvailableBytes]; dataReader.GetBytes(packet, dataReader.AvailableBytes); fireCompleteReadFromServerStream(packet); dataReader.Recycle(); }; }
private NetManager ListenServer() { var listener = new EventBasedNetListener(); listener.ConnectionRequestEvent += OnConnectionRequestEvent; listener.PeerConnectedEvent += OnConnectedEvent; listener.PeerDisconnectedEvent += OnDisconnectedEvent; listener.NetworkReceiveEvent += OnNetworkReceiveEvent; var server = new NetManager(listener); for (var i = 0; i < 10; i++) { if (!server.Start()) { continue; } // 10000 - 60000 の範囲外の場合は再度ポートを割り当ててみる var port = server.LocalPort; if (10000 <= port && port <= 60000) { break; } _logger.InfoFormat("out of port range: {0}, restart server", port); server.Stop(); } return(server); }
public static void Start() { listener = new EventBasedNetListener(); server = new NetManager(listener); server.AutoRecycle = true; server.DiscoveryEnabled = true; server.UnconnectedMessagesEnabled = true; for (int i = 0; i < LANDiscoveryConstants.BROADCAST_PORTS.Length; i++) { if (server.Start(LANDiscoveryConstants.BROADCAST_PORTS[i])) { break; } } listener.NetworkReceiveUnconnectedEvent += NetworkReceiveUnconnected; pollTimer = new Timer((state) => { server.PollEvents(); }); pollTimer.Change(0, 100); }
private NetManager GetListener() { var listener = new EventBasedNetListener(); listener.NetworkErrorEvent += (point, error) => { Console.WriteLine("err: {0}", error.ToString()); _isRunning = false; }; listener.PeerDisconnectedEvent += (peer, info) => { Console.WriteLine("info: {0}", info.Reason); _isRunning = false; }; listener.NetworkReceiveEvent += (peer, reader, method) => { var json = reader.GetString(); var msg = Message.FromString(json); Console.WriteLine(); Console.WriteLine($"({msg.Name})>> {msg.Body}"); Console.Write(">> "); reader.Recycle(); }; var client = new NetManager(listener); client.Start(); return(client); }
public void StartClientConnection() { //Listener es el encargado de gestionar todos los paquetes recibidos netListenerClient = new EventBasedNetListener(); //Packet processor es el encargado de procesar los paquetes creados por nosotros, pudiendo leerlos y enviarlos netPacketProcessorClient = new NetPacketProcessor(); //Manager es donde tenemos todos los datos de la conexion, como el peer netManagerClient = new NetManager(netListenerClient); //netManagerServer.NatPunchEnabled = true; //Evento recibido al conectarse al servidor netListenerClient.PeerConnectedEvent += (server) => { Debug.Log("Connected to server: " + server); }; //Evento estandar, cualquier que no es especial como conectarse, desconectarse o ping netListenerClient.NetworkReceiveEvent += (server, reader, deliveryMethod) => { //Lee los paquetes recibidos y llama a los listeners de cada paquete de los que haya recibido netPacketProcessorClient.ReadAllPackets(reader, server); }; //Aqui estaran todos los listeners necesarios para cada paquete RegisterPacketsListeners(); netManagerClient.Start(); netManagerClient.Connect(ip, port, connectionKey); }
public void Initialize() { EventBasedNetListener listener = new EventBasedNetListener(); listener.NetworkReceiveUnconnectedEvent += OnNetworkReceiveUnconnected; // TODO: make this a function of the class listener.ConnectionRequestEvent += request => { if (server.ConnectedPeersCount < serverSettings.MaxPlayers && serverState.ServerMode.Value == ServerState.Mode.WAITING) { request.AcceptIfKey(serverSettings.Key); } else { request.Reject(); } }; listener.PeerConnectedEvent += OnPlayerConnected; listener.PeerDisconnectedEvent += OnPlayerDisconnected; listener.NetworkReceiveEvent += OnNetworkReceive; server = new NetManager(listener); server.BroadcastReceiveEnabled = true; server.Start(serverSettings.Port); Debug.Log($"Local server started on port {serverSettings.Port}"); }