public void Close() { _peer.Stop(); _peer.DisconnectAll(); _serverPeer?.Disconnect(); _endPointReceivers.Clear(); }
protected override void SendClose(ArraySegment <byte> payload) { if (payload.Array != null) { _peer.Disconnect(payload.Array, payload.Offset, payload.Count); return; } _peer.Disconnect(); }
public override void QuitRoom() { if (isHost) { if (_hostRoomData == null) { log?.logWarn("尝试退出一个不存在的房间"); return; } // 主机退出了,和所有其他玩家断开连接,然后广播房间没了 foreach (var peer in _playerInfoDict.Values.Select(i => i.peer)) { peer.Disconnect(); } _playerInfoDict.Clear(); invokeBroadcast(nameof(ILANRPCMethodClient.removeDiscoverRoom), _hostRoomData.ID); _hostRoomData = null; } else { if (cachedRoomData == null) { log?.logWarn("尝试退出一个不存在的房间"); return; } // 是其他玩家,直接断开连接 hostPeer.Disconnect(); hostPeer = null; cachedRoomData = null; } }
void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) { var client = clients[peer.Id]; Console.WriteLine($"Message received from client({client.Id})"); // 処理 try { var message = MessagePackSerializer.Deserialize <Shared.IClientMsg>(reader.GetRemainingBytesSegment()); switch (message) { case IClientMsg.PlayerAction m: gameState.PlayerACtion(client.Id, m.Value); break; default: break; } } catch (MessagePackSerializationException e) { Console.WriteLine($"{e.Message}"); peer.Disconnect(); } reader.Recycle(); }
void startMatch() { try { manager = new MatchManager(player1DeckStaging, player2DeckStaging); } catch (ArgumentException e) { Console.Error.WriteLine(e.Message); var message = new ErrorMessagePacket("server received invalid deck"); sendToBoth(message, DeliveryMethod.ReliableOrdered); player1Peer.Disconnect(); player2Peer.Disconnect(); } manager.Start(); sendToBoth(manager, DeliveryMethod.ReliableOrdered); PacketProcessor.Send <Player1SignalPacket>(player1Peer, DeliveryMethod.ReliableOrdered); PacketProcessor.Send <Player2SignalPacket>(player2Peer, DeliveryMethod.ReliableOrdered); }
public void Disconect() { connected = false; server.Disconnect(); client.Stop(); connectionThread.Abort(); }
public void Kick(int playerId) { NetPeer peer = Players.FirstOrDefault(p => p.Id == playerId); peer.Disconnect(NetConstants.GetKeyValue(NetKey.Kicked)); Players.Remove(peer); Log.Information("Kicked player '{name}' at {endPoint}", peer.Tag, peer.EndPoint); }
public void Drop(string reason) { NetDataWriter writer = new NetDataWriter(); writer.Put((byte)NetTypes.Goodbye); writer.Put(reason); peer.Send(writer, DeliveryMethod.ReliableOrdered); peer.Disconnect(); }
public void Dispose() { _maintainConnecting.Stop(); if (_netPeer.ConnectionState == ConnectionState.Connected) { _netPeer.Disconnect(); } _ClientNode.OnDisconnect(); }
public override void DisconnectClient() { if (!IsConnected) { return; } // Run in own task to not block the main thread Task.Factory.StartNew(() => { peer.Disconnect(); }, TaskCreationOptions.LongRunning); }
public void OnNetworkReceive(NetPeer peer, NetDataReader reader, DeliveryMethod deliveryMethod) { if (peer.ConnectionState == ConnectionState.Connected) { try { _netPacketProcessor.ReadAllPackets(reader, peer); } catch (ParseException ex) { Logger.Warn("OnNetworkReceive {0}: {1} Data {2}", peer.EndPoint.ToString(), ex.Message, reader.Data.HexDump()); peer.Disconnect(); } catch (Exception ex) { Logger.Warn(ex, "OnNetworkReceive {0}", peer.EndPoint.ToString()); peer.Disconnect(); } } }
public Task Disconnect() { if (!IsConnected) { return(Task.CompletedTask); } var clientDisconnected = Task.Factory.StartNew(() => { peer.Disconnect(); }, TaskCreationOptions.LongRunning); return(clientDisconnected); }
public void OnDisconnect() { Logger.InfoFormat("LiteNetPeer.OnDisconnect {0}", ConnectId); if (!_connected) { return; } _connected = false; _peer.Disconnect(); }
public static void Kick(NetPeer peer, string reason) { if (InstanceType != NetInstanceType.Server || peer == null) { return; } NetDataWriter writer = new NetDataWriter(); writer.Put(reason); peer.Disconnect(writer); LogInfo("Kicked peer " + peer.EndPoint + ". Reason: '" + reason + "'"); }
private void Listener_NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) { var pl = peer.Tag as ServerPlayer; if (pl == null) { Debug.LogError("ServerPlayer tag is undefined on receive event, disconnecting peer."); peer.Disconnect(); return; } _readBuffer.LengthBytes = reader.UserDataSize; _readBuffer.Position = 0; reader.GetBytes(_readBuffer.Data, reader.UserDataSize); SocketMan.HandleIncomingData2(pl.ClientIndex, _readBuffer); reader.Recycle(); }
void INetEventListener.OnPeerConnected(NetPeer peer) { int i = 0; while (i < this._pendingConnections.Count) { if (this._pendingConnections[i].netPeer == peer) { LiteNetLibConnectionManager.NetPeerConnection netPeerConnection = this._pendingConnections[i]; this._pendingConnections.RemoveAt(i); for (int j = 0; j < this._connections.Count; j++) { if (this._connections[j].userId == netPeerConnection.userId) { netPeerConnection.Disconnect(); return; } } this._connections.Add(netPeerConnection); if (this._connectionState == LiteNetLibConnectionManager.ConnectionState.Connecting) { this._connectionState = LiteNetLibConnectionManager.ConnectionState.Connected; Action action = this.onConnectedEvent; if (action != null) { action(); } } if (this.isRelay && netPeerConnection.isConnectionOwner) { this.AcceptAllPendingRequests(); } Action <IConnection> action2 = this.onConnectionConnectedEvent; if (action2 == null) { return; } action2(netPeerConnection); return; } else { i++; } } peer.Disconnect(); }
public bool Disconnect(int hostId, int connectionId, out byte error) { // Sends a disconnect signal to the connected peer and closes the connection. if (!connections.ContainsKey(hostId)) { error = (byte)NetworkError.WrongHost; return(false); } if (!connections[hostId].TryGetValue(connectionId, out tempPeer)) { error = (byte)NetworkError.WrongConnection; return(false); } error = (byte)NetworkError.Ok; tempPeer.Disconnect(); return(true); }
public void Disconnect() { var groupArray = groups.ToArray(); foreach (var group in groupArray) { UntrackGroup(group); } // positively disconnect only if peer is connected if (isConnected) { peer.Disconnect(); } if (OnPeerDisconnected != null) { OnPeerDisconnected.Invoke(this); } }
public void DisconnectFromClientTest() { NetManager server = ManagerStack.Server(1); NetManager client = ManagerStack.Client(1); var clientDisconnected = false; var serverDisconnected = false; ManagerStack.ClientListener(1).PeerDisconnectedEvent += (peer, info) => { Assert.AreEqual(DisconnectReason.DisconnectPeerCalled, info.Reason); Assert.AreEqual(0, client.ConnectedPeersCount); clientDisconnected = true; }; ManagerStack.ServerListener(1).PeerDisconnectedEvent += (peer, info) => { Assert.AreEqual(DisconnectReason.RemoteConnectionClose, info.Reason); serverDisconnected = true; }; NetPeer serverPeer = client.Connect("127.0.0.1", DefaultPort, DefaultAppKey); while (server.ConnectedPeersCount != 1) { Thread.Sleep(15); server.PollEvents(); } //User server peer from client serverPeer.Disconnect(); while (!(clientDisconnected && serverDisconnected)) { Thread.Sleep(15); client.PollEvents(); server.PollEvents(); } Assert.True(clientDisconnected); Assert.True(serverDisconnected); Assert.AreEqual(0, server.ConnectedPeersCount); Assert.AreEqual(0, client.ConnectedPeersCount); }
public override void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) { NebulaUser user = GetUser(peer.Id); if (user == null) { peer.Disconnect(NetDataWriter.FromString("User not registered server side")); WriteLine($"Received packet from '{peer.EndPoint.Address}:{peer.EndPoint.Port}' but the user is not registered.", ConsoleColor.Red); return; } try { PacketProcessor.ReadAllPackets(reader, user); } catch { HandleBadPacket(user); } }
void handlePeerConnected(NetPeer peer) { if (player1Peer == null) { player1Peer = peer; } else if (player2Peer == null) { player2Peer = peer; } else { Console.Error.WriteLine($"unexpected third peer connected at endpoint {peer.EndPoint}"); peer.Disconnect(); return; } Console.WriteLine(nicePeerString(peer) + " has connected"); PacketProcessor.Send <ServerReadyToReceiveDeckSignalPacket>(peer, DeliveryMethod.ReliableOrdered); Console.WriteLine("now waiting for their deck..."); }
private void OnConnectedEvent(NetPeer peer) { if (!_peerList.Add(peer)) { peer.Disconnect(); } _logger.InfoFormat("connected: {0}", peer.EndPoint); if (_peerList.IsEmpty()) { return; } var json = CreateAdminMessage($"[{peer.EndPoint}]さんが入りました").Serialize(); var w = new NetDataWriter(); _peerList.ForEach(p => { w.Reset(); w.Put(json); p.Send(w, DeliveryMethod.ReliableOrdered); }); }
public void DisconnectFromClientTest() { NetManager server = ManagerStack.Server(1); NetManager client = ManagerStack.Client(1); var clientDisconnected = false; var serverDisconnected = false; ManagerStack.ClientListener(1).PeerDisconnectedEvent += (peer, info) => { clientDisconnected = true; }; ManagerStack.ServerListener(1).PeerDisconnectedEvent += (peer, info) => { serverDisconnected = true; }; NetPeer serverPeer = client.Connect("127.0.0.1", DefaultPort, DefaultAppKey); while (server.PeersCount != 1) { Thread.Sleep(15); server.PollEvents(); } //User server peer from client serverPeer.Disconnect(); while (!(clientDisconnected && serverDisconnected)) { Thread.Sleep(15); client.PollEvents(); server.PollEvents(); } // Wait that server remove disconnected peers Thread.Sleep(100); Assert.True(clientDisconnected); Assert.True(serverDisconnected); Assert.AreEqual(0, server.PeersCount); Assert.AreEqual(0, client.PeersCount); }
private void peerDisconnect(NetPeer peer, NetCloseReason reason) { ExitMsg = reason.ToLocal("msg"); peer.Disconnect(createDCMsg((int)reason)); }
public void SendDisconnectPacket() { peer.Disconnect(); }
public void Disconnect() { NetPeer.Disconnect(string.Empty); }
public static void Disconnect(NetPeer peer) { peer.Disconnect(); }
public void NetworkReceived(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) { try { if (connectionActive(peer)) { string uuid = clientIDs.Forward[peer.Id]; string partnerUuid = activeConnections[uuid]; long partnerID = clientIDs.Reverse[partnerUuid]; NetPeer partnerPeer = peers[partnerID]; NetDataWriter writer = new NetDataWriter(); writer.Put(reader.GetRemainingBytes()); partnerPeer.Send(writer, DeliveryMethod.ReliableOrdered); } else { int packetId = reader.GetInt(); string uuid = reader.GetString(); byte[] data = reader.GetBytesWithLength(); int activity = reader.GetInt(); string toUuid = reader.GetString(); int toActivity = reader.GetInt(); //stop the connection if it's not CLIENT_INFO if (packetId != CLIENT_INFO) { peer.Disconnect();//bad packet! } else if (clientIDs.Reverse.Contains(uuid)) { peer.Disconnect(createDCMsg(DC_CODE_ALREADY_CONNECTED)); } else { clientIDs.Add(peer.Id, uuid); info.Add(uuid, new ClientInfo(data, activity, toActivity)); if (searchingConnections.ContainsKey(toUuid)) { searchingConnections.Remove(toUuid); activeConnections.Add(uuid, toUuid); activeConnections.Add(toUuid, uuid); ClientInfo selfInfo = info[uuid]; ClientInfo partnerInfo = info[toUuid]; long partnerID = clientIDs.Reverse[toUuid]; NetPeer partnerPeer = peers[partnerID]; if (selfInfo.Activity != partnerInfo.ToActivity || selfInfo.ToActivity != partnerInfo.Activity) { peer.Disconnect(createDCMsg(DC_CODE_DIFFERENT_ACTIVITY)); partnerPeer.Disconnect(createDCMsg(DC_CODE_DIFFERENT_ACTIVITY)); } else { { NetDataWriter writer = new NetDataWriter(); writer.Put(SERVER_CONNECTED); writer.PutBytesWithLength(partnerInfo.Data); peer.Send(writer, DeliveryMethod.ReliableOrdered); } { NetDataWriter writer = new NetDataWriter(); writer.Put(SERVER_CONNECTED); writer.PutBytesWithLength(selfInfo.Data); partnerPeer.Send(writer, DeliveryMethod.ReliableOrdered); } } } else { searchingConnections.Add(uuid, toUuid); } } } reader.Recycle(); } catch (Exception ex) { DiagManager.Instance.LogError(ex); } }
public void Disconnect() { //TODO: Create a disconnectReason packet type so the users know why the server disconnected them peer.Disconnect(); }
public override void Disconnect(string reason) { _peer.Disconnect(); }