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);
}
void Awake()
{
rigidbody = GetComponent <Rigidbody>();
animator = mesh.GetComponent <Animator>();
playerAnimationEvents = mesh.GetComponent <PlayerAnimationEvents>();
}
public void SetActorAnimationState(PlayerAnimationEvents playerAnimationEvents)
{
primaryMoveUseAnimationAction.isBeingUsed = playerAnimationEvents.isPrimaryMoveAnimationBeingPlayed;
isPlacingBoulderAnimationPlayed = playerAnimationEvents.isPlacingBoulderAnimationPlayed;
}
private void Awake()
{
_weapon = GetComponent <TracerMeleeWeapon>();
_events = GetComponentInParent <PlayerAnimationEvents>();
_events.EventTriggered += _events_EventTriggered;
}
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);
}
}
}
}
