public void SpawnWorldGridElements(WorldUpdate worldUpdates)
{
UpdateWorldStart(worldUpdates);
serverWorldSequenceNumberProcessed = worldUpdates.sequenceNumber;
isWorldInitialised = true;
Debug.Log("<color=blue>spawned grid world serverWorldSequenceNumberProcessed. </color>" + serverWorldSequenceNumberProcessed);
}
public void SendIntoGame(string connectionID, string playerName)
{
Vector3 spawnPos = ServerSideGameManager.instance.spawnPositions[(count++) % ServerSideGameManager.instance.spawnPositions.Count];
serverMasterController = ServerSideGameManager.instance.InstantiatePlayer((int)EnumData.Heroes.Medusa);
serverMasterController.Initialise(id, connectionID, playerName, spawnPos);
//This will send all other players information to our new player
foreach (ServerSideClient client in Server.clients.Values)
{
if (client.serverMasterController != null)
{
if (client.id != id)
{
ServerSend.SpawnPlayer(id, client.serverMasterController);
}
}
}
//This will send new player information to all other players and themselves
foreach (ServerSideClient client in Server.clients.Values)
{
if (client.serverMasterController != null)
{
ServerSend.SpawnPlayer(client.id, serverMasterController);
}
}
List <WorldGridItem> worldGridItemList = new List <WorldGridItem>();
for (int i = 0; i < ServerSideGameManager.instance.toNetworkTileType.Count; i++)
{
List <Vector3Int> positionsOfTile = GridManager.instance.GetAllPositionForTileMap(ServerSideGameManager.instance.toNetworkTileType[i]);
WorldGridItem worldGridItem = new WorldGridItem((int)ServerSideGameManager.instance.toNetworkTileType[i], positionsOfTile);
worldGridItemList.Add(worldGridItem);
}
WorldUpdate worldUpdate = new WorldUpdate(ServerSideGameManager.instance.serverWorldSequenceNumber, worldGridItemList.ToArray(), new GameData((int)ServerSideGameManager.instance.currentGameState, ServerSideGameManager.instance.timeToStartMatch), ServerSideGameManager.projectilesDic, ServerSideGameManager.enemiesDic, ServerSideGameManager.animatingStaticTileDic, GridManager.instance.portalTracker.portalEntranceDic);
ServerSend.SpawnGridWorld(id, worldUpdate);
}
public void AccumulateWorldUpdatesToBePlayedOnClientFromServer(WorldUpdate worldUpdates)
{
if (!isWorldInitialised)
{
return;
}
if (worldUpdates.sequenceNumber > serverWorldSequenceNumberProcessed)
{
WorldUpdate dataPackage;
if (worldUpdatesFromServerToClientDic.TryGetValue(worldUpdates.sequenceNumber, out dataPackage))
{
//Debug.Log("<color=orange>AccumulateWorldUpdatesToBePlayedOnClientFromServer dataPackage already exists for sequence no. </color>" + dataPackage.sequenceNumber);
}
else
{
//Debug.Log("<color=green>AccumulateWorldUpdatesToBePlayedOnClientFromServer Added successfully to processing buffer dic </color>" + worldUpdates.sequenceNumber + " processed sequence number: " + worldUpdates.sequenceNumber);
worldUpdatesFromServerToClientDic.Add(worldUpdates.sequenceNumber, worldUpdates);
}
}
else
{
//Debug.Log("<color=red>AccumulateWorldUpdatesToBePlayedOnClientFromServer Already processed this sequence no </color>" + serverWorldSequenceNumberProcessed);
}
}
public static void SpawnGridWorld(int toClient, WorldUpdate worldUpdate)
{
using (Packet packet = new Packet((int)ServerPackets.spawnGridWorld))
{
packet.Write(worldUpdate.worldGridItems.Length);
foreach (WorldGridItem worldGridItem in worldUpdate.worldGridItems)
{
packet.Write(worldGridItem.tileType);
packet.Write(worldGridItem.updatedCellGridWorldPositionList.Count);
foreach (Vector2Int v in worldGridItem.updatedCellGridWorldPositionList)
{
packet.Write(v);
}
}
packet.Write(worldUpdate.projectileDatas.Count);
foreach (KeyValuePair <int, ProjectileData> keyValuePair in worldUpdate.projectileDatas)
{
packet.Write(keyValuePair.Key);
packet.Write(keyValuePair.Value.projectileOwnerId);
packet.Write(keyValuePair.Value.projectileType);
packet.Write(keyValuePair.Value.projectilePosition);
packet.Write(keyValuePair.Value.faceDirection);
}
packet.Write(worldUpdate.enemyDatas.Count);
foreach (KeyValuePair <int, EnemyData> keyValuePair in worldUpdate.enemyDatas)
{
packet.Write(keyValuePair.Key);
packet.Write(keyValuePair.Value.leaderNetworkId);
packet.Write(keyValuePair.Value.leadercharacterType);
packet.Write(keyValuePair.Value.enemyType);
packet.Write(keyValuePair.Value.animationIndexNumber);
packet.Write(keyValuePair.Value.faceDirection);
packet.Write(keyValuePair.Value.enemyState);
packet.Write(keyValuePair.Value.enemyPosition);
}
packet.Write(worldUpdate.animatingTileDatas.Count);
foreach (KeyValuePair <int, AnimatingStaticTile> keyValuePair in worldUpdate.animatingTileDatas)
{
packet.Write(keyValuePair.Key);
packet.Write(keyValuePair.Value.tileType);
packet.Write(keyValuePair.Value.animationSpriteIndex);
packet.Write(keyValuePair.Value.pos);
}
packet.Write(worldUpdate.portalEntranceDic.Count);
foreach (KeyValuePair <Vector3Int, PortalInfo> item in worldUpdate.portalEntranceDic)
{
packet.Write(item.Key);
packet.Write(item.Value.portalOutlet);
packet.Write(item.Value.portalOwner);
}
packet.Write(worldUpdate.gameData.gameState);
packet.Write(worldUpdate.gameData.matchStartTime);
packet.Write(worldUpdate.sequenceNumber);
SendTCPData(toClient, packet);
}
}
public static void SpawnGridWorld(Packet packet)
{
WorldGridItem[] worldItems = new WorldGridItem[packet.ReadInt()];
for (int i = 0; i < worldItems.Length; i++)
{
int tileType = packet.ReadInt();
int cellPositionCount = packet.ReadInt();
List <Vector3Int> cellPositionList = new List <Vector3Int>();
for (int k = 0; k < cellPositionCount; k++)
{
Vector2Int cell = packet.ReadVector2Int();
cellPositionList.Add(new Vector3Int(cell.x, cell.y, 0));
}
worldItems[i] = new WorldGridItem(tileType, cellPositionList);
}
Dictionary <int, ProjectileData> keyValuePairs = new Dictionary <int, ProjectileData>();
Dictionary <int, EnemyData> keyValueEnemyPairs = new Dictionary <int, EnemyData>();
Dictionary <int, AnimatingStaticTile> keyValuePairsAnimation = new Dictionary <int, AnimatingStaticTile>();
Dictionary <Vector3Int, PortalInfo> keyValuePairsPortal = new Dictionary <Vector3Int, PortalInfo>();
int projectileDatasCount = packet.ReadInt();
for (int i = 0; i < projectileDatasCount; i++)
{
int uid = packet.ReadInt();
int projectileOwnerId = packet.ReadInt();
int projectileTileType = packet.ReadInt();
Vector3 projectilePosition = packet.ReadVector3();
int faceDirection = packet.ReadInt();
keyValuePairs.Add(uid, new ProjectileData(uid, projectileOwnerId, projectileTileType, projectilePosition, faceDirection));
}
int enemyDatasCount = packet.ReadInt();
for (int i = 0; i < enemyDatasCount; i++)
{
int uid = packet.ReadInt();
int leaderNetworkId = packet.ReadInt();
int leadercharacterType = packet.ReadInt();
int enemyType = packet.ReadInt();
int animationIndexNumber = packet.ReadInt();
int faceDirection = packet.ReadInt();
int enemyState = packet.ReadInt();
Vector3 enemyPosition = packet.ReadVector3();
keyValueEnemyPairs.Add(uid, new EnemyData(uid, leaderNetworkId, leadercharacterType, enemyType, animationIndexNumber, faceDirection, enemyState, enemyPosition));
}
int animationStaticTileCount = packet.ReadInt();
for (int i = 0; i < animationStaticTileCount; i++)
{
int uid = packet.ReadInt();
int tileType = packet.ReadInt();
int animationSpIndex = packet.ReadInt();
Vector3Int pos = packet.ReadVector3Int();
keyValuePairsAnimation.Add(uid, new AnimatingStaticTile(uid, tileType, animationSpIndex, pos));
}
int portalElementCount = packet.ReadInt();
for (int i = 0; i < portalElementCount; i++)
{
Vector3Int portalInLet = packet.ReadVector3Int();
Vector3Int portalOutLet = packet.ReadVector3Int();
int portalOwner = packet.ReadInt();
keyValuePairsPortal.Add(portalInLet, new PortalInfo(portalOwner, portalOutLet));
}
int gameState = packet.ReadInt();
int gameMatchStartTime = packet.ReadInt();
int worldUpdateSequenceNumber = packet.ReadInt();
WorldUpdate worldUpdate = new WorldUpdate(worldUpdateSequenceNumber, worldItems, new GameData(gameState, gameMatchStartTime), keyValuePairs, keyValueEnemyPairs, keyValuePairsAnimation, keyValuePairsPortal);
ClientSideGameManager.instance.SpawnWorldGridElements(worldUpdate);
}
void UpdateWorld(WorldUpdate newWorldUpdate)
{
if (latestWorldUpdate.worldGridItems != null)
{
if (updateRateTemp >= updateRate)
{
updateRateTemp = 0;
//implement
for (int i = 0; i < latestWorldUpdate.worldGridItems.Length; i++)
{
for (int j = 0; j < latestWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList.Count; j++)
{
if (!newWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList.Contains(latestWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList[j]))
{
//delete old
GridManager.instance.SetTile(latestWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList[j], (EnumData.TileType)latestWorldUpdate.worldGridItems[i].tileType, false, true);
}
}
}
for (int i = 0; i < newWorldUpdate.worldGridItems.Length; i++)
{
for (int j = 0; j < newWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList.Count; j++)
{
if (!latestWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList.Contains(newWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList[j]))
{
//add new
GridManager.instance.SetTile(newWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList[j], (EnumData.TileType)newWorldUpdate.worldGridItems[i].tileType, true, true);
}
}
}
latestWorldUpdate.worldGridItems = newWorldUpdate.worldGridItems;
}
else
{
updateRateTemp++;
}
foreach (KeyValuePair <int, ProjectileData> kvp in latestWorldUpdate.projectileDatas)
{
if (!newWorldUpdate.projectileDatas.ContainsKey(kvp.Key))
{
//delete old
ProjectileManager projectileManagerToRemove;
if (projectileDatasDic.TryGetValue(kvp.Key, out projectileManagerToRemove))
{
Destroy(projectileManagerToRemove.gameObject);
projectileDatasDic.Remove(kvp.Key);
}
else
{
Debug.LogError("Could not find object to remove");
}
}
}
foreach (KeyValuePair <int, ProjectileData> kvp in newWorldUpdate.projectileDatas)
{
if (!latestWorldUpdate.projectileDatas.ContainsKey(kvp.Key))
{
//add new
ProjectileManager projectileManagerToAdd;
if (projectileDatasDic.TryGetValue(kvp.Key, out projectileManagerToAdd))
{
Debug.LogError("Already contains item to add");
}
else
{
//intantiate here
GameObject gToSpawn = Resources.Load("ClientOnly/" + ((EnumData.Projectiles)(kvp.Value.projectileType)).ToString()) as GameObject;
if (gToSpawn == null)
{
Debug.LogError("gToSpawn is null " + ((EnumData.Projectiles)(kvp.Value.projectileType)).ToString());
return;
}
ProjectileManager newProjectileManager = GridManager.InstantiateGameObject(gToSpawn).GetComponent <ProjectileManager>();
newProjectileManager.OnInititialise(kvp.Key);
newProjectileManager.SetPosition(kvp.Value.projectilePosition);
newProjectileManager.SetFaceDirection(kvp.Value.faceDirection);
projectileDatasDic.Add(kvp.Key, newProjectileManager);
}
}
ProjectileManager projectileManager;
if (projectileDatasDic.TryGetValue(kvp.Key, out projectileManager))
{
projectileManager.SetPosition(kvp.Value.projectilePosition);
projectileManager.SetFaceDirection(kvp.Value.faceDirection);
}
else
{
Debug.LogError("Could not find the projectile manager top alter");
}
}
foreach (KeyValuePair <int, EnemyData> kvp in latestWorldUpdate.enemyDatas)
{
if (!newWorldUpdate.enemyDatas.ContainsKey(kvp.Key))
{
//delete old
ClientEnemyManager enemyManagerToRemove;
if (enemyDatasDic.TryGetValue(kvp.Key, out enemyManagerToRemove))
{
//Debug.LogError("Deleting here");
Destroy(enemyManagerToRemove.gameObject);
enemyDatasDic.Remove(kvp.Key);
}
else
{
Debug.LogError("Could not find object to remove");
}
}
}
foreach (KeyValuePair <int, EnemyData> kvp in newWorldUpdate.enemyDatas)
{
if (!latestWorldUpdate.enemyDatas.ContainsKey(kvp.Key))
{
//add new
ClientEnemyManager clientEnemyManagerToAdd;
if (enemyDatasDic.TryGetValue(kvp.Key, out clientEnemyManagerToAdd))
{
Debug.LogError("Already contains item to add");
}
else
{
//intantiate here
GameObject gToSpawn = Resources.Load("ClientEnemy") as GameObject;
if (gToSpawn == null)
{
Debug.LogError("gToSpawn is null " + ((EnumData.Projectiles)(kvp.Value.enemyType)).ToString());
return;
}
ClientEnemyManager newClientManager = GridManager.InstantiateGameObject(gToSpawn).GetComponent <ClientEnemyManager>();
newClientManager.SetEnemyColor(kvp.Value.leaderNetworkId, kvp.Value.leadercharacterType);
newClientManager.SetEnemyData(kvp.Value);
enemyDatasDic.Add(kvp.Key, newClientManager);
}
}
ClientEnemyManager clientEnemyManager;
if (enemyDatasDic.TryGetValue(kvp.Key, out clientEnemyManager))
{
clientEnemyManager.SetEnemyData(kvp.Value);
}
else
{
Debug.LogError("Could not find the enemy manager top alter");
}
}
foreach (KeyValuePair <int, AnimatingStaticTile> kvp in latestWorldUpdate.animatingTileDatas)
{
if (!newWorldUpdate.animatingTileDatas.ContainsKey(kvp.Key))
{
//delete old
StaticAnimatingTileManager staticAnimatingTileManager;
if (staticAnimatingTileDic.TryGetValue(kvp.Key, out staticAnimatingTileManager))
{
Destroy(staticAnimatingTileManager.gameObject);
staticAnimatingTileDic.Remove(kvp.Key);
}
else
{
Debug.LogError("Could not find object to remove");
}
}
}
foreach (KeyValuePair <int, AnimatingStaticTile> kvp in newWorldUpdate.animatingTileDatas)
{
if (!latestWorldUpdate.animatingTileDatas.ContainsKey(kvp.Key))
{
//add new
StaticAnimatingTileManager staticAnimatingTileManager;
if (staticAnimatingTileDic.TryGetValue(kvp.Key, out staticAnimatingTileManager))
{
Debug.LogError("Already contains item to add");
}
else
{
//intantiate here
GameObject gToSpawn = Resources.Load("ClientOnly/" + ((EnumData.StaticAnimatingTiles)(kvp.Value.tileType)).ToString()) as GameObject;
if (gToSpawn == null)
{
Debug.LogError("gToSpawn is null");
return;
}
StaticAnimatingTileManager newStaticAnimatingTile = GridManager.InstantiateGameObject(gToSpawn).GetComponent <StaticAnimatingTileManager>();
newStaticAnimatingTile.SetPosition(kvp.Value.pos);
newStaticAnimatingTile.SetID(kvp.Value.uid);
newStaticAnimatingTile.SetSprite(kvp.Value.animationSpriteIndex);
staticAnimatingTileDic.Add(kvp.Key, newStaticAnimatingTile);
}
}
StaticAnimatingTileManager staticAnimatingTileManagerRefresh;
if (staticAnimatingTileDic.TryGetValue(kvp.Key, out staticAnimatingTileManagerRefresh))
{
staticAnimatingTileManagerRefresh.SetSprite(kvp.Value.animationSpriteIndex);
}
else
{
Debug.LogError("Could not find the projectile manager top alter");
}
}
}
GridManager.instance.portalTracker.portalEntranceDic = newWorldUpdate.portalEntranceDic;
MultiplayerManager.instance.matchStartTimeText.text = Mathf.RoundToInt(newWorldUpdate.gameData.matchStartTime * Time.fixedDeltaTime).ToString();
latestWorldUpdate.sequenceNumber = newWorldUpdate.sequenceNumber;
latestWorldUpdate.animatingTileDatas = newWorldUpdate.animatingTileDatas;
latestWorldUpdate.enemyDatas = newWorldUpdate.enemyDatas;
latestWorldUpdate.gameData = newWorldUpdate.gameData;
latestWorldUpdate.portalEntranceDic = newWorldUpdate.portalEntranceDic;
latestWorldUpdate.projectileDatas = newWorldUpdate.projectileDatas;
}
void UpdateWorldStart(WorldUpdate newWorldUpdate)
{
for (int i = 0; i < newWorldUpdate.worldGridItems.Length; i++)
{
for (int j = 0; j < newWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList.Count; j++)
{
GridManager.instance.SetTile(newWorldUpdate.worldGridItems[i].updatedCellGridWorldPositionList[j], (EnumData.TileType)newWorldUpdate.worldGridItems[i].tileType, true, false);
}
}
foreach (KeyValuePair <int, ProjectileData> kvp in newWorldUpdate.projectileDatas)
{
ProjectileManager projectileManager;
if (projectileDatasDic.TryGetValue(kvp.Key, out projectileManager))
{
//assign position
projectileManager.SetPosition(kvp.Value.projectilePosition);
projectileManager.SetFaceDirection(kvp.Value.faceDirection);
}
else
{
//intantiate here
GameObject gToSpawn = Resources.Load("ClientOnly/" + ((EnumData.Projectiles)(kvp.Value.projectileType)).ToString()) as GameObject;
if (gToSpawn == null)
{
Debug.LogError("gToSpawn is null");
return;
}
ProjectileManager newProjectileManager = GridManager.InstantiateGameObject(gToSpawn).GetComponent <ProjectileManager>();
newProjectileManager.OnInititialise(kvp.Key);
newProjectileManager.SetPosition(kvp.Value.projectilePosition);
projectileManager.SetFaceDirection(kvp.Value.faceDirection);
projectileDatasDic.Add(kvp.Key, newProjectileManager);
}
}
foreach (KeyValuePair <int, EnemyData> kvp in newWorldUpdate.enemyDatas)
{
ClientEnemyManager clientEnemyManager;
if (enemyDatasDic.TryGetValue(kvp.Key, out clientEnemyManager))
{
//assign position
clientEnemyManager.SetEnemyData(kvp.Value);
}
else
{
//intantiate here
GameObject gToSpawn = Resources.Load("ClientEnemy") as GameObject;
if (gToSpawn == null)
{
Debug.LogError("gToSpawn is null");
return;
}
ClientEnemyManager newClientEnemyManager = GridManager.InstantiateGameObject(gToSpawn).GetComponent <ClientEnemyManager>();
newClientEnemyManager.SetEnemyColor(kvp.Value.leaderNetworkId, kvp.Value.leadercharacterType);
newClientEnemyManager.SetEnemyData(kvp.Value);
enemyDatasDic.Add(kvp.Key, newClientEnemyManager);
}
}
foreach (KeyValuePair <int, AnimatingStaticTile> kvp in newWorldUpdate.animatingTileDatas)
{
StaticAnimatingTileManager staticAnimatingTileManager;
if (staticAnimatingTileDic.TryGetValue(kvp.Key, out staticAnimatingTileManager))
{
//assign position
staticAnimatingTileManager.SetPosition(kvp.Value.pos);
staticAnimatingTileManager.SetID(kvp.Value.uid);
staticAnimatingTileManager.SetSprite(kvp.Value.animationSpriteIndex);
}
else
{
//intantiate here
GameObject gToSpawn = Resources.Load("ClientOnly/" + ((EnumData.StaticAnimatingTiles)(kvp.Value.tileType)).ToString()) as GameObject;
if (gToSpawn == null)
{
Debug.LogError("gToSpawn is null");
return;
}
StaticAnimatingTileManager newstaticAnimatingTileManager = GridManager.InstantiateGameObject(gToSpawn).GetComponent <StaticAnimatingTileManager>();
newstaticAnimatingTileManager.SetPosition(kvp.Value.pos);
newstaticAnimatingTileManager.SetID(kvp.Value.uid);
newstaticAnimatingTileManager.SetSprite(kvp.Value.animationSpriteIndex);
staticAnimatingTileDic.Add(kvp.Key, newstaticAnimatingTileManager);
}
}
GridManager.instance.portalTracker.portalEntranceDic = newWorldUpdate.portalEntranceDic;
MultiplayerManager.instance.matchStartTimeText.text = Mathf.RoundToInt(newWorldUpdate.gameData.matchStartTime * Time.fixedDeltaTime).ToString();
latestWorldUpdate = newWorldUpdate;
}
