public void ConnectToServerHub(string serverHubIP, int serverHubPort)
{
_serverHubClient = new TcpClient(serverHubIP, serverHubPort);
ServerDataPacket packet = new ServerDataPacket {
ConnectionType = ConnectionType.Server,
FirstConnect = true,
IPv4 = Settings.Instance.Server.IP,
Port = Settings.Instance.Server.Port,
Name = Settings.Instance.Server.ServerName
};
byte[] packetBytes = packet.ToBytes();
_serverHubClient.GetStream().Write(packetBytes, 0, packetBytes.Length);
byte[] bytes = new byte[Packet.MAX_BYTE_LENGTH];
if (_serverHubClient.GetStream().Read(bytes, 0, bytes.Length) != 0)
{
packet = (ServerDataPacket)Packet.ToPacket(bytes);
}
ID = packet.ID;
Logger.Instance.Log($"The ID of this server is {ID}");
}
public void Disconnect()
{
try
{
if (client != null && client.Connected)
{
ServerDataPacket packet = new ServerDataPacket
{
ConnectionType = ConnectionType.Server,
ID = serverID,
FirstConnect = false,
IPv4 = Settings.Instance.Server.IP,
Port = Settings.Instance.Server.Port,
Name = Settings.Instance.Server.ServerName,
RemoveFromCollection = true
};
client.GetStream().Write(packet.ToBytes(), 0, packet.ToBytes().Length);
Logger.Instance.Log($"Removed this server from ServerHub @ {ip}:{port}");
client.Close();
}
}catch (Exception e)
{
Logger.Instance.Warning($"Can't remove server from ServerHub @ {ip}:{port}");
Logger.Instance.Warning($"Exception: {e.Message}");
}
}
private void OnServerShutdown(ShutdownEventArgs args)
{
Logger.Instance.Log("Shutting down server...");
if (_serverHubClient != null && _serverHubClient.Connected)
{
ServerDataPacket packet = new ServerDataPacket
{
ConnectionType = ConnectionType.Server,
ID = ID,
FirstConnect = false,
IPv4 = Settings.Instance.Server.IP,
Port = Settings.Instance.Server.Port,
Name = Settings.Instance.Server.ServerName,
RemoveFromCollection = true
};
_serverHubClient.GetStream().Write(packet.ToBytes(), 0, packet.ToBytes().Length);
Logger.Instance.Log("Removed this server from ServerHub");
_serverHubClient.Close();
}
clients.AsParallel().ForAll(x => x.DestroyClient());
_listener.Stop();
}
public void UpdateServerState()
{
if (client.Connected)
{
try {
ServerDataPacket packet = new ServerDataPacket
{
ConnectionType = ConnectionType.Server,
FirstConnect = false,
IPv4 = Settings.Instance.Server.IP,
Port = Settings.Instance.Server.Port,
ID = serverID,
Name = Settings.Instance.Server.ServerName,
MaxPlayers = Settings.Instance.Server.MaxPlayers,
Players = ServerMain.clients.Count(x => x != null && x._client != null && x._client.Connected)
};
byte[] packetBytes = packet.ToBytes();
client.GetStream().Write(packetBytes, 0, packetBytes.Length);
}
catch (Exception e)
{
Logger.Instance.Warning($"Can't send updated server state to ServerHub @ {ip}:{port}");
Logger.Instance.Warning($"Exception: {e.Message}");
}
}
}
///<summary>Bliver kaldt når vi har modtaget data fra serveren</summary>
private void OnNetworkDataReceived(ServerDataPacket networkData)
{
//Reset vores ting til en state hvor vi ved de ikke har fået en update
ResetNetworkedData();
//Opdater alle vores ting i scenen med nyt data
HandleNetworkedPlayer(networkData.player);
HandleNetworkedShips(networkData.enemyShips);
HandleNetworkedMines(networkData.mines);
HandleNetworkedCannonBalls(networkData.cannonBalls);
//Slet alle ting som ikke er blevet opdateret i denne loop
CleanupUnnetworkedData();
}
public void Connect(string serverHubIP, int serverHubPort)
{
ip = serverHubIP;
port = serverHubPort;
try
{
client = new TcpClient(ip, port);
ServerDataPacket packet = new ServerDataPacket
{
ConnectionType = ConnectionType.Server,
FirstConnect = true,
IPv4 = Settings.Instance.Server.IP,
Port = Settings.Instance.Server.Port,
Name = Settings.Instance.Server.ServerName,
MaxPlayers = Settings.Instance.Server.MaxPlayers,
Players = 0
};
byte[] packetBytes = packet.ToBytes();
client.GetStream().Write(packetBytes, 0, packetBytes.Length);
byte[] bytes = new byte[Packet.MAX_BYTE_LENGTH];
if (client.GetStream().Read(bytes, 0, bytes.Length) != 0)
{
packet = (ServerDataPacket)Packet.ToPacket(bytes);
}
serverID = packet.ID;
Logger.Instance.Log($"Connected to ServerHub @ {ip}:{port} with ID {serverID}");
}
catch (Exception e)
{
Logger.Instance.Warning($"Can't connect to ServerHub @ {ip}:{port}");
Logger.Instance.Warning($"Exception: {e.Message}");
}
}
private void ServerShutdown(ShutdownEventArgs args)
{
Logger.Instance.Log("Shutting down server...");
if (_serverHubClient != null && _serverHubClient.Connected)
{
ServerDataPacket packet = new ServerDataPacket
{
ConnectionType = ConnectionType.Server,
IPv4 = Settings.Instance.Server.IP,
Port = Settings.Instance.Server.Port,
Name = Settings.Instance.Server.ServerName,
RemoveFromCollection = true
};
byte[] packetBytes = packet.ToBytes();
_serverHubClient.GetStream().Write(packetBytes, 0, packetBytes.Length);
Logger.Instance.Log("Removed this server from ServerHub");
_serverHubClient.Close();
}
}
private Task HandleConnectionAsync(TcpClient tcpClient)
{
WelcomePacket packet = new WelcomePacket();
Send(tcpClient, packet.CreatePacket());
NewsTitlePacket packet2 = new NewsTitlePacket();
Send(tcpClient, packet2.CreatePacket());
NewsContentPacket packet3 = new NewsContentPacket();
Send(tcpClient, packet3.CreatePacket());
return(Task.Run(async() =>
{
using (var networkStream = tcpClient.GetStream())
{
while (true)
{
var buffer = new byte[4096];
Console.WriteLine("[Server] Reading from client");
var byteCount = await networkStream.ReadAsync(buffer, 0, buffer.Length);
int?size = null;
HeadCodeSc?headcode = null;
byte type = buffer[0];
if (type == 0xC1 || type == 0xC3)
{
size = buffer[1];
headcode = (HeadCodeSc)buffer[2];
Console.WriteLine("C1/C3 packet type");
}
else if (type == 0xC2 || type == 0xC4)
{
size = buffer[1] * 256;
size |= buffer[2];
headcode = (HeadCodeSc)buffer[3];
Console.WriteLine("C2/C4 packet type");
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Unknow packet type 0x{0:X}", type);
Console.ResetColor();
continue;
}
Console.WriteLine("Read {0} bytes from socket.",
byteCount);
Console.WriteLine("Packet type: 0x{0:X} headcode: 0x{1:X} size: 0x{2:X}", type, headcode, size);
Console.WriteLine(BitConverter.ToString(buffer, 0, (int)size));
try
{
if (headcode == HeadCodeSc.ConnectServerData)
{
if ((HeadCodeCs)buffer[3] == HeadCodeCs.ClientConnect)
{
ServerListPacket packetData = new ServerListPacket(udpServer);
Send(tcpClient, packetData.CreatePacket());
}
else if ((HeadCodeCs)buffer[3] == HeadCodeCs.ServerSelect)
{
ServerDataPacket packetData = new ServerDataPacket(udpServer, buffer);
Send(tcpClient, packetData.CreatePacket());
}
}
} catch (Exception)
{
}
}
//await HandleConnectionAsync(tcpClient);
}
}));
}
///<summary>Bliver kaldt når vi skal lave en netværks update</summary>
private async void OnNetworkUpdate()
{
if (isGameMaster == true)
{
ServerDataPacket oldPacket = updateIntervalPacket;
updateIntervalPacket = GenerateServerPacket(oldPacket);
//Konverter data packeten til json format
string packetDataJson = JsonUtility.ToJson(updateIntervalPacket);
//Encode json stringen til base64 string
string packetDataEncoded = System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(packetDataJson));
//Send vores data til serveren
FormUrlEncodedContent packetValue = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("clientType", "master"),
new KeyValuePair <string, string>("packetData", packetDataEncoded)
});
await networkClient.PostAsync(gameserverUrl, packetValue);
}
else
{
//Send en request til serveren om data
FormUrlEncodedContent packetValue = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("clientType", "client")
});
HttpResponseMessage response = await networkClient.PostAsync(gameserverUrl, packetValue);
string responseData = await response.Content.ReadAsStringAsync();
//Tjek om der er data og vidersend til handleren
if (responseData.Trim() != string.Empty)
{
//base 64 stringen til json string
string packetDataDecoded = System.Text.Encoding.UTF8.GetString(System.Convert.FromBase64String(responseData));
//Konverter json stringen til en data packet
ServerDataPacket packetData = JsonUtility.FromJson <ServerDataPacket>(packetDataDecoded);
//Vi tjekker her om sessionen har ændret sig eller om der er en fullupdate, hvis ja så fjerner vi alt i scenen og instantiere alt på nyt
if (packetData.fullUpdate == true || packetData.gameSession != updateIntervalSession)
{
updateIntervalSession = packetData.gameSession;
ResetNetworkedData();
CleanupUnnetworkedData();
OnNetworkDataReceived(packetData);
updateIntervalPacket = packetData;
}
else if (packetData.ID > updateIntervalPacket.ID)
{
OnNetworkDataReceived(packetData);
updateIntervalPacket = packetData;
}
}
}
}
///<summary>Generer en packet med alt nødvendigt information omkring scenen</summary>
private ServerDataPacket GenerateServerPacket(ServerDataPacket oldPacket)
{
ShipPacketData playerData;
if (gameManager.GetPlayerShip() != null)
{
playerData = new ShipPacketData
{
ID = gameManager.GetPlayerShip().GetShipID(),
position = gameManager.GetPlayerShip().transform.position,
rotation = gameManager.GetPlayerShip().transform.rotation,
health = gameManager.GetPlayerShip().GetShipHealth(),
fuel = gameManager.GetPlayerShip().GetShipFuel()
};
}
else
{
playerData = new ShipPacketData
{
ID = -1,
position = new Vector3(),
rotation = new Quaternion(),
health = 0,
fuel = 0
};
}
List <ShipPacketData> enemyShipData = new List <ShipPacketData>();
for (int i = 0; i < gameManager.GetAllShips().Count; i++)
{
if (gameManager.GetAllShips()[i] as EnemyShip != null)
{
ShipPacketData shipData = new ShipPacketData
{
ID = gameManager.GetAllShips()[i].GetShipID(),
position = gameManager.GetAllShips()[i].transform.position,
rotation = gameManager.GetAllShips()[i].transform.rotation,
health = gameManager.GetAllShips()[i].GetShipHealth(),
fuel = gameManager.GetAllShips()[i].GetShipFuel()
};
enemyShipData.Add(shipData);
}
}
List <MinePacketData> minesData = new List <MinePacketData>();
for (int i = 0; i < gameManager.GetMines().Count; i++)
{
MinePacketData mineData = new MinePacketData
{
ID = gameManager.GetMines()[i].GetMineID(),
position = gameManager.GetMines()[i].transform.position
};
minesData.Add(mineData);
}
List <CannonBallPacketData> cannonBallsData = new List <CannonBallPacketData>();
for (int i = 0; i < gameManager.GetCannonBalls().Count; i++)
{
CannonBallPacketData cannonBallData = new CannonBallPacketData
{
ID = gameManager.GetCannonBalls()[i].GetCannonBallID(),
ownerID = gameManager.GetCannonBalls()[i].GetCannonBallOwner().GetShipID(),
position = gameManager.GetCannonBalls()[i].transform.position,
rotation = gameManager.GetCannonBalls()[i].transform.rotation
};
cannonBallsData.Add(cannonBallData);
}
//Indsæt vores data ind i en packet klasse
ServerDataPacket serverPacket = new ServerDataPacket
{
ID = oldPacket.ID + 1,
fullUpdate = (oldPacket.ID + 1) <= 1,
gameSession = updateIntervalSession,
player = playerData,
enemyShips = enemyShipData,
mines = minesData,
cannonBalls = cannonBallsData
};
return(serverPacket);
}