public void SetPlayerStateUpdatesReceivedFromServer(PlayerStateUpdates playerStateUpdates)
{
clientPlayer.SetActorPositionalState(playerStateUpdates.positionUpdates);
clientPlayer.SetActorEventActionState(playerStateUpdates.playerEvents);
clientPlayer.SetActorAnimationState(playerStateUpdates.playerAnimationEvents);
clientPlayer.SetAuthoratativeStates(playerStateUpdates.playerAuthoratativeStates);
if (hasAuthority)
{
localPlayer.SetAuthoratativeStates(playerStateUpdates.playerAuthoratativeStates);
if (localPlayer.isPetrified || localPlayer.isPushed)
{
localPlayer.SetActorPositionalState(playerStateUpdates.positionUpdates);
}
serverPlayer.SetActorPositionalState(playerStateUpdates.positionUpdates);
serverPlayer.SetActorEventActionState(playerStateUpdates.playerEvents);
serverPlayer.SetActorAnimationState(playerStateUpdates.playerAnimationEvents);
serverPlayer.SetAuthoratativeStates(playerStateUpdates.playerAuthoratativeStates);
UpdateServerPredictedPosition(playerStateUpdates);
if (Vector3.Distance(serverPlayer.actorTransform.position, localPlayer.actorTransform.position) >= positionThreshold)
{
Debug.Log(serverPlayer.actorTransform.position + "local---server" + localPlayer.actorTransform.position + "<color=red>Corrected player position</color>" + playerStateUpdates.playerProcessedSequenceNumber);
Debug.Break();
PositionUpdates positionUpdates = new PositionUpdates(serverPlayer.actorTransform.position, serverPlayer.currentMovePointCellPosition, serverPlayer.previousMovePointCellPosition);
localPlayer.SetActorPositionalState(positionUpdates);
}
}
else
{
clientPlayer.ProcessInputEventControl();
clientPlayer.ProcessInputAnimationControl();
}
}
//authoratatively is performed(but is locally is also done)-correction happens
public void SetActorPositionalState(PositionUpdates positionUpdates)
{
actorTransform.position = positionUpdates.updatedActorPosition;
currentMovePointCellPosition = positionUpdates.updatedBlockActorPosition;
previousMovePointCellPosition = positionUpdates.updatedPreviousBlockActorPosition;
Facing = GridManager.instance.GetFaceDirectionFromCurrentPrevPoint(currentMovePointCellPosition, previousMovePointCellPosition, this);
}
public static void SpawnedPlayer(Packet packet)
{
int id = packet.ReadInt();
string username = packet.ReadString();
Vector3 position = packet.ReadVector3();
Vector3Int blockposition = packet.ReadVector3Int();
Vector3Int previousBlockposition = packet.ReadVector3Int();
bool isFiringPrimaryProjectile = packet.ReadBool();
bool isPrimaryMoveAnimationBeingPlayed = packet.ReadBool();
bool isPlacingBoulderAnimationPlayed = packet.ReadBool();
bool isPetrified = packet.ReadBool();
bool isPushed = packet.ReadBool();
int faceDirection = packet.ReadInt();
int previousfaceDirection = packet.ReadInt();
int playerProcessingSequenceNumber = packet.ReadInt();
int playerServerSequenceNumber = packet.ReadInt();
Debug.Log("<color=red>Sequence no spawned on: </color>" + playerProcessingSequenceNumber);
PositionUpdates positionUpdates = new PositionUpdates(position, blockposition, previousBlockposition);
PlayerEvents playerEvents = new PlayerEvents(isFiringPrimaryProjectile);
PlayerAnimationEvents playerAnimtaionEvents = new PlayerAnimationEvents(isPrimaryMoveAnimationBeingPlayed, isPlacingBoulderAnimationPlayed);
PlayerAuthoratativeStates playerAuthoratativeStates = new PlayerAuthoratativeStates(isPetrified, isPushed);
PlayerStateUpdates playerStateUpdates = new PlayerStateUpdates(playerServerSequenceNumber, playerProcessingSequenceNumber, playerAuthoratativeStates, positionUpdates, playerEvents, playerAnimtaionEvents);
ClientSideGameManager.instance.SpawnPlayer(id, username, faceDirection, previousfaceDirection, playerStateUpdates);
}
public PlayerStateUpdates(int playerServerSequenceNumber, int playerProcessedSequenceNumber, PlayerAuthoratativeStates playerAuthoratativeStates, PositionUpdates positionUpdates, PlayerEvents playerEvents, PlayerAnimationEvents playerAnimationEvents)
{
this.playerServerSequenceNumber = playerServerSequenceNumber;
this.playerProcessedSequenceNumber = playerProcessedSequenceNumber;
this.positionUpdates = positionUpdates;
this.playerEvents = playerEvents;
this.playerAuthoratativeStates = playerAuthoratativeStates;
this.playerAnimationEvents = playerAnimationEvents;
}
private void FixedUpdate()
{
//Remote clients
for (int i = 0; i < (int)currentStateProcessingModeOnClient; i++)
{
PlayerStateUpdates updateCorrespondingToSeq;
if (playerStateUpdatesDic.TryGetValue(serverSequenceNumberToBeProcessed + 1, out updateCorrespondingToSeq))
{
//Debug.Log("<color=yellow>Remote Client of id "+id+" is Processing seqence no </color>" + updateCorrespondingToSeq.playerServerSequenceNumber+" and the processed sequence no: "+ updateCorrespondingToSeq.playerProcessedSequenceNumber);
playerStateUpdatesDic.Remove(updateCorrespondingToSeq.playerServerSequenceNumber);
serverSequenceNumberToBeProcessed = updateCorrespondingToSeq.playerServerSequenceNumber;
playerSequenceNumberProcessed = updateCorrespondingToSeq.playerProcessedSequenceNumber;
latestPlayerStateUpdate = updateCorrespondingToSeq;
PositionUpdates positionUpdates = new PositionUpdates(updateCorrespondingToSeq.positionUpdates.updatedActorPosition
, updateCorrespondingToSeq.positionUpdates.updatedBlockActorPosition
, updateCorrespondingToSeq.positionUpdates.updatedPreviousBlockActorPosition);
PlayerEvents playerEvents = new PlayerEvents(updateCorrespondingToSeq.playerEvents.firedPrimaryMoveProjectile);
PlayerAnimationEvents playerAnimtaionEvents = new PlayerAnimationEvents(updateCorrespondingToSeq.playerAnimationEvents.isPrimaryMoveAnimationBeingPlayed
, updateCorrespondingToSeq.playerAnimationEvents.isPlacingBoulderAnimationPlayed);
PlayerAuthoratativeStates playerAuthoratativeStates = new PlayerAuthoratativeStates(updateCorrespondingToSeq.playerAuthoratativeStates.isPetrified
, updateCorrespondingToSeq.playerAuthoratativeStates.isPushed);
PlayerStateUpdates playerStateUpdates = new PlayerStateUpdates(serverSequenceNumberToBeProcessed
, playerSequenceNumberProcessed
, playerAuthoratativeStates
, positionUpdates
, playerEvents
, playerAnimtaionEvents);
SetPlayerStateUpdatesReceivedFromServer(playerStateUpdates);
}
else
{
if (latestPlayerStateUpdate.playerServerSequenceNumber != 0)
{
serverSequenceNumberToBeProcessed = serverSequenceNumberToBeProcessed + 1;
PlayerStateUpdates playerStateUpdates = new PlayerStateUpdates(serverSequenceNumberToBeProcessed
, latestPlayerStateUpdate.playerProcessedSequenceNumber
, latestPlayerStateUpdate.playerAuthoratativeStates
, latestPlayerStateUpdate.positionUpdates
, latestPlayerStateUpdate.playerEvents
, latestPlayerStateUpdate.playerAnimationEvents);
SetPlayerStateUpdatesReceivedFromServer(playerStateUpdates);
}
Debug.LogError("latestPlayerStateUpdate.playerServerSequenceNumber " + latestPlayerStateUpdate.playerServerSequenceNumber);
Debug.LogError("Could not find any posudates for seq: " + (serverSequenceNumberToBeProcessed + 1));
}
}
if (hasAuthority)
{
bool[] inputs = new bool[]
{
localInputController.up,
localInputController.left,
localInputController.down,
localInputController.right,
localInputController.shoot,
localInputController.push,
localInputController.placeORRemovalBoulder
};
localSequenceNumber++;
ProcessInputsLocally(inputs, previousInputs);
RecordLocalClientActions(localSequenceNumber, inputs, previousInputs);
//////Debug.Log("<color=blue>inputsequence </color>"+ playerMovingCommandSequenceNumber + "<color=blue>inputs </color> "+ inputs[0]+" "+inputs[1]+" "+inputs[2]+" "+inputs[3]);
inputCommandsToBeSentToServerCollection.Add(new InputCommands(inputs, previousInputs, localSequenceNumber));
previousInputs = inputs;
//Local client sending data
if (inputCommandsToBeSentToServerCollection.Count >= snapShotsInOnePacket)
{
if (previousHistoryForInputCommandsToBeSentToServerCollection.Count > packetHistorySize)
{
previousHistoryForInputCommandsToBeSentToServerCollection.RemoveAt(0);
}
ClientSend.PlayerInput(inputCommandsToBeSentToServerCollection, previousHistoryForInputCommandsToBeSentToServerCollection);
previousHistoryForInputCommandsToBeSentToServerCollection.Add(new PreviousInputPacks(inputCommandsToBeSentToServerCollection.ToArray()));
inputCommandsToBeSentToServerCollection.Clear();
//Debug.Log("<color=red>--------------------------------------------------------------------</color>");
}
}
UpdateProcessMode();
snapShotBufferSize = GetTheLastestSequenceNoInDic() - serverSequenceNumberToBeProcessed;
//Debug.Log("<color=cyan>Dic Count </color>" + positionUpdates.Count);
}
public Client(string host, int tcpPort, int udpPort)
{
NetworkBridge.Log("Creating client...");
Socket = new Socket(host, tcpPort, udpPort);
Current = this;
Side.NetworkSide = Side.Client;
Thread tcpThread = new Thread(() => {
Stream tcp = Socket.Tcp.GetStream();
while (!Closed)
{
// NetworkBridge.Log("Waiting to read TCP...");
byte[] raw = new byte[Socket.PacketSize];
int read = tcp.Read(raw, 0, raw.Length);
byte[] trim = new byte[read];
Array.Copy(raw, 0, trim, 0, trim.Length);
if (Closed)
{
break;
}
ByteBuffer bufIn = new ByteBuffer(trim);
// bufIn.Debug(0, bufIn.Length);
// NetworkBridge.Log("Sub-Buffers: ");
List <ByteBuffer> buffers = new List <ByteBuffer>();
while (bufIn.Pointer != bufIn.Length)
{
int len = bufIn.ReadInt();
ByteBuffer buf = new ByteBuffer(bufIn.ReadBytes(len));
// buf.Debug(0, buf.Length);
buffers.Add(buf);
}
try {
// Debug.Log("Executing buffers: ");
foreach (ByteBuffer buffer in buffers)
{
// buffer.Debug(0, buffer.Length);
NetworkData.HandleClientData(buffer);
}
} catch (Exception e) {
NetworkBridge.Invoke(() => Debug.LogException(e));
}
}
});
tcpThread.IsBackground = true;
tcpThread.Start();
Thread udpThread = new Thread(() => {
while (IsConnected)
{
byte[] raw = Socket.Udp.Receive(ref Socket.UdpRemote);
ByteBuffer bufIn = new ByteBuffer(raw);
try {
NetworkData.HandleClientData(bufIn);
} catch (Exception e) {
Debug.LogException(e);
}
}
});
udpThread.IsBackground = true;
udpThread.Start();
Thread authThread = new Thread(() => {
Thread.Sleep(100);
Out.WriteByte(NetworkData.Management);
Out.WriteByte(NetworkData.Authenticate);
WriteTcp();
NetworkBridge.Log("Wrote authentication information.");
});
authThread.IsBackground = true;
authThread.Start();
OnAuthenticate += (sender, args) => {
Thread updateThread = new Thread(() => {
while (IsConnected)
{
lock (UdpBuffers) {
if (UdpBuffers.Count > 0)
{
WriteUdp();
UdpBuffers.Clear();
PositionUpdates.Clear();
RotationUpdates.Clear();
ScaleUpdates.Clear();
}
}
Thread.Sleep((int)(1000 / (float)TickRate));
}
});
updateThread.IsBackground = true;
updateThread.Start();
};
}
private void FixedUpdate()
{
serverInstanceHero.ProcessAuthoratativeEvents();
for (int i = 0; i < (int)currentInputProcessingModeOnServer; i++)
{
CheckForPushRequestOnServer(playerSequenceNumberProcessed + 1);
CheckForPlaceBoulderRequestOnServer(playerSequenceNumberProcessed + 1);
CheckForRemovingBoulderRequestOnServer(playerSequenceNumberProcessed + 1);
CheckForPetrificationRequestOnPlayer(playerSequenceNumberProcessed + 1);
InputCommands inputPackageCorrespondingToSeq;
if (inputUpdatesFromClientToServerDic.TryGetValue(playerSequenceNumberProcessed + 1, out inputPackageCorrespondingToSeq))
{
inputUpdatesFromClientToServerDic.Remove(inputPackageCorrespondingToSeq.sequenceNumber);
latestPlayerInputPackage = inputPackageCorrespondingToSeq;
playerSequenceNumberProcessed = inputPackageCorrespondingToSeq.sequenceNumber;
serverInstanceHero.ProcessMovementInputs(inputPackageCorrespondingToSeq.commands
, inputPackageCorrespondingToSeq.previousCommands);
serverInstanceHero.ProcessEventsInputs(inputPackageCorrespondingToSeq.commands, inputPackageCorrespondingToSeq.previousCommands);
serverInstanceHero.ProcessAnimationsInputs(inputPackageCorrespondingToSeq.commands, inputPackageCorrespondingToSeq.previousCommands);
serverInstanceHero.ProcessInputMovementsControl();
serverInstanceHero.ProcessInputEventControl();
serverInstanceHero.ProcessInputAnimationControl();
//Debug.Log(serverInstanceHero.movePoint.position + "Block pos "+serverInstanceHero.GetBlockPosition()+"<color=yellow>Processing seqence no </color>" + inputPackageCorrespondingToSeq.sequenceNumber + "<color=green>position </color>" + serverInstanceHero.actorTransform.position + "<color=green>inputs </color>" + inputPackageCorrespondingToSeq.commands[0] + inputPackageCorrespondingToSeq.commands[1] + inputPackageCorrespondingToSeq.commands[2] + inputPackageCorrespondingToSeq.commands[3]+" Previous Commands "+ inputPackageCorrespondingToSeq.previousCommands[0] + inputPackageCorrespondingToSeq.previousCommands[1] + inputPackageCorrespondingToSeq.previousCommands[2] + inputPackageCorrespondingToSeq.previousCommands[3]);
}
else
{
if (latestPlayerInputPackage.sequenceNumber != 0)
{
//Debug.LogError("Could not find any inputToProcess for seq: " + (sequenceNumberProcessed + 1));
playerSequenceNumberProcessed = playerSequenceNumberProcessed + 1;
serverInstanceHero.ProcessMovementInputs(latestPlayerInputPackage.commands
, latestPlayerInputPackage.previousCommands);
serverInstanceHero.ProcessEventsInputs(latestPlayerInputPackage.commands, latestPlayerInputPackage.previousCommands);
serverInstanceHero.ProcessAnimationsInputs(latestPlayerInputPackage.commands, latestPlayerInputPackage.previousCommands);
serverInstanceHero.ProcessInputMovementsControl();
serverInstanceHero.ProcessInputEventControl();
serverInstanceHero.ProcessInputAnimationControl();
}
}
}
serverLocalSequenceNumber++;
//////Debug.Log("<color=blue>inputsequence </color>"+ playerMovingCommandSequenceNumber + "<color=blue>inputs </color> "+ inputs[0]+" "+inputs[1]+" "+inputs[2]+" "+inputs[3]);
PlayerAuthoratativeStates playerAuthoratativeStates = new PlayerAuthoratativeStates(serverInstanceHero.isPetrified, serverInstanceHero.isPushed);
PositionUpdates positionUpdates = new PositionUpdates(serverInstanceHero.actorTransform.position, serverInstanceHero.currentMovePointCellPosition, serverInstanceHero.previousMovePointCellPosition);
PlayerEvents playerEvents = new PlayerEvents(serverInstanceHero.isFiringPrimaryProjectile);
PlayerAnimationEvents playerAnimationEvents = new PlayerAnimationEvents(serverInstanceHero.primaryMoveUseAnimationAction.isBeingUsed, serverInstanceHero.isPlacingBoulderAnimationPlayed);
PlayerStateUpdates playerStateUpdates = new PlayerStateUpdates(serverLocalSequenceNumber, playerSequenceNumberProcessed, playerAuthoratativeStates, positionUpdates, playerEvents, playerAnimationEvents);
PlayerStateServerUpdates playerStateServerUpdates = new PlayerStateServerUpdates(id, playerStateUpdates);
//Debug.LogError("Server sequence number : "+ serverLocalSequenceNumber+" player sequence number processeed: "+ playerSequenceNumberProcessed+" player position : "+serverInstanceHero.actorTransform.position);
playerStateListOnServer.Add(playerStateServerUpdates);
if (playerStateListOnServer.Count >= snapShotsInOnePacket)
{
if (previousPlayerUpdatedStatePacks.Count > packetHistorySize)
{
previousPlayerUpdatedStatePacks.RemoveAt(0);
}
ServerSend.PlayerStateSend(playerStateListOnServer, previousPlayerUpdatedStatePacks);
previousPlayerUpdatedStatePacks.Add(new PreviousPlayerUpdatedStatePacks(playerStateListOnServer.ToArray()));
playerStateListOnServer.Clear();
//Debug.Log("<color=red>--------------------------------------------------------------------</color>");
}
UpdateClientInputsProcessMode();
snapShotBufferSize = GetTheLastestSequenceNoInDic() - playerSequenceNumberProcessed;
//Debug.Log("<color=cyan>Dic Count </color>"+inputUpdatesFromClientToServerDic.Count);
}
public static void PlayerStateUpdated(Packet packet)
{
int dataCount = packet.ReadInt();
for (int i = 0; i < dataCount; i++)
{
int id = packet.ReadInt();
Vector3 position = packet.ReadVector3();
Vector3Int blockposition = packet.ReadVector3Int();
Vector3Int previousBlockposition = packet.ReadVector3Int();
bool isFiringPrimaryProjectile = packet.ReadBool();
bool isPrimaryMoveAnimationBeingPlayed = packet.ReadBool();
bool isPlacingBoulderAnimationPlayed = packet.ReadBool();
bool isPetrified = packet.ReadBool();
bool isPushed = packet.ReadBool();
int playerProcessedsequenceNumberReceived = packet.ReadInt();
int playerServerSequenceNumberReceived = packet.ReadInt();
PositionUpdates positionUpdates = new PositionUpdates(position, blockposition, previousBlockposition);
PlayerEvents playerEvents = new PlayerEvents(isFiringPrimaryProjectile);
PlayerAnimationEvents playerAnimtaionEvents = new PlayerAnimationEvents(isPrimaryMoveAnimationBeingPlayed, isPlacingBoulderAnimationPlayed);
PlayerAuthoratativeStates playerAuthoratativeStates = new PlayerAuthoratativeStates(isPetrified, isPushed);
PlayerStateUpdates playerStateUpdates = new PlayerStateUpdates(playerServerSequenceNumberReceived, playerProcessedsequenceNumberReceived, playerAuthoratativeStates, positionUpdates, playerEvents, playerAnimtaionEvents);
//Debug.LogError("<color=blue>Receiving updated position for movement </color>playerUpdatedPositionSequenceNumber: " + sequenceNumberReceived + " position: " + position);
if (ClientSideGameManager.players.ContainsKey(id))
{
ClientSideGameManager.players[id].masterController.AccumulateDataToBePlayedOnClientFromServer(playerStateUpdates);
}
else
{
Debug.LogError("Player of id doesnot exists: " + id);
}
//if (!ClientSideGameManager.players[id].masterController.hasAuthority)
//{
// Debug.LogWarning("<color=red>Receiving remote player data</color>"+sequenceNumberReceived);
//}
//else
//{
// Debug.LogWarning("<color=green>Receiving my player data</color>"+sequenceNumberReceived);
//}
}
int previousPlayerUpdatedPositionPacks = packet.ReadInt();
for (int i = 0; i < previousPlayerUpdatedPositionPacks; i++)
{
int previousPlayerUpdatedPositionPacksCount = packet.ReadInt();
for (int j = 0; j < previousPlayerUpdatedPositionPacksCount; j++)
{
int previousHistoryPlayerId = packet.ReadInt();
Vector3 previousHistoryPositionUpdate = packet.ReadVector3();
Vector3Int previousHistoryBlockPositionUpdate = packet.ReadVector3Int();
Vector3Int previousHistoryPreviousBlockPositionUpdate = packet.ReadVector3Int();
bool isFiringPrimaryProjectile = packet.ReadBool();
bool isPrimaryMoveAnimationBeingPlayed = packet.ReadBool();
bool isPlacingBoulderAnimationPlayed = packet.ReadBool();
bool isPetrified = packet.ReadBool();
bool isPushed = packet.ReadBool();
int previousHistoryPlayerProcessingSequenceNo = packet.ReadInt();
int previousHistoryServerSequenceNo = packet.ReadInt();
PositionUpdates positionUpdates = new PositionUpdates(previousHistoryPositionUpdate, previousHistoryBlockPositionUpdate, previousHistoryPreviousBlockPositionUpdate);
PlayerEvents playerEvents = new PlayerEvents(isFiringPrimaryProjectile);
PlayerAnimationEvents playerAnimtaionEvents = new PlayerAnimationEvents(isPrimaryMoveAnimationBeingPlayed, isPlacingBoulderAnimationPlayed);
PlayerAuthoratativeStates playerAuthoratativeStates = new PlayerAuthoratativeStates(isPetrified, isPushed);
PlayerStateUpdates playerStateUpdates = new PlayerStateUpdates(previousHistoryServerSequenceNo, previousHistoryPlayerProcessingSequenceNo, playerAuthoratativeStates, positionUpdates, playerEvents, playerAnimtaionEvents);
if (ClientSideGameManager.players.ContainsKey(previousHistoryPlayerId))
{
ClientSideGameManager.players[previousHistoryPlayerId].masterController.AccumulateDataToBePlayedOnClientFromServer(playerStateUpdates);
}
else
{
Debug.LogError("Player of id doesnot exists: " + previousHistoryPlayerId);
}
}
}
}
