//ErrorMessagePacket
private static void HandlePacket(ErrorMessagePacket packet)
{
Fade.FadeIn();
Globals.WaitingOnServer = false;
Interface.Interface.MsgboxErrors.Add(new KeyValuePair <string, string>(packet.Header, packet.Error));
Interface.Interface.MenuUi.Reset();
}
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);
}
void TcpClientMethod(int index)
{
Console.WriteLine("Socket opened. (" + _tcpListener.ToString() + ")");
Packet receivedPacket;
Client client = _clients[index];
try {
while ((receivedPacket = client.TcpRead()) != null)
{
Console.Write("TCP Receieved: ");
// act on packet type
switch (receivedPacket._packetType)
{
case Packet.PacketType.EMPTY:
Console.WriteLine("EMPTY");
/* do nothing */
break;
case Packet.PacketType.CHATMESSAGE:
Console.WriteLine("CHAT");
TcpRespondToAll((ChatMessagePacket)receivedPacket, client);
break;
case Packet.PacketType.PRIVATEMESSAGE:
Console.WriteLine("PRIVATE");
TcpRespondTo((PrivateMessagePacket)receivedPacket, client);
break;
case Packet.PacketType.SERVERMESSAGE:
Console.WriteLine("SERVER");
ServerMessagePacket servPacket = (ServerMessagePacket)receivedPacket;
servPacket._messageRecv = GetReturnMessage(servPacket._messageSent);
client.TcpSend(servPacket);
break;
case Packet.PacketType.CLIENTNAME:
Console.WriteLine("NAME");
ClientNamePacket namePacket = (ClientNamePacket)receivedPacket;
// create message
namePacket._message = client._name + " changed name to " + namePacket._name;
// change name
client._name = namePacket._name;
// update client
client.TcpSend(namePacket);
// notify all clients
TcpRespondToAll(new ChatMessagePacket(namePacket._message), client);
break;
case Packet.PacketType.LOGIN:
Console.WriteLine("LOGIN");
LoginPacket loginPacket = (LoginPacket)receivedPacket;
client._endPoint = loginPacket._endPoint;
loginPacket._serverKey = client.UpdateRSA(loginPacket);
client.TcpSend(loginPacket);
break;
case Packet.PacketType.SECUREMESSAGE:
Console.WriteLine("SECURE");
// receive packet
SecurePacket safePacket = (SecurePacket)receivedPacket;
// transmit packet
TcpSecureRespondToAll(
client.GetSecureMessage(safePacket),
safePacket._packetSrc
);
break;
case Packet.PacketType.ERROR:
//should be for other things, in another place
Console.WriteLine("ERROR");
ErrorMessagePacket errPacket = (ErrorMessagePacket)receivedPacket;
client.TcpSend(errPacket);
break;
case Packet.PacketType.ENDSESSION:
Console.Write("ENDING TCP SESSION: " + client._name);
// signal to client to close connections
// and end while loop
client.Close();
break;
case Packet.PacketType.JOINGAME:
Console.Write("JOIN GAME - ");
JoinGamePacket joinGame = (JoinGamePacket)receivedPacket;
Client host = null;
foreach (Client user in _clients.Values)
{
if (user._name == joinGame._targetHost)
{
host = user;
}
}
//ChatMessagePacket resultPacket = null;
if (GameSession.Instance.JoinSession(ref client, host))
{
Console.WriteLine("JOINED A GAME");
//success - msg client
PrivateMessagePacket resultPacket =
new PrivateMessagePacket(client._name, "Started Game Session")
{
_packetSrc = _serverName
};
TcpRespondTo(resultPacket, client);
//launch client's game
client.TcpSend(joinGame);
}
else
{
Console.WriteLine("FAILED TO JOIN A GAME");
//failed - msg client
};
break;
case Packet.PacketType.USERLIST:
Console.WriteLine("USERLIST");
UserListPacket userList = (UserListPacket)receivedPacket;
if (userList._users == null)
{
List <string> usernames = new List <string>();
// collect user names
foreach (KeyValuePair <int, Client> c in _clients)
{
usernames.Add(c.Value._name);
}
userList._users = usernames.ToArray();
TcpSendToAll(userList);
}
// if list is filled, why is it here?!
break;
case Packet.PacketType.LEAVEGAME:
LeaveGamePacket leaveGame = (LeaveGamePacket)receivedPacket;
// check game sessions
bool wasHost = GameSession.Instance.IsHosting(client);
// update game session
List <string> players = GameSession.Instance.LeaveSession(ref client);
ServerMessagePacket serverMessage = null;
if (!leaveGame._wasForced)
{
serverMessage = new ServerMessagePacket
(client._name + " has left the game.", null);
}
else
{
serverMessage = new ServerMessagePacket
("GAME ERROR: " + client._name + " was forced to leave the game.", null);
}
foreach (Client user in _clients.Values)
{
if (players.Contains(user._name))
{
user.TcpSend(serverMessage);
}
}
if (wasHost)
{
leaveGame._wasForced = true;
foreach (Client user in _clients.Values)
{
user.TcpSend(leaveGame);
}
}
break;
default:
break;
}
}
} catch (Exception e) {
Console.WriteLine("Error: " + e.Message);
if (client != null)
{
Console.WriteLine("Client: " + client._name);
}
}
client.Close();
_clients.TryRemove(index, out client);
}
//ErrorMessagePacket
private static void HandlePacket(ErrorMessagePacket packet)
{
MessageBox.Show(packet.Error, packet.Header, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
private static void HandlePacket(Client client, Packet packet)
{
switch (packet.type)
{
case PacketType.NICKNAME:
Boolean duplicate = false;
string NickName = ((NickNamePacket)packet).nickname;
foreach (Client c in clients)
{
if (c.NickName.Equals(NickName))
{
duplicate = true;
}
}
if (duplicate == false)
{
client.NickName = NickName;
ChatMessagePacket nickRecieved = new ChatMessagePacket("Info> Nickname has been set!", "Blue");
sendOnlineList();
client.Send(nickRecieved);
sendLobbies();
}
else
{
ErrorMessagePacket error = new ErrorMessagePacket("Error> Nickname has been taken!");
client.Send(error);
}
break;
case PacketType.CHATMESSAGE:
Console.WriteLine("Recieved Chat Message");
if (client.NickName != null)
{
string message = ((ChatMessagePacket)packet).message;
string color = ((ChatMessagePacket)packet).messageColor;
Console.WriteLine($" COLOR:{color} [{client.NickName}] {message}");
ChatMessagePacket chatMessage = new ChatMessagePacket($"[{client.NickName}] {message}", color);
foreach (Client c in clients)
{
c.Send(chatMessage);
}
}
else
{
ChatMessagePacket nickNameError = new ChatMessagePacket("SET A NICKNAME BEFORE CHATTING WITH !setnickname [NICKNAME] Or via the Lobby GUI");
client.Send(nickNameError);
}
break;
case PacketType.CREATELOBBY:
Console.WriteLine("Lobby Created by: " + client.NickName);
Lobby lobby = new Lobby((Lobbies.Count + 1), client);
Lobbies.Add(lobby);
client.Send(new CreateLobbyPacket(client.NickName));
sendLobbies();
lobby.sendList();
break;
case PacketType.LEAVELOBBY:
foreach (Lobby l in Lobbies.ToArray())
{
if (l.creator.NickName.Equals(client.NickName))
{
l.creator = null;
checkLobbyNotEmpty();
l.sendList();
}
else if (l.other != null)
{
if (l.other.NickName.Equals(client.NickName))
{
l.other = null;
checkLobbyNotEmpty();
l.sendList();
}
}
}
sendLobbies();
break;
case PacketType.JOINLOBBY:
string creator = (((JoinLobbyPacket)packet).creator);
Console.WriteLine("Client " + client.NickName + " Joined Lobby created by: " + creator);
foreach (Lobby l in Lobbies)
{
if (l.creator.NickName.Equals(creator))
{
client.Send(new JoinLobbyPacket(""));
l.addOther(client);
}
}
break;
case PacketType.START:
foreach (Lobby l in Lobbies)
{
if (l.creator.NickName.Equals(client.NickName))
{
l.start();
break;
}
client.Send(new ErrorMessagePacket("Error> You are not the creator of the lobby!"));
}
break;
case PacketType.OPTION:
foreach (Lobby l in Lobbies)
{
Console.WriteLine(((OptionPickPacket)packet).Option);
if (l.creator.NickName.Equals(client.NickName))
{
l.setCreatorPick(((OptionPickPacket)packet).Option);
}
else if (l.other.NickName.Equals(client.NickName))
{
l.setOtherPick(((OptionPickPacket)packet).Option);
}
}
break;
case PacketType.FORCEQUIT:
foreach (Lobby l in Lobbies.ToArray())
{
if (l.creator.NickName.Equals(client.NickName) || l.other.NickName.Equals(client.NickName))
{
l.forceQuit(client);
Lobbies.Remove(l);
break;
}
}
break;
case PacketType.EMPTY:
Console.WriteLine("Blank Packet");
break;
default:
Console.WriteLine("Error Packet Type Unknown");
break;
}
}
