public static void Welcome(Packet packet)
{
string msg = packet.ReadString();
int myId = packet.ReadInt();
Debug.Log("Message from server Connecting the endpioing for udp path......................................" + msg);
Client.instance.myID = myId;
//Send welcome packet receive ack
ClientSend.WelcomeReceived();
Client.instance.udp.Connect(((IPEndPoint)Client.instance.tcp.socket.Client.LocalEndPoint).Port);
}
public void ChangeCharacter(string hero)
{
EnumData.Heroes heroEnum = (EnumData.Heroes)Enum.Parse(typeof(EnumData.Heroes), hero);
if (clientlocalActor != null)
{
if (heroEnum != (EnumData.Heroes)clientlocalActor.hero)
{
CharacterChangeCommand characterChangeCommand = new CharacterChangeCommand(clientlocalActor.GetLocalSequenceNo(), (int)heroEnum);
ClientSend.ChangeCharacter(characterChangeCommand);
}
else
{
Debug.Log("Cant change character");
}
}
}
public void SpawnServerProjectiles()
{
if (itemToCast.usableItemType == EnumData.UsableItemTypes.TidalWave)
{
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, GridManager.instance.grid.WorldToCell(actorTransform.position));
ClientSend.SpawnItemCommand(spawnItemCommand);
isFiringServerProjectiles = true;
onCompletedMotionToPoint = () => { isFiringServerProjectiles = false; onCompletedMotionToPoint = null; };
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.BubbleShield)
{
if (bubbleShieldAttackReady)
{
waitingActionForBubbleShieldItemMove.ReInitialiseTimerToBegin(GameConfig.bubbleShieldItemMoveAttackRateTickRate);
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, GridManager.instance.grid.WorldToCell(actorTransform.position));
ClientSend.SpawnItemCommand(spawnItemCommand);
isFiringServerProjectiles = true;
onCompletedMotionToPoint = () => { isFiringServerProjectiles = false; onCompletedMotionToPoint = null; };
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.MightyWind)
{
if (IsHeroAbleToFireProjectiles())
{
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, GridManager.instance.grid.WorldToCell(actorTransform.position));
ClientSend.SpawnItemCommand(spawnItemCommand);
isFiringServerProjectiles = true;
onCompletedMotionToPoint = () => { isFiringServerProjectiles = false; onCompletedMotionToPoint = null; };
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.FlamePillar)
{
if (IsHeroAbleToFireProjectiles())
{
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, GridManager.instance.grid.WorldToCell(actorTransform.position));
ClientSend.SpawnItemCommand(spawnItemCommand);
isFiringServerProjectiles = true;
onCompletedMotionToPoint = () => { isFiringServerProjectiles = false; onCompletedMotionToPoint = null; };
}
}
}
public void SpawnItem()
{
if (itemToCast.usableItemType == EnumData.UsableItemTypes.Minion)
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheckFor) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.GameObjectEnums.BoulderAppearing, EnumData.GameObjectEnums.BoulderDisappearing))
{
//send command to server of placement
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, cellToCheckFor);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.PermamnentBlock)
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheckFor) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.GameObjectEnums.BoulderAppearing, EnumData.GameObjectEnums.BoulderDisappearing))
{
//send command to server of placement
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, cellToCheckFor);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.CereberausHead)
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheckFor) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.GameObjectEnums.BoulderAppearing, EnumData.GameObjectEnums.BoulderDisappearing))
{
//send command to server of placement
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, cellToCheckFor);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.Boulder)
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheckFor) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.TileType.NoBoulder) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.GameObjectEnums.BoulderAppearing))
{
//send command to server of placement
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, cellToCheckFor);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.ArrowDirectional)
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheckFor) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.GameObjectEnums.BoulderAppearing))
{
//send command to server of placement
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, cellToCheckFor);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.MirrorItem)
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheckFor) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.GameObjectEnums.BoulderAppearing))
{
//send command to server of placement
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, cellToCheckFor);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.GorgonGlass)
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheckFor) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.GameObjectEnums.BoulderAppearing))
{
//send command to server of placement
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, cellToCheckFor);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.Pitfall)
{
Vector3Int cellToCheck = GridManager.instance.grid.WorldToCell(actorTransform.position + 2 * GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (GridManager.instance.HasTileAtCellPoint(cellToCheck, EnumData.TileType.Normal))
{
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, Vector3Int.zero);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.Earthquake)
{
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, Vector3Int.zero);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.Tornado)
{
Vector3Int cellToCheck = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheck))
{
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, Vector3Int.zero);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.Portal)
{
Vector3Int cellToCheck = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheck))
{
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, Vector3Int.zero);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.AeloianMight)
{
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, Vector3Int.zero);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
else if (itemToCast.usableItemType == EnumData.UsableItemTypes.QuickSand)
{
SpawnItemCommand spawnItemCommand = new SpawnItemCommand(GetLocalSequenceNo(), (int)Facing, (int)itemToCast.usableItemType, Vector3Int.zero);
ClientSend.SpawnItemCommand(spawnItemCommand);
}
}
public override void ProcessEventsInputs(bool[] inputs, bool[] previousInputs)
{
if (!isInFlyingState)
{
if (itemToCast != null && itemToCast.castableItemType == EnumData.CastItemTypes.ClientProjectiles)
{
if (itemToCast.itemCount > 0 && inputs[(int)EnumData.PosidannaInputs.UseItem])
{
SpawnClientProjectiles();
}
else if (itemToCast.itemCount <= 0 || (!inputs[(int)EnumData.PosidannaInputs.UseItem] && previousInputs[(int)EnumData.PosidannaInputs.UseItem] != inputs[(int)EnumData.PosidannaInputs.UseItem]))
{
ResetClientProjectilesVars();
}
}
}
bool secondaryAttackReady = !waitingActionForSecondaryMove.Perform();
if (!MultiplayerManager.instance.isServer && hasAuthority())
{
if (completedMotionToMovePoint)
{
if (isInFlyingState)
{
if (inputs[(int)EnumData.PosidannaInputs.LandPlayer] && previousInputs[(int)EnumData.PosidannaInputs.LandPlayer] != inputs[(int)EnumData.PosidannaInputs.LandPlayer])
{
if (isInFlyingState)
{
//land here
flyingTickCountTemp = 0;
LandPlayerCommand landPlayerCommand = new LandPlayerCommand(GetLocalSequenceNo());
ClientSend.LandPlayer(landPlayerCommand);
}
}
}
else
{
if (inputs[(int)EnumData.PosidannaInputs.RespawnPlayer] && previousInputs[(int)EnumData.PosidannaInputs.RespawnPlayer] != inputs[(int)EnumData.PosidannaInputs.RespawnPlayer])
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position);
if (IsPlayerSpawnable(cellToCheckFor))
{
//Respawn player command
RespawnPlayerCommand respawnPlayerCommand = new RespawnPlayerCommand(GetLocalSequenceNo());
ClientSend.RespawnPlayer(respawnPlayerCommand);
}
else
{
Debug.LogError("Invalid location to spawn player");
}
}
else if (itemToCast != null && itemToCast.itemCount > 0 && itemToCast.castableItemType == EnumData.CastItemTypes.SpawnnableItems)
{
if (inputs[(int)EnumData.PosidannaInputs.UseItem] && previousInputs[(int)EnumData.PosidannaInputs.UseItem] != inputs[(int)EnumData.PosidannaInputs.UseItem])
{
SpawnItem();
}
}
}
}
bubbleShieldAttackReady = !waitingActionForBubbleShieldItemMove.Perform();
if (!isInFlyingState)
{
if (inputs[(int)EnumData.PosidannaInputs.ShootTidalWave] && previousInputs[(int)EnumData.PosidannaInputs.ShootTidalWave] != inputs[(int)EnumData.PosidannaInputs.ShootTidalWave])
{
FireTidalWaveCommand fireTidalWaveCommand = new FireTidalWaveCommand(GetLocalSequenceNo(), GridManager.instance.grid.WorldToCell(actorTransform.position));
ClientSend.FireTidalWave(fireTidalWaveCommand);
isFiringServerProjectiles = true;
onCompletedMotionToPoint = () => { isFiringServerProjectiles = false; onCompletedMotionToPoint = null; };
}
else if (inputs[(int)EnumData.PosidannaInputs.CastBubbleShield] && previousInputs[(int)EnumData.PosidannaInputs.CastBubbleShield] != inputs[(int)EnumData.PosidannaInputs.CastBubbleShield] && secondaryAttackReady)
{
waitingActionForSecondaryMove.ReInitialiseTimerToBegin(secondaryMoveAttackRateTickRate);
CastBubbleShieldCommand castBubbleShieldCommand = new CastBubbleShieldCommand(GetLocalSequenceNo(), GridManager.instance.grid.WorldToCell(actorTransform.position));
ClientSend.CastBubbleShield(castBubbleShieldCommand);
isFiringServerProjectiles = true;
onCompletedMotionToPoint = () => { isFiringServerProjectiles = false; onCompletedMotionToPoint = null; };
}
else if (itemToCast != null && itemToCast.itemCount > 0 && itemToCast.castableItemType == EnumData.CastItemTypes.ServerProjectiles)
{
if (inputs[(int)EnumData.PosidannaInputs.UseItem] && previousInputs[(int)EnumData.PosidannaInputs.UseItem] != inputs[(int)EnumData.PosidannaInputs.UseItem])
{
SpawnServerProjectiles();
}
}
}
}
}
public override void ProcessEventsInputs(bool[] inputs, bool[] previousInputs)
{
if (!isInFlyingState)
{
if (inputs[(int)EnumData.MedusaInputs.Shoot])
{
if (IsHeroAbleToFireProjectiles())
{
if (!waitingActionForPrimaryMove.Perform())
{
isFiringPrimaryProjectile = true;
waitingActionForPrimaryMove.ReInitialiseTimerToBegin(primaryMoveAttackRateTickRate);
}
else
{
isFiringPrimaryProjectile = false;
}
}
}
else if (!inputs[(int)EnumData.MedusaInputs.Shoot] && previousInputs[(int)EnumData.MedusaInputs.Shoot] != inputs[(int)EnumData.MedusaInputs.Shoot])
{
isFiringPrimaryProjectile = false;
waitingActionForPrimaryMove.ReInitialiseTimerToEnd(primaryMoveAttackRateTickRate);
}
else if (itemToCast != null && itemToCast.castableItemType == EnumData.CastItemTypes.ClientProjectiles)
{
if (itemToCast.itemCount > 0 && inputs[(int)EnumData.MedusaInputs.UseItem])
{
SpawnClientProjectiles();
}
else if (itemToCast.itemCount <= 0 || (!inputs[(int)EnumData.MedusaInputs.UseItem] && previousInputs[(int)EnumData.MedusaInputs.UseItem] != inputs[(int)EnumData.MedusaInputs.UseItem]))
{
ResetClientProjectilesVars();
}
}
}
if (!MultiplayerManager.instance.isServer && hasAuthority())
{
if (completedMotionToMovePoint)
{
if (isInFlyingState)
{
if (inputs[(int)EnumData.MedusaInputs.LandPlayer] && previousInputs[(int)EnumData.MedusaInputs.LandPlayer] != inputs[(int)EnumData.MedusaInputs.LandPlayer])
{
if (isInFlyingState)
{
//land here
flyingTickCountTemp = 0;
LandPlayerCommand landPlayerCommand = new LandPlayerCommand(GetLocalSequenceNo());
ClientSend.LandPlayer(landPlayerCommand);
}
}
}
else
{
if (inputs[(int)EnumData.MedusaInputs.RespawnPlayer] && previousInputs[(int)EnumData.MedusaInputs.RespawnPlayer] != inputs[(int)EnumData.MedusaInputs.RespawnPlayer])
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position);
if (IsPlayerSpawnable(cellToCheckFor))
{
//Respawn player command
RespawnPlayerCommand respawnPlayerCommand = new RespawnPlayerCommand(GetLocalSequenceNo());
ClientSend.RespawnPlayer(respawnPlayerCommand);
}
else
{
Debug.LogError("Invalid location to spawn player");
}
}
else if (inputs[(int)EnumData.MedusaInputs.Push] && previousInputs[(int)EnumData.MedusaInputs.Push] != inputs[(int)EnumData.MedusaInputs.Push])
{
Vector3Int cellPos = currentMovePointCellPosition + GridManager.instance.grid.WorldToCell(GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
Actor actorToPush = GridManager.instance.GetActorOnPos(cellPos);
if (actorToPush != null)
{
if (IsActorAbleToPush(Facing) && IsActorPushableInDirection(actorToPush, Facing))
{
//Send reliable request of push to server here
PushCommand pushCommand = new PushCommand(GetLocalSequenceNo(), (int)Facing, actorToPush.ownerId);
ClientSend.PushPlayerCommand(pushCommand);
}
}
ClientEnemyManager clientEnemy = GridManager.instance.GetClientEnemyOnPos(cellPos);
if (clientEnemy != null)
{
if (IsClientEnemyPushable(Facing))
{
PushCommand pushCommand = new PushCommand(GetLocalSequenceNo(), (int)Facing, clientEnemy.id);
ClientSend.PushPlayerCommand(pushCommand);
}
}
}
else if (inputs[(int)EnumData.MedusaInputs.PlaceRemovalBoulder] && previousInputs[(int)EnumData.MedusaInputs.PlaceRemovalBoulder] != inputs[(int)EnumData.MedusaInputs.PlaceRemovalBoulder])
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForSpawnObjectPlacementAtPos(cellToCheckFor) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.TileType.NoBoulder) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.GameObjectEnums.BoulderAppearing))
{
//send command to server of placement
PlaceBoulderCommand placeBoulderCommand = new PlaceBoulderCommand(GetLocalSequenceNo(), cellToCheckFor);
ClientSend.PlaceBoulderCommand(placeBoulderCommand);
}
else if (GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.TileType.Boulder) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.TileType.NoBoulder) && !GridManager.instance.HasTileAtCellPoint(cellToCheckFor, EnumData.GameObjectEnums.BoulderDisappearing))
{
RemoveBoulderCommand removeBoulderCommand = new RemoveBoulderCommand(GetLocalSequenceNo(), cellToCheckFor);
ClientSend.RemoveBoulderCommand(removeBoulderCommand);
}
}
else if (itemToCast != null && itemToCast.itemCount > 0 && itemToCast.castableItemType == EnumData.CastItemTypes.SpawnnableItems)
{
if (inputs[(int)EnumData.MedusaInputs.UseItem] && previousInputs[(int)EnumData.MedusaInputs.UseItem] != inputs[(int)EnumData.MedusaInputs.UseItem])
{
SpawnItem();
}
}
}
}
bubbleShieldAttackReady = !waitingActionForBubbleShieldItemMove.Perform();
if (!isInFlyingState)
{
if (itemToCast != null && itemToCast.itemCount > 0 && itemToCast.castableItemType == EnumData.CastItemTypes.ServerProjectiles)
{
if (inputs[(int)EnumData.MedusaInputs.UseItem] && previousInputs[(int)EnumData.MedusaInputs.UseItem] != inputs[(int)EnumData.MedusaInputs.UseItem])
{
SpawnServerProjectiles();
}
}
}
}
}
public override void ProcessEventsInputs(bool[] inputs, bool[] previousInputs)
{
if (!isInFlyingState)
{
if (itemToCast != null && itemToCast.castableItemType == EnumData.CastItemTypes.ClientProjectiles)
{
if (itemToCast.itemCount > 0 && inputs[(int)EnumData.ErmolaiInputs.UseItem])
{
SpawnClientProjectiles();
}
else if (itemToCast.itemCount <= 0 || (!inputs[(int)EnumData.ErmolaiInputs.UseItem] && previousInputs[(int)EnumData.ErmolaiInputs.UseItem] != inputs[(int)EnumData.ErmolaiInputs.UseItem]))
{
ResetClientProjectilesVars();
}
}
}
if (!MultiplayerManager.instance.isServer && hasAuthority())
{
if (completedMotionToMovePoint)
{
if (isInFlyingState)
{
if (inputs[(int)EnumData.ErmolaiInputs.LandPlayer] && previousInputs[(int)EnumData.ErmolaiInputs.LandPlayer] != inputs[(int)EnumData.ErmolaiInputs.LandPlayer])
{
if (isInFlyingState)
{
//land here
flyingTickCountTemp = 0;
LandPlayerCommand landPlayerCommand = new LandPlayerCommand(GetLocalSequenceNo());
ClientSend.LandPlayer(landPlayerCommand);
}
}
}
else
{
if (inputs[(int)EnumData.ErmolaiInputs.RespawnPlayer] && previousInputs[(int)EnumData.ErmolaiInputs.RespawnPlayer] != inputs[(int)EnumData.ErmolaiInputs.RespawnPlayer])
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position);
if (IsPlayerSpawnable(cellToCheckFor))
{
//Respawn player command
RespawnPlayerCommand respawnPlayerCommand = new RespawnPlayerCommand(GetLocalSequenceNo());
ClientSend.RespawnPlayer(respawnPlayerCommand);
}
else
{
Debug.LogError("Invalid location to spawn player");
}
}
else if (inputs[(int)EnumData.ErmolaiInputs.CastPitfall] && previousInputs[(int)EnumData.ErmolaiInputs.CastPitfall] != inputs[(int)EnumData.ErmolaiInputs.CastPitfall])
{
Vector3Int cellToCheck = GridManager.instance.grid.WorldToCell(actorTransform.position + 2 * GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (GridManager.instance.HasTileAtCellPoint(cellToCheck, EnumData.TileType.Normal))
{
CastPitfallCommand castPitfallCommand = new CastPitfallCommand(GetLocalSequenceNo(), (int)Facing);
ClientSend.CastPitfall(castPitfallCommand);
}
}
else if (inputs[(int)EnumData.ErmolaiInputs.CastEarthquake] && previousInputs[(int)EnumData.ErmolaiInputs.CastEarthquake] != inputs[(int)EnumData.ErmolaiInputs.CastEarthquake])
{
CastEarthQuakeCommand castEarthQuakeCommand = new CastEarthQuakeCommand(GetLocalSequenceNo());
ClientSend.CastEarthQuake(castEarthQuakeCommand);
}
else if (itemToCast != null && itemToCast.itemCount > 0 && itemToCast.castableItemType == EnumData.CastItemTypes.SpawnnableItems)
{
if (inputs[(int)EnumData.ErmolaiInputs.UseItem] && previousInputs[(int)EnumData.ErmolaiInputs.UseItem] != inputs[(int)EnumData.ErmolaiInputs.UseItem])
{
SpawnItem();
}
}
}
}
bubbleShieldAttackReady = !waitingActionForBubbleShieldItemMove.Perform();
if (!isInFlyingState)
{
if (itemToCast != null && itemToCast.itemCount > 0 && itemToCast.castableItemType == EnumData.CastItemTypes.ServerProjectiles)
{
if (inputs[(int)EnumData.ErmolaiInputs.UseItem] && previousInputs[(int)EnumData.ErmolaiInputs.UseItem] != inputs[(int)EnumData.ErmolaiInputs.UseItem])
{
SpawnServerProjectiles();
}
}
}
}
}
private void FixedUpdate()
{
if (isInitialised)
{
//Remote clients
for (int i = 0; i < (int)currentStateProcessingModeOnClient; i++)
{
PlayerStateUpdates updateCorrespondingToSeq;
if (playerStateUpdatesDic.TryGetValue(serverSequenceNumberToBeProcessed + 1, out updateCorrespondingToSeq))
{
//if(clientPlayer.ownerId==2)
//{
// Debug.LogError("Processing : "+ updateCorrespondingToSeq.playerServerSequenceNumber);
//}
//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;
PlayerStateUpdates playerStateUpdates = new PlayerStateUpdates(serverSequenceNumberToBeProcessed
, playerSequenceNumberProcessed
, updateCorrespondingToSeq.playerAuthoratativeStates
, updateCorrespondingToSeq.positionUpdates
, updateCorrespondingToSeq.playerEvents
, updateCorrespondingToSeq.playerAnimationEvents
, updateCorrespondingToSeq.playerFlyData);
SetPlayerStateUpdatesReceivedFromServer(playerStateUpdates);
}
else
{
Debug.LogError(id + " latestPlayerStateUpdate.playerServerSequenceNumber " + latestPlayerStateUpdate.playerServerSequenceNumber);
Debug.LogError(id + " Could not find any posudates for seq: " + (serverSequenceNumberToBeProcessed + 1));
if (latestPlayerStateUpdate.playerServerSequenceNumber != 0)
{
serverSequenceNumberToBeProcessed = serverSequenceNumberToBeProcessed + 1;
PlayerStateUpdates playerStateUpdates = new PlayerStateUpdates(serverSequenceNumberToBeProcessed
, latestPlayerStateUpdate.playerProcessedSequenceNumber
, latestPlayerStateUpdate.playerAuthoratativeStates
, latestPlayerStateUpdate.positionUpdates
, latestPlayerStateUpdate.playerEvents
, latestPlayerStateUpdate.playerAnimationEvents
, latestPlayerStateUpdate.playerFlyData);
SetPlayerStateUpdatesReceivedFromServer(playerStateUpdates);
}
}
}
if (hasAuthority)
{
bool[] inputs = getInputs();
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 override void ProcessEventsInputs(bool[] inputs, bool[] previousInputs)
{
if (!isInFlyingState)
{
if (itemToCast != null && itemToCast.castableItemType == EnumData.CastItemTypes.ClientProjectiles)
{
if (itemToCast.itemCount > 0 && inputs[(int)EnumData.HeliemisInputs.UseItem])
{
SpawnClientProjectiles();
}
else if (itemToCast.itemCount <= 0 || (!inputs[(int)EnumData.HeliemisInputs.UseItem] && previousInputs[(int)EnumData.HeliemisInputs.UseItem] != inputs[(int)EnumData.HeliemisInputs.UseItem]))
{
ResetClientProjectilesVars();
}
}
}
if (!MultiplayerManager.instance.isServer && hasAuthority())
{
if (completedMotionToMovePoint)
{
if (isInFlyingState)
{
if (inputs[(int)EnumData.HeliemisInputs.LandPlayer] && previousInputs[(int)EnumData.HeliemisInputs.LandPlayer] != inputs[(int)EnumData.HeliemisInputs.LandPlayer])
{
if (isInFlyingState)
{
//land here
flyingTickCountTemp = 0;
LandPlayerCommand landPlayerCommand = new LandPlayerCommand(GetLocalSequenceNo());
ClientSend.LandPlayer(landPlayerCommand);
}
}
}
else
{
if (inputs[(int)EnumData.HeliemisInputs.RespawnPlayer] && previousInputs[(int)EnumData.HeliemisInputs.RespawnPlayer] != inputs[(int)EnumData.HeliemisInputs.RespawnPlayer])
{
Vector3Int cellToCheckFor = GridManager.instance.grid.WorldToCell(actorTransform.position);
if (IsPlayerSpawnable(cellToCheckFor))
{
//Respawn player command
RespawnPlayerCommand respawnPlayerCommand = new RespawnPlayerCommand(GetLocalSequenceNo());
ClientSend.RespawnPlayer(respawnPlayerCommand);
}
else
{
Debug.LogError("Invalid location to spawn player");
}
}
else if (inputs[(int)EnumData.HeliemisInputs.PlaceTornado] && previousInputs[(int)EnumData.HeliemisInputs.PlaceTornado] != inputs[(int)EnumData.HeliemisInputs.PlaceTornado])
{
Vector3Int cellToCheck = GridManager.instance.grid.WorldToCell(actorTransform.position + GridManager.instance.GetFacingDirectionOffsetVector3(Facing));
if (!GridManager.instance.IsCellBlockedForUnitMotionAtPos(cellToCheck))
{
PlaceTornadoCommand placeTornoadoCommand = new PlaceTornadoCommand(GetLocalSequenceNo(), (int)Facing);
ClientSend.PlaceTornadoCommand(placeTornoadoCommand);
}
}
else if (itemToCast != null && itemToCast.itemCount > 0 && itemToCast.castableItemType == EnumData.CastItemTypes.SpawnnableItems)
{
if (inputs[(int)EnumData.HeliemisInputs.UseItem] && previousInputs[(int)EnumData.HeliemisInputs.UseItem] != inputs[(int)EnumData.HeliemisInputs.UseItem])
{
SpawnItem();
}
}
}
}
bubbleShieldAttackReady = !waitingActionForBubbleShieldItemMove.Perform();
if (!isInFlyingState)
{
if (inputs[(int)EnumData.HeliemisInputs.ShootMightyWind] && previousInputs[(int)EnumData.HeliemisInputs.ShootMightyWind] != inputs[(int)EnumData.HeliemisInputs.ShootMightyWind])
{
if (IsHeroAbleToFireProjectiles())
{
FireMightyWindCommand fireMightyWindCommand = new FireMightyWindCommand(GetLocalSequenceNo(), (int)Facing, GridManager.instance.grid.WorldToCell(actorTransform.position));
ClientSend.FireMightyWind(fireMightyWindCommand);
isFiringServerProjectiles = true;
onCompletedMotionToPoint = () => { isFiringServerProjectiles = false; onCompletedMotionToPoint = null; };
}
}
else if (itemToCast != null && itemToCast.itemCount > 0 && itemToCast.castableItemType == EnumData.CastItemTypes.ServerProjectiles)
{
if (inputs[(int)EnumData.HeliemisInputs.UseItem] && previousInputs[(int)EnumData.HeliemisInputs.UseItem] != inputs[(int)EnumData.HeliemisInputs.UseItem])
{
SpawnServerProjectiles();
}
}
}
}
}
