public void SendReadyToServer()
{
if (m_currentState == this)
{
ClientReadyMessage clientReadyMessage = new ClientReadyMessage();
m_TCPClient.Send(clientReadyMessage.GetBytes());
}
}
public void ReceivePacket(TCPToolkit.Packet packet, int playerID)
{
IdentificationMessage identification = Serializable.CreateFromBytes <IdentificationMessage>(packet.Data.ArraySegment());
if (identification != null)
{
lock (m_lock)
{
if (!m_clientCharacters.ContainsKey(playerID)) // it's a new player
{
AddNewPlayer(playerID);
}
#if DEBUG_LOG
Debug.Log("Received TCP connection request from player (ID " + playerID + ")");
#endif // DEBUG_LOG
ServerSuccessfulConnectMessage serverSuccessPing = new ServerSuccessfulConnectMessage();
m_TCPServer.Send(serverSuccessPing.GetBytes(), playerID);
}
return;
}
OnLobbyEnteredMessage lobbyEnter = Serializable.CreateFromBytes <OnLobbyEnteredMessage>(packet.Data.ArraySegment());
if (lobbyEnter != null)
{
lock (m_lock)
{
if (m_clientCharacters.ContainsKey(playerID))
{
Debug.Log("Adding character " + lobbyEnter.CharacterID.Value + " to player " + playerID);
m_clientCharacters[playerID] = lobbyEnter.CharacterID;
BroadcastPlayerList();
}
}
return;
}
ClientReadyMessage ready = IConvertible.CreateFromBytes <ClientReadyMessage>(packet.Data.ArraySegment());
if (ready != null && m_readyClients.ContainsKey(playerID))
{
Debug.Log("Client " + playerID + " is ready to receive world.");
m_readyClients[playerID] = true;
return;
}
if (m_awaitingClientLoadWorld)
{
ClientWorldLoadedMessage clientWorldLoaded = IConvertible.CreateFromBytes <ClientWorldLoadedMessage>(packet.Data.ArraySegment());
if (clientWorldLoaded != null)
{
m_readyClients.Remove(playerID);
}
}
}
private Task ProcessClientReady(Uri uri, ClientReadyMessage clientReady)
{
if (!_clientCollection.TryGet(clientReady.ClientId, out var client))
{
// Something weird is going on
// Ignore the message
return(Task.CompletedTask);
}
return(FireOnConnected(client, uri));
}
public static void HandleClientReadyMessage(ClientReadyMessage message, LoLClient client)
{
client.Ready = true;
client.Send(new LoadScreenInfoMessage(6, 6, ConfigurationProvider.Instance.GetBlueIds(), ConfigurationProvider.Instance.GetPurpleIds()), Channel.CHL_LOADING_SCREEN);
foreach (var player in ConfigurationProvider.Instance.Configuration.Players)
{
client.Send(new LoadScreenPlayerNameMessage(player.UserId, player.SkinId, player.Name, 0), Channel.CHL_LOADING_SCREEN);
client.Send(new LoadScreenPlayerChampionMessage(player.UserId, player.SkinId, player.ChampionName, 0), Channel.CHL_LOADING_SCREEN);
}
}
private void HandleGameDataTransfer(GameDataTransferMessage msg, double timeStamp)
{
const int entries = BombGame.GameLevelWidth * BombGame.GameLevelHeight;
TilesetAssetName = msg.TileSetAssetName;
_data = new TileBlockClient[entries];
_fringe = new TileBlockClient[entries];
_itemData = new ItemClient[entries];
_overlayData = new OverlayClient[entries];
_bombs.Clear();
for (var i = 0; i < entries; i++)
{
Point tilePosition = new Point(i % BombGame.GameLevelWidth, i / BombGame.GameLevelWidth);
BlockType groundBlockType = msg.Data[i].GroundBlockType;
_data[i] = new TileBlockClient(groundBlockType)
{
TilePosition = tilePosition, IsActive = true
};
BlockType fringeBlockType = msg.Data[i].FringeBlockType;
ItemType fringeItemType = msg.Data[i].FringeItemType;
_fringe[i] = new TileBlockClient(fringeBlockType)
{
AttachedItem = fringeBlockType == BlockType.Box ? fringeItemType : ItemType.Empty,
IsActive = fringeBlockType == BlockType.Box,
TilePosition = tilePosition
};
_itemData[i] = new ItemClient {
IsActive = false, TilePosition = tilePosition
};
_overlayData[i] = new OverlayClient {
IsActive = false, TilePosition = tilePosition
};
_bombs.Clear();
}
foreach (GameMember gameMember in _members)
{
gameMember.InitFromServer(msg.StartUpPositions[gameMember.Id - 1]);
gameMember.WalkDirection = Vector2.Zero;
}
State = InGameState.PreparingMatchLoadData;
ClientReadyMessage message = new ClientReadyMessage(timeStamp, ClientId, true, true);
message.Send(_messageTypeMap, _netClient.ServerConnection);
}
public void RpcCheckReady()
{
if (m_localPlayerID != INVALID_PLAYER_ID)
{
return;
}
SetupLocalPlayerID();
if (!isServer)
{
ClientReadyMessage msg = new ClientReadyMessage();
msg.ID = m_localPlayerID;
NetworkManager.singleton.client.Send((short)MessageType.ClientReady, msg);
}
else
{
m_Players[m_localPlayerID].m_loadReady = true;
}
}
private void InitializeGameState(InitGameMessage initGameMessage)
{
var fix = initGameMessage.Fix.Value;
playerNumber = fix.PlayerNumber;
teamSize = fix.TeamSize;
spaceshipRespawnTime = fix.SpaceshipRespawnTime;
spaceshipMaxLifePoints = fix.SpaceshipMaxLifePoints;
spaceshipRadius = fix.SpaceshipRadius;
normalProjectileRadius = fix.NormalProjectileRadius;
normalProjectileSpeed = fix.NormalProjectileSpeed;
normalProjectileClipSize = fix.NormalProjectileClipSize;
normalProjectileReloadDelay = fix.NormalProjectileReloadDelay;
normalProjectileReloadSpeed = fix.NormalProjectileReloadSpeed;
bouncingProjectileRadius = fix.BouncingProjectileRadius;
bouncingProjectileSpeed = fix.BouncingProjectileSpeed;
bouncingProjectileClipSize = fix.BouncingProjectileClipSize;
bouncingProjectileAutoReloadSpeed = fix.BouncingProjectileAutoReloadSpeed;
controlPointRadius = fix.ControlPointRadius;
controlPointTakingProgression = fix.ControlPointCapturingLimit;
controlPointProgressionSpeed = fix.ControlPointCapturingSpeed;
controlPointTimeBeforeCooldown = fix.ControlPointTimeBeforeCooldown;
controlPointCooldownSpeed = fix.ControlPointCooldownSpeed;
maxControlProgression = fix.ControlProgressionGoal;
controlProgressionSpeed = fix.ControlProgressionSpeed;
controlFinalizationDuration = fix.ReinstallDuration;
timeToDraw = fix.TimeToDraw;
if (playerNumber / teamSize == 0)
{
gameArea.transform.rotation = Quaternion.Euler(0, 0, 0);
playerColors[0] = Config.PLAYER_COLOR;
playerColors[1] = Config.ENEMY_COLOR;
controlPointColors[0] = Config.PLAYER_CONTROL_COLOR;
controlPointColors[1] = Config.ENEMY_CONTROL_COLOR;
respawnPointColors[0] = Config.PLAYER_RESPAWN_POINT_COLOR;
respawnPointColors[1] = Config.ENEMY_RESPAWN_POINT_COLOR;
inputMultiplier = 1;
controlledPointsTexts[0] = playerControlledPointsText;
controlledPointsTexts[1] = enemyControlledPointsText;
controlledPointsBackgrounds[0] = playerControlledPointsBackground;
controlledPointsBackgrounds[1] = enemyControlledPointsBackground;
controlProgressions[0] = playerControlProgression;
controlProgressions[1] = enemyControlProgression;
progressionDatas[0] = playerProgressionData;
progressionDatas[1] = enemyProgressionData;
}
else
{
gameArea.transform.rotation = Quaternion.Euler(0, 0, 180);
playerColors[0] = Config.ENEMY_COLOR;
playerColors[1] = Config.PLAYER_COLOR;
controlPointColors[0] = Config.ENEMY_CONTROL_COLOR;
controlPointColors[1] = Config.PLAYER_CONTROL_COLOR;
respawnPointColors[0] = Config.ENEMY_RESPAWN_POINT_COLOR;
respawnPointColors[1] = Config.PLAYER_RESPAWN_POINT_COLOR;
inputMultiplier = -1;
controlledPointsTexts[0] = enemyControlledPointsText;
controlledPointsTexts[1] = playerControlledPointsText;
controlledPointsBackgrounds[0] = enemyControlledPointsBackground;
controlledPointsBackgrounds[1] = playerControlledPointsBackground;
controlProgressions[0] = enemyControlProgression;
controlProgressions[1] = playerControlProgression;
progressionDatas[0] = enemyProgressionData;
progressionDatas[1] = playerProgressionData;
}
playerUsernameTexts = new TextMeshProUGUI[2 * teamSize];
playerDisconnectedIcons = new Image[2 * teamSize]; // playerDisconnectedIcons[playerNumber] will be null
playerConnectingIcons = new Image[2 * teamSize]; // playerConnectingIcons[playerNumber] will be null
playerUsernameTexts[playerNumber] = allUsernameTexts[0];
UInt8 nextTeammateUsernameTextIndex = 1;
UInt8 nextEnemyUsernameTextIndex = 3;
for (UInt8 playerIndex = 0; playerIndex < 2 * teamSize; playerIndex++)
{
if (playerIndex != playerNumber)
{
if (playerIndex / teamSize == playerNumber / teamSize) // if is it a teammate
{
playerUsernameTexts[playerIndex] = allUsernameTexts[nextTeammateUsernameTextIndex];
playerDisconnectedIcons[playerIndex] = allDisconnectedIcons[nextTeammateUsernameTextIndex - 1]; // subtracting 1, because there is no icon for our player
playerConnectingIcons[playerIndex] = allConnectingIcons[nextTeammateUsernameTextIndex - 1];
nextTeammateUsernameTextIndex++;
}
else
{
playerUsernameTexts[playerIndex] = allUsernameTexts[nextEnemyUsernameTextIndex];
playerDisconnectedIcons[playerIndex] = allDisconnectedIcons[nextEnemyUsernameTextIndex - 1]; // subtracting 1, because there is no icon for our player
playerConnectingIcons[playerIndex] = allConnectingIcons[nextEnemyUsernameTextIndex - 1];
nextEnemyUsernameTextIndex++;
}
}
}
normalProjectileAmmoText.GetComponent <Ammo>().Init(normalProjectileClipSize, normalProjectileReloadSpeed);
bouncingProjectileAmmoText.GetComponent <Ammo>().Init(bouncingProjectileClipSize, bouncingProjectileAutoReloadSpeed);
normalProjectileAmmoText.GetComponent <Ammo>().SetAmmo(fix.NormalProjectileAmmo);
normalProjectileAmmoText.GetComponent <Ammo>().SetReloadTimeRemaining(fix.NormalProjectileReloadTimeRemaining);
bouncingProjectileAmmoText.GetComponent <Ammo>().SetAmmo(fix.BouncingProjectileAmmo);
bouncingProjectileAmmoText.GetComponent <Ammo>().SetReloadTimeRemaining(fix.BouncingProjectileReloadTimeRemaining);
controlProgressions[0].GetComponent <ControlProgression>().Init(maxControlProgression, controlProgressionSpeed);
controlProgressions[1].GetComponent <ControlProgression>().Init(maxControlProgression, controlProgressionSpeed);
controlProgressions[0].GetComponent <ControlProgression>().SetControlProgression(fix.TeamOneControlProgression);
controlProgressions[1].GetComponent <ControlProgression>().SetControlProgression(fix.TeamTwoControlProgression);
progressionDatas[0].GetComponent <ReinstallTime>().SetRemainingTime(fix.TeamOneReinstallRemaining > 0 ? fix.TeamOneReinstallRemaining : 0);
progressionDatas[1].GetComponent <ReinstallTime>().SetRemainingTime(fix.TeamTwoReinstallRemaining > 0 ? fix.TeamTwoReinstallRemaining : 0);
respawnPoints.Add(Instantiate(respawnPointPrefab));
respawnPoints[0].transform.parent = gameArea.transform;
respawnPoints[0].transform.localPosition = new Vector3(fix.TeamOneRespawnPoint.Position.X, fix.TeamOneRespawnPoint.Position.Y, Config.RESPAWN_POINT_Z_DEPTH);
respawnPoints[0].transform.localRotation = Quaternion.Euler(0, 0, 0);
respawnPoints[0].transform.localScale = new Vector3(fix.TeamOneRespawnPoint.Width, fix.TeamOneRespawnPoint.Height, 1);
respawnPoints[0].GetComponent <Renderer>().material.color = respawnPointColors[0];
respawnPoints.Add(Instantiate(respawnPointPrefab));
respawnPoints[1].transform.parent = gameArea.transform;
respawnPoints[1].transform.localPosition = new Vector3(fix.TeamTwoRespawnPoint.Position.X, fix.TeamTwoRespawnPoint.Position.Y, Config.RESPAWN_POINT_Z_DEPTH);
respawnPoints[1].transform.localRotation = Quaternion.Euler(0, 0, 0);
respawnPoints[1].transform.localScale = new Vector3(fix.TeamTwoRespawnPoint.Width, fix.TeamTwoRespawnPoint.Height, 1);
respawnPoints[1].GetComponent <Renderer>().material.color = respawnPointColors[1];
///////////////////////////////////////
///
for (int i = 0; i < initGameMessage.SpaceshipsLength; i++)
{
playerUsernameTexts[i].text = initGameMessage.Spaceships(i).Value.Username;
floatingUsernameTexts[i].text = initGameMessage.Spaceships(i).Value.Username;
if (i / teamSize == playerNumber / teamSize)
{
floatingUsernameTexts[i].color = teammateAliveUsernameColor;
}
else
{
floatingUsernameTexts[i].color = opponentAliveUsernameColor;
}
if (i != playerNumber)
{
float offsetX = playerUsernameTexts[i].rectTransform.sizeDelta.x / 2.0f - playerUsernameTexts[i].preferredWidth;
if (i / teamSize == playerNumber / teamSize)
{
offsetX = offsetX - 10;
}
else
{
offsetX = -offsetX + 20;
}
playerDisconnectedIcons[i].transform.localPosition = new Vector3(offsetX, 0, 0);
playerConnectingIcons[i].transform.localPosition = new Vector3(offsetX, 0, 0);
playerConnectingIcons[i].gameObject.SetActive(!initGameMessage.Spaceships(i).Value.IsConnected);
}
GameObject spaceshipShadow = new GameObject();
spaceshipShadows.Add(spaceshipShadow);
spaceshipShadow.transform.parent = gameArea.transform;
GameObject spaceship = Instantiate(spaceshipPrefab);
spaceships.Add(spaceship);
spaceship.transform.parent = gameArea.transform;
spaceship.transform.localRotation = Quaternion.Euler(0, 0, 0);
spaceship.transform.localScale = new Vector3(1, 1, 1);
spaceship.GetComponent <SpaceshipDrawer>().Init(playerColors, spaceshipRadius);
spaceship.GetComponent <HealthBar>().Init(new Vector3(0, (spaceshipRadius + Config.HEALTH_BAR_Y_OFFSET) * inputMultiplier, Config.HEALTH_BAR_Z_DEPTH), Vector3.Scale(Config.HEALTH_BAR_SCALE, new Vector3(inputMultiplier, inputMultiplier, 1)));
spaceship.GetComponent <Health>().Init(spaceshipMaxLifePoints);
spaceship.GetComponent <Ownable>().SetOwner((byte)(i / teamSize));
spaceship.GetComponent <Interpolate>().SetInterpolateRotation(i != playerNumber);
if (i == playerNumber)
{
spaceships[playerNumber].GetComponent <Health>().onHealthChanged += playerHealthBar.GetComponent <HealthBar>().OnHealthChanged;
spaceships[playerNumber].GetComponent <Health>().onHealthChanged += playerHealthBar.GetComponent <HealthDrawer>().OnHealthChanged;
}
var spaceshipState = initGameMessage.Spaceships(i).Value.State;
if (spaceshipState.HasValue)
{
floatingUsernameTexts[i].text = initGameMessage.Spaceships(i).Value.Username;
spaceship.transform.localPosition = new Vector3(spaceshipState.Value.Position.X, spaceshipState.Value.Position.Y, Config.SPACESHIP_Z_DEPTH);
spaceship.GetComponent <SpaceshipDrawer>().SetRotation(spaceshipState.Value.Direction * 180f / Mathf.PI);
spaceship.GetComponent <Health>().SetHealthPoints(spaceshipState.Value.LifePoints);
spaceship.GetComponent <Health>().SetHealingSpeed(spaceshipState.Value.HealingSpeed);
if (i / teamSize == playerNumber / teamSize)
{
playerUsernameTexts[i].color = teammateAliveUsernameColor;
}
else
{
playerUsernameTexts[i].color = opponentAliveUsernameColor;
}
}
else
{
floatingUsernameTexts[i].text = "";
spaceship.GetComponent <Health>().SetHealthPoints(0);
spaceship.transform.Find("Empty").Find("Empty").Find("Model").gameObject.SetActive(false);
spaceship.transform.Find("Empty").Find("Health Bar").gameObject.SetActive(false);
if (i / teamSize == playerNumber / teamSize)
{
playerUsernameTexts[i].color = teammateDeadUsernameColor;
}
else
{
playerUsernameTexts[i].color = opponentDeadUsernameColor;
}
}
}
///////////////////////////////
for (int i = 0; i < initGameMessage.ObstaclesLength; ++i)
{
var obstacleData = initGameMessage.Obstacles(i).Value;
GameObject obstacle = new GameObject();
obstacles.Add(obstacle);
obstacle.transform.parent = gameArea.transform;
obstacle.transform.localPosition = new Vector3(obstacleData.Position.Value.X, obstacleData.Position.Value.Y, Config.OBSTACLE_Z_DEPTH);
obstacle.transform.localRotation = Quaternion.Euler(0, 0, 0);
obstacle.transform.localScale = new Vector3(1, 1, 1);
MeshRenderer meshRenderer = obstacle.AddComponent <MeshRenderer>();
meshRenderer.material = asteroidMaterial;
MeshFilter meshFilter = obstacle.AddComponent <MeshFilter>();
Mesh mesh = new Mesh();
Vector3[] vertices = new Vector3[1 + obstacleData.ColliderLength];
vertices[0] = new Vector3(0, 0, 0);
for (UInt8 pointIndex = 0; pointIndex < obstacleData.ColliderLength; pointIndex++)
{
Position pointPosition = obstacleData.Collider(pointIndex).Value;
vertices[1 + pointIndex] = new Vector3(pointPosition.X, pointPosition.Y, 0);
}
mesh.vertices = vertices;
int[] triangles = new int[3 * obstacleData.ColliderLength];
for (UInt8 pointIndex = 0; pointIndex < obstacleData.ColliderLength; pointIndex++)
{
triangles[3 * pointIndex + 0] = 0;
triangles[3 * pointIndex + 1] = 1 + pointIndex;
triangles[3 * pointIndex + 2] = 1 + ((1 + pointIndex) % obstacleData.ColliderLength);
}
mesh.triangles = triangles;
Vector2[] uv = new Vector2[vertices.Length];
for (int j = 0; j < uv.Length; j++)
{
uv[j] = new Vector2(obstacleData.Position.Value.X + vertices[j].x, obstacleData.Position.Value.Y + vertices[j].y);
}
mesh.uv = uv;
meshFilter.mesh = mesh;
}
for (int i = 0; i < initGameMessage.ProjectilesLength; ++i)
{
var projectileState = initGameMessage.Projectiles(i).Value.State;
GameObject projectile = Instantiate(projectilePrefab);
projectiles.Add(projectile);
projectile.transform.parent = gameArea.transform;
projectile.transform.localRotation = Quaternion.Euler(0, 0, 0);
projectile.transform.localScale = new Vector3(1, 1, 1);
if (projectileState.HasValue)
{
switch (projectileState.Value.Type)
{
case ProjectileType.Normal:
projectile.transform.Find("Normal").gameObject.SetActive(true);
projectile.transform.Find("Bouncing").gameObject.SetActive(false);
break;
case ProjectileType.Bouncing:
projectile.transform.Find("Normal").gameObject.SetActive(false);
projectile.transform.Find("Bouncing").gameObject.SetActive(true);
break;
}
projectile.GetComponent <ProjectileDrawer>().Init(playerColors, normalProjectileRadius, bouncingProjectileRadius);
projectile.GetComponent <Ownable>().SetOwner(projectileState.Value.Owner);
projectile.GetComponent <Velocity>().SetDirection(projectileState.Value.Direction);
projectile.GetComponent <Velocity>().Speed = projectileState.Value.Type == ProjectileType.Normal ? normalProjectileSpeed : bouncingProjectileSpeed;
projectile.transform.localPosition = new Vector3(projectileState.Value.Position.X, projectileState.Value.Position.Y, Config.BALL_Z_DEPTH);
}
else
{
projectile.GetComponent <ProjectileDrawer>().Init(playerColors, normalProjectileRadius, bouncingProjectileRadius);
projectile.SetActive(false);
}
}
int[] numberOfControlPoints = { 0, 0 };
for (int i = 0; i < initGameMessage.ControlPointStatesLength; ++i)
{
var controlPointState = initGameMessage.ControlPointStates(i).Value;
var controlPointStateFix = controlPointState.Fix.Value;
GameObject controlPoint = Instantiate(controlPointPrefab);
controlPoints.Add(controlPoint);
controlPoint.transform.parent = gameArea.transform;
controlPoint.transform.localPosition = new Vector3(controlPointStateFix.Position.X, controlPointStateFix.Position.Y, Config.CONTROL_POINT_Z_DEPTH);
controlPoint.transform.localRotation = Quaternion.Euler(0, 0, 0);
controlPoint.transform.localScale = new Vector3(1, 1, 1);
controlPoint.GetComponent <ControlPointDrawer>().Init(controlPointColors, controlPointRadius);
controlPoint.GetComponent <CaptureBar>().Init(new Vector3(0, 0, Config.CAPTURE_BAR_Z_DEPTH), Vector3.Scale(Config.CAPTURE_BAR_SCALE, new Vector3(inputMultiplier, inputMultiplier, 1)), playerColors);
controlPoint.GetComponent <ControlPoint>().Init(controlPointTakingProgression, controlPointProgressionSpeed, controlPointTimeBeforeCooldown, controlPointCooldownSpeed);
controlPoint.GetComponent <ControlPoint>().SetState(
new bool[] { controlPointStateFix.ContestedByTeamOne, controlPointStateFix.ContestedByTeamTwo },
controlPointStateFix.ProgressedTeam,
controlPointStateFix.Progression,
controlPointStateFix.TimeBeforeCooldown > 0 ? controlPointStateFix.TimeBeforeCooldown : 0
);
if (controlPointState.Owner.HasValue)
{
controlPoint.GetComponent <Ownable>().SetOwner(controlPointState.Owner.Value.Value);
numberOfControlPoints[controlPointState.Owner.Value.Value]++;
}
}
if (numberOfControlPoints[0] > numberOfControlPoints[1])
{
controlProgressions[0].GetComponent <ControlProgression>().EnableProgress(true);
controlProgressions[1].GetComponent <ControlProgression>().EnableProgress(false);
}
else if (numberOfControlPoints[1] > numberOfControlPoints[0])
{
controlProgressions[0].GetComponent <ControlProgression>().EnableProgress(false);
controlProgressions[1].GetComponent <ControlProgression>().EnableProgress(true);
}
else
{
controlProgressions[0].GetComponent <ControlProgression>().EnableProgress(false);
controlProgressions[1].GetComponent <ControlProgression>().EnableProgress(false);
}
ClientReadyMessage.StartClientReadyMessage(networkHandler.builder);
var clientReadyMessage = ClientReadyMessage.EndClientReadyMessage(networkHandler.builder);
networkHandler.Send(clientReadyMessage);
messageText.text = "Waiting for players...";
clientState = ClientState.WaitingForOpponent;
UpdateAttackedIcons();
UpdateControlledPoints();
UpdatePlayerAttackingAudio();
timeToDrawText.text = TimeSpan.FromSeconds(Mathf.CeilToInt(timeToDraw)).ToString(@"mm\:ss");
mainCamera.transform.position = new Vector3(spaceships[playerNumber].transform.position.x, spaceships[playerNumber].transform.position.y, -25);
backgroundCamera.GetComponent <Spin>().enabled = false;
backgroundCamera.transform.localEulerAngles = new Vector3(-5 * spaceships[playerNumber].transform.localPosition.y, 5 * spaceships[playerNumber].transform.localPosition.x, 0) * inputMultiplier;
UIUtilities.Show(inGameHUD);
}
//END FADE FUNCS
//START ADDITIONAL HANDLER FUNCS DUE TO UNWORKING COMMAND FUNC
void OnClientReady(NetworkMessage netMsg)
{
ClientReadyMessage msg = netMsg.ReadMessage <ClientReadyMessage>();
m_Players[msg.ID].m_loadReady = true;
}
