public override PackageInterface[] CreatePackagesFromStream(byte[] stream)
{
if (stream == null)
{
return(null);
}
string[] jsonStrings = ConvertStreamToValidJsonStrings(ConvertNetworkDataToString(stream));
if (jsonStrings == null)
{
return(null);
}
List <PackageInterface> packages = new List <PackageInterface>();
foreach (string data in jsonStrings)
{
PackageInterface package = CreatePackageFromJSONString(data);
if (package != null)
{
packages.Add(package);
}
}
if (packages.Count > 0)
{
return(packages.ToArray());
}
return(null);
}
public override void ProcessServerData(PackageInterface data)
{
if (!Canceled && (Timeout == false))
{
ProcessTCPPackage(data);
}
}
public void SendUDP(PackageInterface package)
{
if (UdpConnection == null)
{
throw new ConnectionException("Network connection does not have an UDP connection!");
}
UdpConnection.Send(Adapter.CreateNetworkDataFromPackage(package), RemoteEndPoint);
}
public void BroadCastUDP(PackageInterface package)
{
if (!CanSend())
{
return;
}
foreach (NetworkConnection clientCon in ClientConnections.Values)
{
clientCon.SendUDP(package);
}
}
private void HandleSessionRequest(NetworkConnection connection, PackageInterface request)
{
ClientSessionRequest packet = (ClientSessionRequest)request;
if (packet.Reconnect)
{
ReconnectClientWithPreviousSession(connection, packet);
}
else
{
ConnectClientWithNewSession(connection);
}
}
public override void ProcessServerData(PackageInterface data)
{
switch (data.PackageType)
{
case PackageType.ServerData:
ApplyServerPositions(data as ServerDataPackage);
break;
case PackageType.ServerGameControl:
UpdateScore(data as ServerGameControlPackage);
break;
}
}
public bool InspectPackage(PackageInterface package)
{
if (State == ResponseState.Pending)
{
if (package != null && package.PackageType == ResponsePackageType)
{
ResponsePackage = package;
State = ResponseState.Received;
}
}
return(ResponsePackage != null);
}
private void ProcessTCPPackage(PackageInterface package)
{
switch (package.PackageType)
{
case PackageType.ServerPlayerIDResponse:
HandleInitResponse(package as ServerInitializeGameResponse);
break;
case PackageType.ServerMatchmakingStatusResponse:
HandleStatusResponse(package as ServerMatchmakingStatusResponse);
break;
}
}
public void SendDataUDP(PackageInterface package, int session)
{
if (!CanSend())
{
return;
}
NetworkConnection sessionConnection = ClientConnections[session];
if (sessionConnection != null)
{
sessionConnection.SendUDP(package);
}
}
private void ReadGameRequests(NetworkConnection networkConnection)
{
PackageInterface newPacket = networkConnection.ReadTCP();
if (newPacket == null)
{
return;
}
if (newPacket.PackageType == PackageType.ClientInitalizeGamePackage)
{
HandleGameRequest(networkConnection, newPacket);
}
}
private void ReadSessionRequests(NetworkConnection networkConnection)
{
PackageInterface newPacket = networkConnection.ReadTCP();
if (newPacket == null)
{
return;
}
if (newPacket.PackageType == PackageType.ClientSessionRequest)
{
HandleSessionRequest(networkConnection, newPacket);
}
}
private void ReceiveTCP(object sender, byte[] data, IPEndPoint source)
{
PackageInterface package = Adapter.CreatePackageFromNetworkData(data);
if (package == null)
{
return;
}
if (!CheckForResponse(package))
{
TcpPackages.Write(package);
}
}
public Dictionary <int, PackageInterface> GetDataFromEverySessionUDP()
{
Dictionary <int, PackageInterface> packages = new Dictionary <int, PackageInterface>();
foreach (int session in ClientConnections.Keys)
{
PackageInterface sessionPackage = GetDataUDP(session);
if (sessionPackage != null)
{
packages.Add(session, sessionPackage);
}
}
return(packages);
}
private bool CheckForResponse(PackageInterface package)
{
foreach (ResponseRequest responseRequest in m_openResponses.Entries)
{
if (responseRequest.InspectPackage(package) ||
responseRequest.State == ResponseRequest.ResponseState.Timeout ||
responseRequest.State == ResponseRequest.ResponseState.Canceled)
{
m_openResponses.Remove(responseRequest);
return(true);
}
}
return(false);
}
static void proGamerClient()
{
IPEndPoint server = new IPEndPoint(IPAddress.Parse("127.0.0.1"), NetworkConstants.SERVER_PORT);
Socket connectionSocket = new Socket(server.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
connectionSocket.Connect(server);
TCPPacketConnection conn = new TCPPacketConnection(connectionSocket);
connections.Add(conn);
open8PlayersGame(conn);
NetworkConnection networkConn = new NetworkConnection(conn);
UDPConnection c = new UDPConnection(conn.Local);
c.InitializeReceiving();
networkConn.SetUDPConnection(c);
List <int> playerIDs = new List <int>();
while (true)
{
PackageInterface p = networkConn.ReadTCP();
if (p != null && p.PackageType == PackageType.ServerPlayerIDResponse)
{
ServerInitializeGameResponse ps = p as ServerInitializeGameResponse;
foreach (Player pl in ps.m_players)
{
if (pl.Controllable)
{
playerIDs.Add(pl.ID);
}
}
break;
}
else
{
Thread.Sleep(100);
}
}
while (true)
{
foreach (int playerID in playerIDs)
{
sendMovementToMatchBall(networkConn, playerID);
}
Thread.Sleep(100);
}
}
private void HandleGameRequest(NetworkConnection connection, PackageInterface request)
{
ClientInitializeGamePackage initPackage = request as ClientInitializeGamePackage;
switch (initPackage.Request)
{
case ClientInitializeGamePackage.RequestType.Matchmaking:
ConnectionsReadyForQueingUpToMatchmaking.Remove(connection);
OnMatchmakingRequest?.Invoke(this, connection, request);
break;
case ClientInitializeGamePackage.RequestType.Observe:
ConnectionsReadyForQueingUpToMatchmaking.Remove(connection);
OnObserverRequest?.Invoke(this, connection);
break;
}
}
protected override void Update(GameTime gameTime)
{
if (m_networkDied)
{
ConnectionControl.SetStatus("Connection died.");
CleanUpNetwork();
SwitchMode(GameMode.Connect);
}
InputManager.Update();
if (IsActive)
{
if (IsExitInput())
{
HandleExitInput();
}
ActiveControl.HandleInput();
}
if (Network != null)
{
foreach (PackageInterface package in Network.GetTCPPackages())
{
ActiveControl.ProcessServerData(package);
}
}
// a switch to finish can happen in between those lines which disconnects -> check again if its dead
if (Network != null)
{
PackageInterface udpPackage = Network.GetUDPPackage();
if (udpPackage != null)
{
ActiveControl.ProcessServerData(udpPackage);
}
}
ActiveControl.Update(gameTime);
base.Update(gameTime);
}
public void BroadcastGenericUDPPackage(PackageInterface package)
{
Out.BroadCastUDP(package);
}
public void SendTCPPackageToClient(PackageInterface packet, int sessionID)
{
Out.SendDataTCP(packet, sessionID);
}
public override byte[] CreateNetworkDataFromPackage(PackageInterface package)
{
string networkDataString = JsonConvert.SerializeObject(package);
return(System.Text.Encoding.Default.GetBytes(networkDataString));
}
public virtual void ProcessServerData(PackageInterface data)
{
}
public abstract byte[] CreateNetworkDataFromPackage(PackageInterface package);
private void HandleMatchmakingRequest(object sender, NetworkConnection connection, PackageInterface request)
{
MatchmakingRequests.Write(new QueueRequest(connection, request as ClientInitializeGamePackage));
}
public void SendTCP(PackageInterface package)
{
TcpConnection.Send(Adapter.CreateNetworkDataFromPackage(package));
}
