private void ProcessWelcomeReceivedPacket(int playerId, Packet packet)
{
int packetPlayerId = packet.ReadInt();
string userName = packet.ReadString();
string userApiVersion = packet.ReadString();
if (userApiVersion != GameConfiguration.ApiVersion)
{
playersManager.clients.Remove(playerId);
Logger.LogError(LoggerSection.Connection, $"Unable to add a client with old version ({userApiVersion}) to the game");
return;
}
if (playerId != packetPlayerId)
{
throw new Exception($"Bad playerId {playerId} received");
}
if (userName.Equals(""))
{
Logger.LogError(LoggerSection.Connection, $"Bad user name passed from player {playerId}");
return;
}
Logger.LogEvent(LoggerSection.Connection, $"{playersManager.clients[playerId].GetTcpEndPoint()} connected successfully and is now a player {playerId}");
lobbyGamePhase.ConnectPlayer(playerId, userName);
}
public override void Interact()
{
if (playGamePhase.clientSkeld.playGamePhaseUserInterface.minimapButton.IsMinimapShown)
{
return;
}
if (isTransitionGoing)
{
Logger.LogNotice(SharedLoggerSection.Interactions, "Unable to interact with security panel, because fade animation is still going");
return;
}
isControlledPlayerViewing = !isControlledPlayerViewing;
if (isControlledPlayerViewing)
{
playersLockable.Add(playersManager.controlledClientPlayer.basePlayer.information.id);
Logger.LogEvent(SharedLoggerSection.Interactions, "Has started viewing security panel");
}
else
{
playersLockable.Remove(playersManager.controlledClientPlayer.basePlayer.information.id);
Logger.LogEvent(SharedLoggerSection.Interactions, "Has stopped viewing security panel");
}
isTransitionGoing = true;
isFirstTransition = true;
StartCoroutine(BlinkFade());
}
public void TryToScheduleGameStart(int calledPlayerId)
{
if (!PlayersManager.IsLobbyHost(calledPlayerId))
{
Logger.LogNotice(SharedLoggerSection.GameStart, $"Player {calledPlayerId} tries to schedule game start, but he's not the host");
return;
}
if (playersManager.clients.Count < GameConfiguration.MinRequiredPlayersAmountForGame)
{
Logger.LogError(SharedLoggerSection.GameStart, "Attempt to start a game with too few players in it");
return;
}
if (GameStarts)
{
Logger.LogError(SharedLoggerSection.GameStart, "Attempt to start a game which is already starting");
return;
}
GameStarts = true;
metaMonoBehaviours.coroutines.StartCoroutine(StartGame());
Logger.LogEvent(SharedLoggerSection.GameStart, "Game starts");
}
private void InitializeScene(UnityEngine.SceneManagement.Scene scene, LoadSceneMode loadSceneMode)
{
switch (scene.name)
{
case Scene.MainMenu:
mainMenuGamePhase.Initialize();
break;
case Scene.Lobby:
lobbyGamePhase.Initialize();
break;
case Scene.RoleReveal:
roleRevealGamePhase.Initialize();
break;
case Scene.Skeld:
playGamePhase.Initialize();
break;
default:
Logger.LogError(SharedLoggerSection.ScenesManager, $"No game phase initializer found for the scene {scene.name}");
break;
}
}
/**
* Callback that is getting called when player presses interaction key near interactable
*/
public override void Interact(int playerId)
{
PlayerColor newPlayerColor = PlayerColors.SwitchToRandomColor(playerId);
playersManager.clients[playerId].basePlayer.colorable.ChangeColor(newPlayerColor);
Logger.LogEvent(SharedLoggerSection.PlayerColors, $"Changed player {playerId} color to {Helpers.GetEnumName(newPlayerColor)}");
}
public void ProcessPacket(int playerId, int packetTypeId, Packet packet, bool isTcp)
{
string packetTypeName = Helpers.GetEnumName((ClientPacketType)packetTypeId);
string protocolName = isTcp ? "TCP" : "UDP";
Logger.LogEvent(LoggerSection.Network, $"Received «{packetTypeName}» {protocolName} packet from the client {playerId}");
packetHandlers[packetTypeId](playerId, packet);
}
public void RequestGameStart()
{
if (!HasEnoughPlayersForGame())
{
return;
}
playersManager.controlledClientPlayer.clientControllable.OnStartGame();
Logger.LogEvent(SharedLoggerSection.GameStart, "Requested game start");
}
public void InitiateGameStart()
{
gameStarts = true;
secondsBeforeGameStartsLeft = LobbyGamePhase.SecondsForGameLaunch;
gameStartsInLabel.text = GetGameStartsInLabelText();
gameStartsInLabel.gameObject.SetActive(true);
StartCoroutine(ProcessGameStartTick());
Logger.LogEvent(SharedLoggerSection.GameStart, "Starting the game");
}
public void Start()
{
Logger.Initialize(new[] { LoggerSection.Network, LoggerSection.GameSnapshots }, true);
Logger.LogEvent(LoggerSection.Initialization, "Started client initialization");
metaMonoBehaviours.Initialize();
scenesManager.Initialize(InitializeScene);
Logger.LogEvent(LoggerSection.Initialization, "Initialized global environment");
scenesManager.LoadScene(Scene.MainMenu);
}
public void DisableSecurityCameras()
{
foreach (SecurityCamera camera in cameras)
{
camera.Disable();
}
CamerasEnabled = false;
Logger.LogEvent(SharedLoggerSection.Interactions, "Enabled security cameras");
}
private void ProcessPlayerInputPacket(int playerId, Packet packet)
{
// Because of multi threading we might not have this client yet
if (!playersManager.clients.ContainsKey(playerId))
{
Logger.LogNotice(LoggerSection.GameSnapshots, $"Unable to process not yet initialized player {playerId} input");
return;
}
PlayerInput playerInput = packet.ReadPlayerInput();
playersManager.clients[playerId].serverPlayer.remoteControllable.EnqueueInput(playerInput);
}
public void Add(int playerId)
{
lockedPlayerIds.Add(playerId);
BasePlayer basePlayer = basePlayersManager.players[playerId];
if (basePlayer.movable.isDisabled)
{
Logger.LogError(SharedLoggerSection.Interactions, $"Unable to lock the disabled player {playerId}");
return;
}
basePlayer.movable.isDisabled = true;
}
public void Remove(int playerId)
{
lockedPlayerIds.Remove(playerId);
BasePlayer basePlayer = basePlayersManager.players[playerId];
if (!basePlayer.movable.isDisabled)
{
Logger.LogError(SharedLoggerSection.Interactions, $"Unable to unlock the not disabled player {playerId}");
return;
}
basePlayer.movable.isDisabled = false;
}
private IEnumerator StartGame()
{
yield return(new WaitForSeconds(SecondsForGameLaunch));
int[] impostorPlayerIds = GetImpostorPlayerIds();
foreach (int impostorPlayerId in impostorPlayerIds)
{
playersManager.clients[impostorPlayerId].basePlayer.impostorable.isImpostor = true;
}
scenesManager.LoadScene(Scene.Skeld);
Logger.LogEvent(SharedLoggerSection.GameStart, $"Game has started. Impostors: {string.Join(", ", impostorPlayerIds)}");
}
private Sprite GetSprite(PlayerColor playerColor)
{
switch (playerColor)
{
case PlayerColor.Red:
return(minimapIconSprites.redSprite);
case PlayerColor.Blue:
return(minimapIconSprites.blueSprite);
case PlayerColor.Green:
return(minimapIconSprites.greenSprite);
case PlayerColor.Yellow:
return(minimapIconSprites.yellowSprite);
case PlayerColor.Pink:
return(minimapIconSprites.pinkSprite);
case PlayerColor.Orange:
return(minimapIconSprites.orangeSprite);
case PlayerColor.Purple:
return(minimapIconSprites.purpleSprite);
case PlayerColor.Black:
return(minimapIconSprites.blackSprite);
case PlayerColor.Brown:
return(minimapIconSprites.brownSprite);
case PlayerColor.Cyan:
return(minimapIconSprites.cyanSprite);
case PlayerColor.Lime:
return(minimapIconSprites.limeSprite);
case PlayerColor.White:
return(minimapIconSprites.whiteSprite);
default:
Logger.LogError(SharedLoggerSection.PlayerColors, $"Undefined sprite for color {Shared.Helpers.GetEnumName(playerColor)}");
return(minimapIconSprites.redSprite);
}
}
public override void Interact()
{
if (playGamePhase.clientSkeld.playGamePhaseUserInterface.minimapButton.IsMinimapShown)
{
return;
}
isControlledPlayerViewing = !isControlledPlayerViewing;
if (isControlledPlayerViewing)
{
adminPanelMinimap.SetActive(true);
playersLockable.Add(playersManager.controlledClientPlayer.basePlayer.information.id);
Logger.LogEvent(SharedLoggerSection.Interactions, "Started viewing admin panel");
}
else
{
adminPanelMinimap.SetActive(false);
playersLockable.Remove(playersManager.controlledClientPlayer.basePlayer.information.id);
Logger.LogEvent(SharedLoggerSection.Interactions, "Stopped viewing admin panel");
}
onInteraction?.Invoke();
}
public override void Interact()
{
Logger.LogEvent(SharedLoggerSection.PlayerColors, "Interacted with lobby computer");
}
private void UpdateAnimatorController()
{
RuntimeAnimatorController animatorController;
switch (clientPlayer.basePlayer.colorable.color)
{
case PlayerColor.Red:
animatorController = astronautAnimatorControllersRepository.redAnimatorController;
break;
case PlayerColor.Blue:
animatorController = astronautAnimatorControllersRepository.blueAnimatorController;
break;
case PlayerColor.Green:
animatorController = astronautAnimatorControllersRepository.greenAnimatorController;
break;
case PlayerColor.Yellow:
animatorController = astronautAnimatorControllersRepository.yellowAnimatorController;
break;
case PlayerColor.Pink:
animatorController = astronautAnimatorControllersRepository.pinkAnimatorController;
break;
case PlayerColor.Orange:
animatorController = astronautAnimatorControllersRepository.orangeAnimatorController;
break;
case PlayerColor.Purple:
animatorController = astronautAnimatorControllersRepository.purpleAnimatorController;
break;
case PlayerColor.Black:
animatorController = astronautAnimatorControllersRepository.blackAnimatorController;
break;
case PlayerColor.Brown:
animatorController = astronautAnimatorControllersRepository.brownAnimatorController;
break;
case PlayerColor.Cyan:
animatorController = astronautAnimatorControllersRepository.cyanAnimatorController;
break;
case PlayerColor.Lime:
animatorController = astronautAnimatorControllersRepository.limeAnimatorController;
break;
case PlayerColor.White:
animatorController = astronautAnimatorControllersRepository.whiteAnimatorController;
break;
default:
Logger.LogError(SharedLoggerSection.PlayerColors, "Undefined player color");
return;
}
animator.runtimeAnimatorController = animatorController;
}
public void LoadScene(string sceneName)
{
SceneManager.LoadScene(sceneName, LoadSceneMode.Additive);
Logger.LogEvent(SharedLoggerSection.ScenesManager, $"Loaded scene {sceneName}");
}
public void UnloadScene(string sceneName)
{
SceneManager.UnloadSceneAsync(sceneName);
Logger.LogEvent(SharedLoggerSection.ScenesManager, $"Unloaded scene {sceneName}");
}
