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();
}
