void Start()
{
m_ChatBoxTxt.text = "....";
m_SendBtn.onClick.RemoveAllListeners();
m_SendBtn.onClick.AddListener(() => {
if (string.IsNullOrEmpty(m_ChatEditBox.text))
{
Debug.LogWarning("Empty field!!");
return;
}
Debug.Log("Send btn clicked::");
SimpleMessagePacket smp = new SimpleMessagePacket();
smp.msg = m_ChatEditBox.text;
smp.fromIP = LobbyManager.HOST_IP;
smp.fromName = LobbyManager.HOST_NAME;
mPlayerSocket?.Send(JsonUtility.ToJson(smp));
});
}
private void OnSimpleMessageReceived(SimpleMessagePacket simpleMessagePacket)
{
_context.Post(p => SimpleMessageReceived?.Invoke(this,
new SimpleMessageRecivedEventHandlerArgs(simpleMessagePacket.Room, simpleMessagePacket.UserLogin, simpleMessagePacket.DateTime, simpleMessagePacket.Message)), null);
}
/// <summary>
/// Read and prosess data from stream
/// </summary>
private void ClientStreamReadData()
{
try
{
using (Stream stream = _server.GetStream())
{
BinaryReader streamReader = new BinaryReader(stream);
while (true)
{
PacketType packetType = (PacketType)streamReader.ReadInt32();
switch (packetType)
{
case PacketType.Negotiation:
NegotiationPacket negotiationPacket = new NegotiationPacket(stream);
negotiationPacket.Receive();
Login = negotiationPacket.Login;
_loginEvents[0].Set();
_registerEvents[0].Set();
lock (_rooms)
{
Room mainRoom = new Room(Room.MainRoomId, Room.MainRoomName, new HashSet <string>());
_rooms.Add(Room.MainRoomId, mainRoom);
}
_context.Post(p => NegotiationCompleted?.Invoke(this, EventArgs.Empty), null);
break;
case PacketType.SimpleMessage:
SimpleMessagePacket simpleMessagePacket = new SimpleMessagePacket(stream);
simpleMessagePacket.Receive();
OnSimpleMessageReceived(simpleMessagePacket);
break;
case PacketType.Error:
ErrorPacket errorPacket = new ErrorPacket(stream);
errorPacket.Receive();
_context.Post(p => ErrorOccurred?.Invoke(this, new ErrorOccurredEventHandlerArgs(errorPacket.ErrorMessage, errorPacket.ErrorType)), null);
break;
case PacketType.UserConnect:
UserConnectPacket userConnectPacket = new UserConnectPacket(stream);
userConnectPacket.Receive();
lock (_users)
{
_users[userConnectPacket.UserLogin] = userConnectPacket.UserInfo;
}
_context.Post(p => UserConnected?.Invoke(this, new UserConnectedEventHandlerArgs(userConnectPacket.UserLogin, userConnectPacket.UserInfo)), null);
break;
case PacketType.UserDisconnect:
UserDisconnectPacket userDisconnectPacket = new UserDisconnectPacket(stream);
userDisconnectPacket.Receive();
lock (_users)
{
_users.Remove(userDisconnectPacket.UserLogin);
}
_context.Post(p => UserDisconnected?.Invoke(this, new UserDisconnectedEventHandlerArgs(userDisconnectPacket.UserLogin)), null);
break;
case PacketType.CreateNewRoom:
CreateNewRoomPacket createNewRoomPacket = new CreateNewRoomPacket(stream);
createNewRoomPacket.Receive();
lock (_rooms)
{
_rooms.Add(createNewRoomPacket.Room.Id, createNewRoomPacket.Room);
}
_context.Post(p => NewRoomCreated?.Invoke(this, new NewRoomCreatedEventHandlerArgs(createNewRoomPacket.Room)), null);
break;
case PacketType.AddUserToRoom:
AddUsersToRoomPacket addUsersToRoomPacket = new AddUsersToRoomPacket(stream);
addUsersToRoomPacket.Receive();
lock (_rooms)
{
foreach (string user in addUsersToRoomPacket.Users)
{
_rooms[addUsersToRoomPacket.RoomId].Members.Add(user);
}
}
_context.Post(p => RoomsUpdated?.Invoke(this, new RoomsUpdatedEventHandlerArgs()), null);
break;
case PacketType.RemoveUserFromRoom:
RemoveUserFromRoomPacket removeUserFromRoomPacket = new RemoveUserFromRoomPacket(stream);
removeUserFromRoomPacket.Receive();
lock (_rooms)
{
Room room;
if (_rooms.TryGetValue(removeUserFromRoomPacket.RoomId, out room))
{
room.Members.Remove(removeUserFromRoomPacket.User);
}
}
_context.Post(p => RoomsUpdated?.Invoke(this, new RoomsUpdatedEventHandlerArgs()), null);
break;
}
}
}
}
catch (Exception)
{
_server.Close();
_server.Client.Dispose();
}
}
public void PassMessage(string _smpStr)
{
SimpleMessagePacket smp = JsonUtility.FromJson <SimpleMessagePacket> (_smpStr);
m_ChatBox.AddToBox("<size=26><color=#51FF15>" + smp.fromName + " said : </size></color> <b>" + smp.msg + "</b>");
}
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);
}
}
