private void client_CloseRoom(CloseRoomPacket packet)
{
WriteToLog(packet.Message);
ClearRoomChat();
ToggleRoomTab(false);
SwitchToTab(tabPageRooms);
}
private void Listener(TcpClient tcpClient)
{
try
{
using (Stream stream = tcpClient.GetStream())
{
while (true)
{
BinaryReader streamReader = new BinaryReader(stream);
PacketType packetType = (PacketType)streamReader.ReadInt32();
switch (packetType)
{
case PacketType.Registry:
RegistryPacket registryPacket = new RegistryPacket(stream);
registryPacket.Receive();
RegistryNewUser(tcpClient, registryPacket);
break;
case PacketType.Login:
LoginPacket loginPacket = new LoginPacket(stream);
loginPacket.Receive();
if (!LoginUser(tcpClient, loginPacket))
{
return;
}
break;
case PacketType.SimpleMessage:
SimpleMessagePacket simpleMessagePacket = new SimpleMessagePacket(stream);
simpleMessagePacket.Receive();
lock (_connectedUsers)
{
foreach (TcpClient client in _connectedUsers.Values)
{
simpleMessagePacket.Send(client.GetStream());
}
}
break;
case PacketType.Disconnect:
lock (_connectedUsers)
{
var item = _connectedUsers.First(u => u.Value == tcpClient);
_connectedUsers.Remove(item.Key);
}
return;
case PacketType.UserDisconnect:
UserDisconnectPacket userDisconnectPacket = new UserDisconnectPacket(stream);
userDisconnectPacket.Receive();
lock (_connectedUsers)
{
foreach (TcpClient client in _connectedUsers.Values)
{
userDisconnectPacket.Send(client.GetStream());
}
}
lock (_connectedUsers)
{
_connectedUsers.Remove(userDisconnectPacket.UserLogin);
_context.Send(p => ClientDisconnected?.Invoke(this, new DisconnectedEventHandlerArgs(tcpClient, userDisconnectPacket.UserLogin)), null);
}
return;
case PacketType.CreateNewRoom:
lock (_rooms)
{
CreateNewRoomPacket createNewRoomPacket = new CreateNewRoomPacket(stream);
createNewRoomPacket.Receive();
_rooms.Add(createNewRoomPacket.Room.Id, createNewRoomPacket.Room);
lock (_connectedUsers)
{
foreach (var connectedUser in _connectedUsers.Where(cu =>
createNewRoomPacket.Room.Members.Contains(cu.Key)))
{
createNewRoomPacket.Send(connectedUser.Value.GetStream());
}
}
}
break;
case PacketType.CloseRoom:
CloseRoomPacket closeRoomPacket = new CloseRoomPacket(stream);
closeRoomPacket.Receive();
lock (_rooms)
{
Room room;
if (_rooms.TryGetValue(closeRoomPacket.RoomId, out room))
{
lock (_connectedUsers)
{
foreach (TcpClient client in _connectedUsers.Where(u =>
room.Members.Contains(u.Key)).Select(u => u.Value))
{
new RemoveUserFromRoomPacket(client.GetStream(), closeRoomPacket.RoomId, closeRoomPacket.User).Send();
}
}
}
}
break;
case PacketType.UpdateUser:
UpdateUserPacket updateUserPacket = new UpdateUserPacket(stream);
updateUserPacket.Receive();
UserManager.Instance.Update(updateUserPacket.Login, updateUserPacket.UserInfoWithPrivateInfo);
break;
}
}
}
}
catch (Exception ex)
{
_context.Post(p => ErrorOccurred?.Invoke(this, new ErrorOccurredEventHandlerArgs(ex.Message, ErrorType.ServerListener)), null);
}
}
private void Client_CloseRoom(CloseRoomPacket packet)
{
User.Room = null;
}
