/// <summary>Joins the lobby and sends a lobby join request to the server</summary>
/// <param name="lobbyindex">The lobby index.</param>
public void JoinLobby(int lobbyindex)
{
ServerVisibility = ConstantsModel.HIDDEN;
LobbyVisibility = ConstantsModel.VISIBLE;
PacketSend.ClientLobbyJoin(Lobbies[lobbyindex].UID);
}
/// <summary>Sets the ready.</summary>
public void SetReady()
{
ClientManager.Instance.playersInSession[ClientManager.Instance.MyID].Status = 1;
ReadyEnabled = "False";
PacketSend.ClientStatus(1);
}
/// <summary>The GameLobbyInstance class stores lobby information for a single lobby instance. It stores lobby PlayerCount,
/// Name, IsFull, and the lobby UID</summary>
public static void ProcessCommand(string cmd)
{
string[] tokens = cmd.Split(" ");
switch (tokens[0])
{
case "/help":
Console.WriteLine(Constants.DO_HELP);
break;
case "/kick":
Console.WriteLine(Constants.DO_KICK);
Kick(tokens[1]);
break;
case "/exit":
Console.WriteLine(Constants.DO_SHUTDOWN);
Environment.Exit(0);
break;
case "/disconnect":
Console.WriteLine(Constants.DO_DISCONNECT);
PacketSend.ServerDisconnect();
break;
default:
Console.WriteLine(Constants.UNKNOWN);
break;
}
}
private void _processClientPackets()
{
if (_isClosing || !_doPacketProcess)
{
return;
}
_localRecvPackets = _localSecurity.TransferIncoming();
if (_localRecvPackets != null)
{
foreach (var packet in _localRecvPackets)
{
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000 || packet.Opcode == 0x2001)
{
continue;
}
//Send to PacketHandler
PacketReceived?.Invoke(packet);
}
}
_localSendBuffers = _localSecurity.TransferOutgoing();
if (_localSendBuffers == null)
{
return;
}
foreach (var buffer in _localSendBuffers)
{
PacketSend?.Invoke(buffer.Value);
Send(buffer.Key.Buffer);
}
}
/// <summary>Queues the user again by reconnecting them to the lobby.</summary>
public void queueAgain()
{
ClientManager.Instance.playersInSession[ClientManager.Instance.MyID].ResetState();
PacketSend.ClientStatus(0);
mainWindow.SetNewView(Screens.MULTIPLAYER_MENU_RC);
}
private void EndGame()
{
gameOver = true;
eventTimer.Stop();
encoderTimer.Stop();
myEvents.getAggregator().PublishOnUIThread(new GameOverEvent(gameOver));
PacketSend.ClientGameOver(gameOver);
}
/// <summary>Handles the MultiplayerNewGameEvent event.</summary>
/// <param name="message">The message.</param>
public void Handle(MultiplayerNewGameEvent message)
{
ClientManager.Instance.playersInSession[ClientManager.Instance.MyID].Status = 2;
myEvents.getAggregator().Unsubscribe(this);
PacketSend.ClientStatus(2);
LoadMultiPlayer();
}
/// <summary>Attempts to reconnect to the previous address.</summary>
public void AttemptReconnect()
{
string[] ipAndPort = ParseInputIP();
PacketSend.ClientReconnect();
ConnectEnabled = "False";
myEvents.getAggregator().PublishOnUIThread(new ClientConnectedEvent(ipAndPort, true));
}
/// <summary>Creates a lobby and sends a lobby create request to the server.</summary>
public void CreateLobby()
{
if (Lobbies.Count < 4)
{
PacketSend.ClientLobbyCreate();
ServerVisibility = ConstantsModel.HIDDEN;
LobbyVisibility = ConstantsModel.VISIBLE;
}
}
public void Send(byte[] packet)
{
if (packet.Length > 0)
{
lock (syncLock) {
socket.Send(BitConverter.GetBytes(packet.Length));
socket.Send(packet);
TotalBytesSend += packet.Length;
PacketSend?.Invoke(this, packet.Length);
}
}
}
/// <summary>Kicks the specified player. If multiple players with the same name are connected, kick only the first found one.</summary>
/// <param name="player">The player.</param>
private static void Kick(string player)
{
foreach (GameClientInstance x in GameServer.connectedClients.Values)
{
if (x.UserName == player)
{
PacketSend.ServerKick(x.UID);
return;
}
}
Console.WriteLine(Constants.USER_NOT_FOUND_ERROR + player);
}
private void EncodeGrid(object sender, ElapsedEventArgs e)
{
this.Dispatcher.Invoke(() =>
{
string encodedGrid = "";
for (int i = 1; i < (col - 1); i++)
{
for (int j = 1; j < row; j++)
{
encodedGrid += Array.IndexOf(TILE_ARRAY, cell[i, j].Background);
}
}
PacketSend.ClientGrid(encodedGrid);
});
}
///<summary>Remove a player from the lobby. If the lobby becomes empty, remove this lobby from the lobby list and dispose this.</summary>
///<param name="player">Client to remove from the lobby</param>
///<remarks> This function sends a "LobbyList" packet.</remarks>
public void RemovePlayer(GameClientInstance player)
{
if (playersInLobby.Contains(player))
{
playersInLobby.Remove(player);
PlayerCount--;
IsFull = false;
}
if (PlayerCount == 0)
{
GameServer.openLobbies.Remove(UID);
Console.WriteLine(Name + Constants.LOBBY_CLOSED);
PacketSend.LobbyList();
}
}
private void CalculateScore()
{
int multiplier = 0;
switch (clearedRows)
{
case 0:
break;
case 1:
multiplier = 100;
break;
case int n when(n == 2 || n == 3):
multiplier = 200;
break;
case 4:
multiplier = 500;
break;
case 5:
multiplier = 1000;
break;
default:
multiplier = 1500;
break;
}
if (multiplier != 0)
{
audioManager.PlaySound(Sound.CLEARED_ROW);
}
score = (score + (clearedRows * multiplier));
clearedRows = 0;
myEvents.getAggregator().PublishOnUIThread(new ScoreEvent(score));
PacketSend.ClientScore(score);
}
private void _processServerPackets()
{
if (_isClosing || !_doPacketProcess)
{
return;
}
#region Handle Recive
_remoteRecvPackets = _remoteSecurity.TransferIncoming();
if (_remoteRecvPackets != null)
{
foreach (var packet in _remoteRecvPackets.Where(packet => packet.Opcode != 0x5000 && packet.Opcode != 0x9000))
{
//RaiseEvent if event is assigned.
PacketReceived?.Invoke(packet);
}
}
#endregion
#region Handle Send
_remoteSendBuffers = _remoteSecurity.TransferOutgoing();
if (_remoteSendBuffers == null)
{
return;
}
foreach (var buffer in _remoteSendBuffers)
{
PacketSend?.Invoke(buffer.Value);
Send(buffer.Key.Buffer);
}
#endregion
}
public static ArrByte64K GetPacket(OperationResponse response)
{
PacketSend packetSend = PacketSend.Create(response.OperationCode, PacketSend.CodeType.OperationCode);
packetSend.SetReturnCode(response.ReturnCode);
if (response.Parameters != null)
{
foreach (var parameter in response.Parameters)
{
packetSend.Write((byte)parameter.Key);
//添加value的值类型，如int，byte，string，等
if (parameter.Value.GetType() == typeof(byte))
{
packetSend.Write((byte)ValueType.Byte);
packetSend.Write((byte)parameter.Value);
}
else if (parameter.Value.GetType() == typeof(int))
{
packetSend.Write((byte)ValueType.Int32);
packetSend.Write((int)parameter.Value);
}
else if (parameter.Value.GetType() == typeof(string))
{
packetSend.Write((byte)ValueType.String);
packetSend.Write((string)parameter.Value);
}
else if (parameter.Value.GetType().IsEnum)
{
packetSend.Write((byte)ValueType.EnumInt);
packetSend.Write((int)parameter.Value);
}
else if (parameter.Value.GetType() == typeof(bool))
{
packetSend.Write((byte)ValueType.Boolean);
packetSend.Write((bool)parameter.Value);
}
else if (parameter.Value.GetType() == typeof(sbyte))
{
packetSend.Write((byte)ValueType.SByte);
packetSend.Write((sbyte)parameter.Value);
}
else if (parameter.Value.GetType() == typeof(short))
{
packetSend.Write((byte)ValueType.Int16);
packetSend.Write((short)parameter.Value);
}
else if (parameter.Value.GetType() == typeof(long))
{
packetSend.Write((byte)ValueType.Int64);
packetSend.Write((long)parameter.Value);
}
else if (parameter.Value.GetType() == typeof(ushort))
{
packetSend.Write((byte)ValueType.UInt16);
packetSend.Write((ushort)parameter.Value);
}
else if (parameter.Value.GetType() == typeof(uint))
{
packetSend.Write((byte)ValueType.UInt32);
packetSend.Write((uint)parameter.Value);
}
else if (parameter.Value.GetType() == typeof(ulong))
{
packetSend.Write((byte)ValueType.UInt64);
packetSend.Write((ulong)parameter.Value);
}
else
{
}
}
}
return(packetSend.CreateArrByte64K());
}
private void OnPacketSend(string packet)
{
PacketSend?.Invoke(packet);
}
protected bool OnPacketSend(string packet) => PacketSend == null || PacketSend.Invoke(packet);
private void ProtocolClient_PacketSend(ProtocolClient sender, int Send)
{
PacketSend?.Invoke(sender, Send);
}
