private List <Commands> DeserializeCommands(BitBuffer buffer)
{
var commandsList = new List <Commands>();
try
{
var playerId = buffer.GetInt();
var storedCommandLists = buffer.GetInt();
var clientData = clients[playerId];
for (var i = 0; i < storedCommandLists; i++)
{
var seq = buffer.GetInt();
var commands = new Commands(
seq,
buffer.GetByte() > 0,
buffer.GetByte() > 0,
buffer.GetByte() > 0,
buffer.GetByte() > 0,
buffer.GetFloat());
if (clientData.RecvCommandSeq < seq)
{
commandsList.Add(commands);
clientData.RecvCommandSeq = seq;
}
}
}
catch (Exception ex)
{
Debug.Log("ERROR " + ex.StackTrace);
}
return(commandsList);
}
public static PlayerInfo FromBytes(BitBuffer bitBuffer)
{
int id = bitBuffer.GetByte();
int health = bitBuffer.GetByte();
PositionInfo positionInfo = PositionInfo.FromBytes(bitBuffer);
return(new PlayerInfo(id, health, positionInfo));
}
public static AbilityResponse FromBytes(BitBuffer bitBuffer)
{
int id = bitBuffer.GetByte();
AbilityType type = (AbilityType)bitBuffer.GetByte();
PositionInfo startPosition = null;
if (type == AbilityType.AUTOATTACK)
{
startPosition = PositionInfo.FromBytes(bitBuffer);
}
return(new AbilityResponse(id, type, startPosition, PositionInfo.FromBytes(bitBuffer)));
}
public static PlayerInfoBroadcast FromBytes(BitBuffer bitBuffer)
{
int id = bitBuffer.GetByte();
int count = bitBuffer.GetByte();
List <PlayerInfo> list = new List <PlayerInfo> ();
for (int i = 0; i < count; i++)
{
PlayerInfo playerInfo = PlayerInfo.FromBytes(bitBuffer);
list.Add(playerInfo);
}
return(new PlayerInfoBroadcast(id, list));
}
private void SaveConnectedPlayersAttributes(BitBuffer buffer)
{
var connectedPlayerCount = buffer.GetByte();
PlayerPrefs.SetInt("ConnectedPlayerCount", connectedPlayerCount);
for (var i = 1; i <= connectedPlayerCount; i++)
{
var otherClientId = buffer.GetInt();
var otherClientName = buffer.GetString();
var position = new Vector3();
var rotation = new Quaternion();
position.x = buffer.GetFloat();
position.y = buffer.GetFloat();
position.z = buffer.GetFloat();
rotation.w = buffer.GetFloat();
rotation.x = buffer.GetFloat();
rotation.y = buffer.GetFloat();
rotation.z = buffer.GetFloat();
PlayerPrefs.SetInt($"ConnectedPlayer{i}Id", otherClientId);
PlayerPrefs.SetString($"ConnectedPlayer{i}Name", otherClientName);
PlayerPrefs.SetFloat($"ConnectedPlayer{i}PosX", position.x);
PlayerPrefs.SetFloat($"ConnectedPlayer{i}PosY", position.y);
PlayerPrefs.SetFloat($"ConnectedPlayer{i}PosZ", position.z);
PlayerPrefs.SetFloat($"ConnectedPlayer{i}RotW", rotation.w);
PlayerPrefs.SetFloat($"ConnectedPlayer{i}RotX", rotation.x);
PlayerPrefs.SetFloat($"ConnectedPlayer{i}RotY", rotation.y);
PlayerPrefs.SetFloat($"ConnectedPlayer{i}RotZ", rotation.z);
}
}
public static PacketType ServerDeserializeInput(BitBuffer buffer, List <Commands> commandsList,
List <Shot> shotsList, ShotBroadcast shotBroadcast, PlayerJoined p, out int playerDisconnect)
{
var messageType = buffer.GetByte();
playerDisconnect = -1;
if (messageType == (byte)PacketType.PLAYER_JOINED_ACK)
{
DeserializePlayerJoinedAck(p, buffer);
return(PacketType.PLAYER_JOINED_ACK);
}
if (messageType == (byte)PacketType.COMMANDS)
{
DeserializeCommands(commandsList, buffer);
return(PacketType.COMMANDS);
}
if (messageType == (byte)PacketType.PLAYER_SHOT)
{
DeserializeShot(shotsList, buffer);
return(PacketType.PLAYER_SHOT);
}
if (messageType == (byte)PacketType.SHOT_BROADCAST_ACK)
{
DeserializeShotBroadcast(buffer, shotBroadcast); // SAME AS SHOTBROADCAST; BUT ITS AN ACK
return(PacketType.SHOT_BROADCAST_ACK);
}
if (messageType == (byte)PacketType.PLAYER_DISCONNECT)
{
playerDisconnect = PlayerDisconnectDeserialize(buffer);
}
return(PacketType.PLAYER_DISCONNECT);
}
private void DeserializeClientMessage(BitBuffer buffer, int clientId)
{
try
{
var messageType = (PacketType)buffer.GetByte();
switch (messageType)
{
case PacketType.Commands:
var commandsList = DeserializeCommands(buffer);
ProcessReceivedCommands(commandsList, clientId);
break;
case PacketType.PlayerJoinedAck:
DeserializePlayerJoinedAck(buffer);
break;
case PacketType.PlayerShot:
var shotsList = DeserializePlayerShot(buffer);
ProcessReceivedShots(shotsList, clientId);
break;
case PacketType.PlayerDisconnect:
ProcessPlayerDisconnect(clientId);
break;
default:
throw new ArgumentOutOfRangeException();
}
} catch (Exception ex)
{
Debug.Log("ERROR " + ex.StackTrace);
}
}
public static int[] PlayerConnectResponseDeserialize(BitBuffer buffer)
{
int[] resp = new int[2];
buffer.GetByte(); // PlayerConnect
resp[0] = buffer.GetInt(); // userID
resp[1] = buffer.GetInt(); // srvPort
return(resp);
}
public static PlayerInput fromBytes(BitBuffer bitBuffer)
{
int id = bitBuffer.GetByte();
InputType type = (InputType)bitBuffer.GetByte();
switch (type)
{
case InputType.MOVEMENT:
return(MovementInput.FromBytes(id, bitBuffer));
case InputType.ABILITY:
return(AbilityInput.FromBytes(id, bitBuffer));
case InputType.START_GAME:
return(GameStartInput.FromBytes(id, bitBuffer));
}
return(null);
}
public static ResponsesContainer FromBytes(BitBuffer bitBuffer)
{
int size = bitBuffer.GetAvailableByteCount() - 1;
byte[] bytes = new byte[size];
for (int i = 0; i < bytes.Length; i++)
{
bytes[i] = bitBuffer.GetByte();
}
return(new ResponsesContainer(bytes));
}
public void TestBitsInLastByte()
{
var b = new BitBuffer(new byte[1], 7);
b.GetBool();
for (int i = 0; i < 8; i++)
{
b = new BitBuffer(new byte[1], i);
b.GetByte(8 - i);
}
}
public static PacketType ClientDeserialize(List <Snapshot> interpolationBuffer, PlayerJoined playerJoined, BitBuffer buffer,
int displaySeq, CommandsList clientCommands, int cmdSeq, List <Shot> shots, int shotSeq,
ShotBroadcast shotBroadcast, out int commandSnapshotAck, out int playerDisconnect)
{
commandSnapshotAck = -1;
var messageType = buffer.GetByte();
playerDisconnect = -1;
if (messageType == (byte)PacketType.UPDATE_MESSAGE)
{
ClientDeserializeUpdate(interpolationBuffer, buffer, displaySeq, clientCommands, out commandSnapshotAck);
return(PacketType.UPDATE_MESSAGE);
}
if (messageType == (byte)PacketType.PLAYER_JOINED)
{
PlayerJoinedDeserialize(playerJoined, buffer);
return(PacketType.PLAYER_JOINED);
}
if (messageType == (byte)PacketType.COMMANDS_ACK_MESSAGE)
{
int receivedAckSequence = ClientDeserializeAck(buffer);
clientCommands.Ack(receivedAckSequence);
return(PacketType.COMMANDS_ACK_MESSAGE);
}
if (messageType == (byte)PacketType.SHOT_ACK)
{
int receivedShotAckSeq = ClientDeserializeShotAck(buffer);
int count = 0;
foreach (var shot in shots)
{
if (shot.Seq <= receivedShotAckSeq)
{
count++;
}
}
shots.RemoveRange(0, count);
return(PacketType.SHOT_ACK);
}
if (messageType == (byte)PacketType.SHOT_BROADCAST)
{
DeserializeShotBroadcast(buffer, shotBroadcast);
return(PacketType.SHOT_BROADCAST);
}
if (messageType == (byte)PacketType.PLAYER_DISCONNECT)
{
playerDisconnect = PlayerDisconnectDeserialize(buffer);
}
return(PacketType.PLAYER_DISCONNECT);
}
private void Deserialize(BitBuffer buffer)
{
var messageType = (PacketType)buffer.GetByte();
if (messageType == PacketType.PlayerJoinedResponse)
{
var recvClientId = buffer.GetInt();
if (recvClientId == clientId)
{
SavePlayerAttributes(buffer);
channel.Disconnect();
SceneManager.LoadScene("Client Game");
}
}
}
private ClientData DeserializeJoin(BitBuffer buffer)
{
PacketType messageType = (PacketType)buffer.GetByte();
if (messageType != PacketType.Join)
{
throw new ArgumentException("Unknown message type received from client manager.");
}
var newClientData = new ClientData();
newClientData.PlayerId = buffer.GetInt();
newClientData.PlayerName = buffer.GetString();
return(newClientData);
}
private void SavePlayerAttributes(BitBuffer buffer)
{
var clientPort = buffer.GetInt();
var serverPort = buffer.GetInt();
var clientTime = buffer.GetFloat();
var displaySeq = buffer.GetInt();
var minBufferElems = buffer.GetByte();
var position = new Vector3();
var rotation = new Quaternion();
position.x = buffer.GetFloat();
position.y = buffer.GetFloat();
position.z = buffer.GetFloat();
rotation.w = buffer.GetFloat();
rotation.x = buffer.GetFloat();
rotation.y = buffer.GetFloat();
rotation.z = buffer.GetFloat();
var health = buffer.GetInt();
var speed = buffer.GetFloat();
var gravity = buffer.GetFloat();
PlayerPrefs.SetInt("ClientId", clientId);
PlayerPrefs.SetInt("ClientPort", clientPort);
PlayerPrefs.SetInt("ServerPort", serverPort);
PlayerPrefs.SetFloat("ClientTime", clientTime);
PlayerPrefs.SetInt("DisplaySequence", displaySeq);
PlayerPrefs.SetInt("MinInterpolationBufferElements", minBufferElems);
PlayerPrefs.SetFloat("ClientPosX", position.x);
PlayerPrefs.SetFloat("ClientPosY", position.y);
PlayerPrefs.SetFloat("ClientPosZ", position.z);
PlayerPrefs.SetFloat("ClientRotW", rotation.w);
PlayerPrefs.SetFloat("ClientRotX", rotation.x);
PlayerPrefs.SetFloat("ClientRotY", rotation.y);
PlayerPrefs.SetFloat("ClientRotZ", rotation.z);
PlayerPrefs.SetInt("ClientHealth", health);
PlayerPrefs.SetFloat("PlayerSpeed", speed);
PlayerPrefs.SetFloat("Gravity", gravity);
SaveConnectedPlayersAttributes(buffer);
PlayerPrefs.Save();
}
private void DeserializeSnapshot(BitBuffer buffer)
{
var recvFrameSeq = buffer.GetInt();
if (recvFrameSeq < displaySeq)
{
return; // Check if received snapshot is old
}
var time = buffer.GetFloat();
var recvCmdSeq = buffer.GetInt();
var recvVelY = buffer.GetFloat();
var playerCount = buffer.GetByte();
var positions = new Dictionary <int, Vector3>();
var rotations = new Dictionary <int, Quaternion>();
for (int i = 0; i < playerCount; i++)
{
var position = new Vector3();
var rotation = new Quaternion();
var playerId = buffer.GetInt();
position.x = buffer.GetFloat();
position.y = buffer.GetFloat();
position.z = buffer.GetFloat();
rotation.w = buffer.GetFloat();
rotation.x = buffer.GetFloat();
rotation.y = buffer.GetFloat();
rotation.z = buffer.GetFloat();
positions.Add(playerId, position);
rotations.Add(playerId, rotation);
if (playerId == clientId)
{
Conciliate(recvCmdSeq, position, recvVelY);
}
}
var snapshot = new Snapshot(recvFrameSeq, time, positions, rotations);
StoreSnapshot(snapshot, recvFrameSeq);
}
private void DeserializeBuffer(BitBuffer buffer)
{
var messageType = (PacketType)buffer.GetByte();
switch (messageType)
{
case PacketType.Snapshot:
DeserializeSnapshot(buffer);
break;
case PacketType.CommandsAck:
{
var receivedAckSequence = DeserializeCommandAck(buffer);
RemoveAckedCommands(receivedAckSequence);
break;
}
case PacketType.PlayerJoined:
DeserializePlayerJoined(buffer);
break;
case PacketType.PlayerShotAck:
var rcvdShotSequence = DeserializeShotAck(buffer);
RemoveAckedShots(rcvdShotSequence);
break;
case PacketType.PlayerShotBroadcast:
DeserializeShotBroadcast(buffer);
break;
case PacketType.PlayerRespawn:
DeserializePlayerRespawn(buffer);
break;
case PacketType.PlayerDisconnectBroadcast:
DeserializePlayerDisconnectBroadcast(buffer);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static ServerResponse fromBytes(BitBuffer bitBuffer)
{
ResponseType type = (ResponseType)bitBuffer.GetByte();
switch (type)
{
case ResponseType.PLAYER_UPDATE:
return(PlayerInfoUpdate.FromBytes(bitBuffer));
case ResponseType.ABILITY:
return(AbilityResponse.FromBytes(bitBuffer));
case ResponseType.NEW_PLAYER:
return(NewPlayerEvent.FromBytes(bitBuffer));
case ResponseType.PLAYER_INFO_BROADCAST:
return(PlayerInfoBroadcast.FromBytes(bitBuffer));
case ResponseType.RESPONSES_CONTAINER:
return(ResponsesContainer.FromBytes(bitBuffer));
}
return(null);
}
public static int PlayerConnectDeserialize(BitBuffer buffer)
{
buffer.GetByte(); // PlayerConnect
return(buffer.GetInt());
}
public static AbilityInput FromBytes(int id, BitBuffer bitBuffer)
{
return(new AbilityInput(id, (AbilityType)bitBuffer.GetByte(), PositionInfo.FromBytes(bitBuffer)));
}
private void ProcessResponse(BitBuffer bitBuffer)
{
ServerResponse response = ServerResponse.fromBytes(bitBuffer);
switch (response.GetResponseType())
{
case ResponseType.PLAYER_UPDATE: {
PlayerInfoUpdate playerUpdate = (PlayerInfoUpdate)response;
PlayerInfo playerInfo = playerUpdate.GetPlayerInfo();
if (_players.ContainsKey(playerInfo.GetId()))
{
_players [playerInfo.GetId()].SetTargetPosition(playerInfo.GetPosition());
_players [playerInfo.GetId()].SetHealth(playerInfo.GetHealth());
}
break;
}
case ResponseType.ABILITY: {
AbilityResponse auto = (AbilityResponse)response;
switch (auto.GetAbilityType())
{
case AbilityType.AUTOATTACK:
SpawnAutoAttack(auto.GetId(), auto.GetStartPosition(), auto.GetPosition());
break;
case AbilityType.FREEZE:
_players[auto.GetId()].SpawnFreeze(auto.GetPosition());
break;
case AbilityType.FLASH:
_players[auto.GetId()].MoveTo(auto.GetPosition());
_players[auto.GetId()].CancelMovement();
break;
case AbilityType.EXPLOSION:
CreateExplosion(auto.GetPosition());
break;
}
break;
}
case ResponseType.NEW_PLAYER: {
NewPlayerEvent newPlayerEvent = (NewPlayerEvent)response;
PlayerInfo playerInfo = newPlayerEvent.GetPlayerInfo();
Player player = CreatePlayer(playerInfo);
_players.Add(playerInfo.GetId(), player);
break;
}
case ResponseType.PLAYER_INFO_BROADCAST: {
PlayerInfoBroadcast playerInfoBroadcast = (PlayerInfoBroadcast)response;
_localId = playerInfoBroadcast.GetId();
foreach (PlayerInfo playerInfo in playerInfoBroadcast.getPlayersInfo())
{
Player player = CreatePlayer(playerInfo);
_players.Add(playerInfo.GetId(), player);
}
break;
}
case ResponseType.RESPONSES_CONTAINER: {
byte[] responses = ((ResponsesContainer)response).GetData();
BitBuffer containerBuffer = new BitBuffer();
containerBuffer.PutBytes(responses);
containerBuffer.Flip();
int totalResponses = containerBuffer.GetByte();
for (int i = 0; i < totalResponses; i++)
{
ProcessResponse(containerBuffer);
}
break;
}
}
}
