private void CacheFriendsForTeams()
{
this._friendsPerTeam.Clear();
IEnumerable <PlayerId> friends = FriendListService.GetAllFriendsInAllPlatforms();
if (friends == null)
{
return;
}
IEnumerable <MissionPeer> source = VirtualPlayer.Peers <MissionPeer>().Where <MissionPeer>((Func <MissionPeer, bool>)(x => friends.Contains <PlayerId>(x.Peer.Id)));
foreach (Team team1 in (ReadOnlyCollection <Team>) this.Mission.Teams)
{
Team team = team1;
if (team != null)
{
this._friendsPerTeam.Add(team, source.Where <MissionPeer>((Func <MissionPeer, bool>)(x => x.Team == team)).Select <MissionPeer, VirtualPlayer>((Func <MissionPeer, VirtualPlayer>)(x => x.Peer)));
}
}
if (this.OnUpdateFriendsPerTeam == null)
{
return;
}
this.OnUpdateFriendsPerTeam();
}
public Simulation_Window(string image, string DMode)
{
this.InitializeComponent();
virtualPlayer = new VirtualPlayer(this.InkCanvas, this.path);
virtualPlayer.startSimulation(image, DMode);
Console.WriteLine(image);
}
/// <summary>
/// Handles spectating a user if applicable
/// </summary>
public void HandleSpectating()
{
if (Screen.SpectatorClient == null)
{
return;
}
if (CurrentFrame >= Replay.Frames.Count)
{
if (AudioEngine.Track.IsPlaying)
{
AudioEngine.Track.Pause();
}
if (!Screen.IsPaused)
{
Screen.IsPaused = true;
}
return;
}
VirtualPlayer.PlayAllFrames();
if (Screen.IsPaused)
{
Screen.IsPaused = false;
}
if (AudioEngine.Track.IsPaused)
{
AudioEngine.Track.Play();
}
}
public override void HandleNewClientAfterLoadingFinished(NetworkCommunicator networkPeer)
{
VirtualPlayer virtualPlayer1 = networkPeer.VirtualPlayer;
GameNetwork.BeginBroadcastModuleEvent();
GameNetwork.WriteMessage((GameNetworkMessage) new InitializeLobbyPeer(networkPeer, virtualPlayer1.Id, virtualPlayer1.BannerCode, virtualPlayer1.BodyProperties, virtualPlayer1.ChosenBadgeIndex, -1));
GameNetwork.EndBroadcastModuleEvent(GameNetwork.EventBroadcastFlags.AddToMissionRecord | GameNetwork.EventBroadcastFlags.DontSendToPeers);
foreach (NetworkCommunicator networkPeer1 in GameNetwork.NetworkPeers)
{
if (networkPeer1.IsSynchronized || networkPeer1 == networkPeer)
{
if (networkPeer1 != networkPeer && networkPeer1 != GameNetwork.MyPeer)
{
GameNetwork.BeginModuleEventAsServer(networkPeer1);
GameNetwork.WriteMessage((GameNetworkMessage) new InitializeLobbyPeer(networkPeer, virtualPlayer1.Id, virtualPlayer1.BannerCode, virtualPlayer1.BodyProperties, virtualPlayer1.ChosenBadgeIndex, -1));
GameNetwork.EndModuleEventAsServer();
}
VirtualPlayer virtualPlayer2 = networkPeer1.VirtualPlayer;
if (!networkPeer.IsServerPeer)
{
GameNetwork.BeginModuleEventAsServer(networkPeer);
GameNetwork.WriteMessage((GameNetworkMessage) new InitializeLobbyPeer(networkPeer1, virtualPlayer2.Id, virtualPlayer2.BannerCode, virtualPlayer2.BodyProperties, virtualPlayer2.ChosenBadgeIndex, -1));
GameNetwork.EndModuleEventAsServer();
}
}
}
}
private void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.tag == "Player" && !playerObj)
{
playerObj = collision.gameObject.GetComponent <VirtualPlayer>();
animator.SetBool("isTalking", true);
GameManager.Instance.shoppingWindow.SetActive(true);
}
}
private void OnCollisionExit(Collision collision)
{
if (collision.gameObject.tag == "Player")
{
playerObj = null;
animator.SetBool("isTalking", false);
GameManager.Instance.shoppingWindow.SetActive(false);
}
}
private void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.tag == "Player" && !playerObj && GameManager.Instance.progress != StaticData.GAME_PROGRESS.FIGHTING)
{
playerObj = collision.gameObject.GetComponent <VirtualPlayer>();
animator.SetBool("isReady", true);
GameManager.Instance.ChangeProgress(StaticData.GAME_PROGRESS.FIGHTING);
joystick.SetNoOfInstruction(this);
}
}
public virtual void RequestStopSpawnSession()
{
this.IsSpawningEnabled = false;
this.SpawningDelayTimer = 0.0f;
this._hasCalledSpawningEnded = false;
foreach (MissionPeer peer in VirtualPlayer.Peers <MissionPeer>())
{
this.AgentVisualSpawnComponent.RemoveAgentVisuals(peer, true);
}
}
public UserControl_Passive(StateUpdate_Model stateUpdate, HomePage_ViewModel homePageViewModel)
{
this.activatetuto = false;
this.BarInfoPassive = new UserControl_GameInfoBar(stateUpdate, homePageViewModel);
InitializeComponent();
this.virtualP = new VirtualPlayer(this.PassiveCanvas, this.PassiveCanvasPath);
this.InfoBar.Children.Add(this.BarInfoPassive);
}
public MatrixFrame GetSpawnPointFrameForPlayer(
VirtualPlayer player,
BattleSideEnum side,
int agentVisualIndex,
int totalTroopCount,
bool isMounted = false)
{
if (agentVisualIndex == 0)
{
int num1 = -1;
int num2 = -1;
for (int index = 0; index < this._visualSpawnPointUsers.Length; ++index)
{
if (this._visualSpawnPointUsers[index] == player)
{
num1 = index;
break;
}
if (num2 < 0 && this._visualSpawnPointUsers[index] == null)
{
num2 = index;
}
}
int index1 = num1 >= 0 ? num1 : num2;
if (index1 < 0)
{
return(MatrixFrame.Identity);
}
this._visualSpawnPointUsers[index1] = player;
GameEntity gameEntity = (GameEntity)null;
switch (side)
{
case BattleSideEnum.Defender:
gameEntity = this._visualDefenderSpawnPoints[index1];
break;
case BattleSideEnum.Attacker:
gameEntity = this._visualAttackerSpawnPoints[index1];
break;
}
MatrixFrame matrixFrame = gameEntity != null?gameEntity.GetGlobalFrame() : this._visualSpawnPoints[index1].GetGlobalFrame();
matrixFrame.rotation.OrthonormalizeAccordingToForwardAndKeepUpAsZAxis();
return(matrixFrame);
}
Vec3 origin1 = this._visualSpawnPoints[3].GetGlobalFrame().origin;
Vec3 origin2 = this._visualSpawnPoints[1].GetGlobalFrame().origin;
Vec3 origin3 = this._visualSpawnPoints[5].GetGlobalFrame().origin;
Mat3 rotation = this._visualSpawnPoints[0].GetGlobalFrame().rotation;
rotation.MakeUnit();
List <WorldFrame> formationCreation = Formation.GetFormationFramesForBeforeFormationCreation(origin2.Distance(origin3), totalTroopCount, isMounted, new WorldPosition(Mission.Current.Scene, origin1), rotation);
return(formationCreation.Count < agentVisualIndex ? new MatrixFrame(rotation, origin1) : formationCreation[agentVisualIndex - 1].ToGroundMatrixFrame());
}
private void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.tag == "Player" && !playerObj)
{
playerObj = collision.gameObject.GetComponent <VirtualPlayer>();
animator.SetBool("isCrying", true);
GameManager.Instance.ChangeProgress(StaticData.GAME_PROGRESS.WINNING);
AudioManager.Instance.PlaySoundEffect(clip, true);
Celebrate();
}
}
private void HandleServerEventInitializeLobbyPeer(InitializeLobbyPeer message)
{
NetworkCommunicator peer = message.Peer;
VirtualPlayer virtualPlayer = peer.VirtualPlayer;
virtualPlayer.Id = message.ProvidedId;
virtualPlayer.BannerCode = message.BannerCode;
virtualPlayer.BodyProperties = message.BodyProperties;
virtualPlayer.ChosenBadgeIndex = message.ChosenBadgeIndex;
peer.ForcedAvatarIndex = message.ForcedAvatarIndex;
}
public void FreeSpawnPointFromPlayer(VirtualPlayer player)
{
for (int index = 0; index < this._visualSpawnPointUsers.Length; ++index)
{
if (this._visualSpawnPointUsers[index] == player)
{
this._visualSpawnPointUsers[index] = (VirtualPlayer)null;
break;
}
}
}
public override void HandleEarlyNewClientAfterLoadingFinished(NetworkCommunicator networkPeer)
{
PlayerData parameter = networkPeer.PlayerConnectionInfo.GetParameter <PlayerData>("PlayerData");
VirtualPlayer virtualPlayer = networkPeer.VirtualPlayer;
virtualPlayer.Id = parameter.PlayerId;
virtualPlayer.BannerCode = parameter.Bannercode;
virtualPlayer.BodyProperties = parameter.BodyProperties;
virtualPlayer.IsFemale = parameter.IsFemale;
virtualPlayer.ChosenBadgeIndex = parameter.ShownBadgeIndex;
networkPeer.IsMuted = parameter.IsMuted;
}
public void ClearPeerCounts()
{
foreach (MissionPeer peer in VirtualPlayer.Peers <MissionPeer>())
{
peer.AssistCount = 0;
peer.DeathCount = 0;
peer.KillCount = 0;
peer.Score = 0;
GameNetwork.BeginBroadcastModuleEvent();
GameNetwork.WriteMessage((GameNetworkMessage) new KillDeathCountChange(peer.GetNetworkPeer(), (NetworkCommunicator)null, peer.KillCount, peer.AssistCount, peer.DeathCount, peer.Score));
GameNetwork.EndBroadcastModuleEvent(GameNetwork.EventBroadcastFlags.None);
}
}
/// <summary>
/// Determines which frame we are on in the replay and sets if it has unique key presses/releases.
/// </summary>
internal void HandleInput()
{
if (Screen.SpectatorClient != null)
{
VirtualPlayer.PlayAllFrames();
}
HandleScoring();
if (CurrentFrame >= Replay.Frames.Count || !(Manager.CurrentAudioPosition >= Replay.Frames[CurrentFrame].Time) || !Screen.InReplayMode)
{
return;
}
var previousActive = Replay.KeyPressStateToLanes(Replay.Frames[CurrentFrame - 1].Keys);
var currentActive = Replay.KeyPressStateToLanes(Replay.Frames[CurrentFrame].Keys);
foreach (var activeLane in currentActive)
{
try
{
if (!previousActive.Contains(activeLane))
{
UniquePresses[activeLane] = true;
}
}
catch (Exception)
{
// ignored
}
}
foreach (var activeLane in previousActive)
{
try
{
if (!currentActive.Contains(activeLane))
{
UniqueReleases[activeLane] = true;
}
}
catch (Exception)
{
// ignored
}
}
CurrentFrame++;
}
public void passiveStep1()
{
Tutorial_popupWindow a = new Tutorial_popupWindow("Bienvenu(e) dans la vue passive, vous allez avoir accès à cette vue quand c'est à l'équipe adverse de jouer.\n" +
"Vous pouvez voir que votre rôle est devenu passif et que la couleur des barres est verte.\n" +
"Dans cette vue, vous allez avoir accès à ce que le devineur de l'équipe adverse voit.", "Ok");
a.ShowDialog();
a = new Tutorial_popupWindow("Le rôle de passif consiste à regarder la partie qui se joue de l'équipe adverse. Une fois le temps écouler, si l'équipe adverse ne devine pas le mot, vous aller avoir le droit à une riposte pour essayer de deviner le mot.", "Ok");
a.ShowDialog();
a = new Tutorial_popupWindow("Après avoir cliqué sur \"ok\", vous aller voir une simulation d'une partie qui durera 15 secondes, où l'autre équipe ne réussira pas à deviner le mot. Cliquer sur \"ok\" pour commencer.", "Ok");
a.ShowDialog();
virtualP = new VirtualPlayer(this.PassiveCanvas, this.PassiveCanvasPath);
virtualP.startSimulation("svg_16udqo3c4k3c6ptda.svg", "PANORAMIC_U");
this.wait();
}
//////////////////////////////////////////////////////////////////////////
// RoundStartCO ( Coroutine )
private IEnumerator RoundStartCO()
{
UI.Instance.PrintStatus("");
// Give two random cards to players
for (int i = 0; i < MAX_PLAYERS; i++)
{
VirtualPlayer player = VirtualPlayer.Players[i];
for (int j = 0; j < 2; j++)
{
Card randomCard = m_Deck[Random.Range(0, m_Deck.Count)].GetComponent <Card>();
player.GetCard(randomCard);
}
}
// Give two random cards to dealer, first is hidden
Card randomCard1 = m_Deck[Random.Range(0, m_Deck.Count)].GetComponent <Card>();
Dealer.Instance.GetCard(randomCard1);
Card randomCard2 = m_Deck[Random.Range(0, m_Deck.Count)].GetComponent <Card>();
Dealer.Instance.GetCard(randomCard2);
// hide mouse
Cursor.visible = false;
Cursor.lockState = CursorLockMode.Locked;
m_RoundStartTime = m_HiddenCardShowTime;
while (m_RoundStartTime > 0f)
{
m_RoundStartTime -= Time.deltaTime;
yield return(null);
}
Cursor.visible = true;
Cursor.lockState = CursorLockMode.None;
randomCard1.Shown = false;
// Game setup is completed, players make their own decision
VirtualPlayer.Players.ForEach(( VirtualPlayer p ) => p.MakeDecision());
GameActive = true;
UI.Instance.PrintStatus("Players Turn");
this.ChechGameStatus();
}
protected override void OnEndMission()
{
base.OnEndMission();
if (!GameNetwork.IsServer)
{
return;
}
foreach (NetworkCommunicator networkPeer in GameNetwork.NetworkPeers)
{
VirtualPlayer virtualPlayer = networkPeer.VirtualPlayer;
TeamDeathmatchMissionRepresentative component = virtualPlayer.GetComponent <TeamDeathmatchMissionRepresentative>();
if (component != null)
{
virtualPlayer.RemoveComponent((PeerComponent)component);
}
}
}
public NoobContinuousFire(BattleMain.Battle battle, VirtualPlayer virtualPlayer, int indexNum, float x) : base(battle, virtualPlayer, indexNum)
{
hp = 65000;
radius = 32f;
position = new Vector2(x, BattleWindow.Up - 50f);
speed = 6f;
headTime = 600;
middleTime = 5000;
shootTime = 1600;
shootInterval = 80;
shootCount = 0;
enableShootCount = 10;
isBulletToItem = false;
}
//////////////////////////////////////////////////////////////////////////
// OnReet
public void NewRound()
{
m_WinnerPlayer = null;
m_HigherPlayerPoints = 0;
GameActive = false;
// Reset cards
Card.Cards.ForEach(( Card c ) => c.OnReset());
// Reset players
VirtualPlayer.Players.ForEach(( VirtualPlayer p ) => p.OnReset());
Dealer.Instance.OnReset();
m_CurrentPhase = GAMEPHASE.PLAYERS;
StartCoroutine(RoundStartCO());
}
private void UpdateTextMessage(int playerId, string text)
{
//Unlike the others, we do display our own text messages, but it is handled differently
if (playerId == _myPlayerId)
{
GameObject.FindGameObjectWithTag("Player").GetComponent <DialogController>().Speak(text, 5.0f);
return;
}
//If this is an existing player, update their stats
foreach (GameObject go in _players)
{
VirtualPlayer player = go.GetComponent <VirtualPlayer>();
if (player.Id == playerId)
{
player.UpdateText(text);
return;
}
}
}
internal override void Init()
{
Player1 = new Player(Players.player1, ElementTypes.cross);
Player2 = new VirtualPlayer(Players.player2, ElementTypes.dot);
_curentPlayer = Player1;
_gameState = GameState.started;
BoardCellModels = new BoardCellModel[BoardManager.Instance.BoardWidth, BoardManager.Instance.BoardHeigh];
for (int i = 0; i < BoardManager.Instance.BoardWidth; i++)
{
for (int j = 0; j < BoardManager.Instance.BoardHeigh; j++)
{
var cellModel = new BoardCellModel(ElementTypes.none);
cellModel.ElementType = ElementTypes.none;
BoardCellModels[i, j] = cellModel;
}
}
NotifyTurn();
}
/// <summary>
/// Add distant player to main GUI.
/// </summary>
/// <param name="player">The distant player to be added.</param>
/// <returns>The particular distant player's GUI.</returns>
public VirtualPlayer AddPlayer(Player player)
{
GameObject playerGUI = Resources.Load("distant_player") as GameObject;
GameObject playerOverview = Instantiate(playerGUI, this.transform.root);
GameObject playerIcon = Resources.Load("player") as GameObject;
Text playerLabel = playerIcon.GetComponentInChildren <Text>();
playerLabel.text = player.Name;
GameObject distantPlayerIcon = Instantiate(playerIcon, this.transform);
PlayerOverview po = distantPlayerIcon.GetComponent <PlayerOverview>();
po.Overview = playerOverview;
VirtualPlayer virtualPlayer = playerOverview.GetComponentInChildren <VirtualPlayer>();
virtualPlayer.Initialize();
return(virtualPlayer);
}
private void UpdateTeamPowerBasedOnGold(Team team)
{
int num1 = 0;
int num2 = 0;
foreach (MissionPeer peer in VirtualPlayer.Peers <MissionPeer>())
{
if (peer.Team != null && peer.Team.Side == team.Side)
{
int gold = peer.GetComponent <FlagDominationMissionRepresentative>().Gold;
if (gold >= 100)
{
num2 += gold;
}
if (peer.ControlledAgent != null && peer.ControlledAgent.IsActive())
{
MultiplayerClassDivisions.MPHeroClass classForCharacter = MultiplayerClassDivisions.GetMPHeroClassForCharacter(peer.ControlledAgent.Character);
num2 += classForCharacter.TroopCost;
}
++num1;
}
}
int num3 = num1 + (team.Side == BattleSideEnum.Attacker ? MultiplayerOptions.OptionType.NumberOfBotsTeam1.GetIntValue() : MultiplayerOptions.OptionType.NumberOfBotsTeam2.GetIntValue());
foreach (Agent activeAgent in team.ActiveAgents)
{
if (activeAgent.MissionPeer == null)
{
num2 += 300;
}
}
int num4 = num3 * 300;
float num5 = Math.Min(1f, num4 == 0 ? 0.0f : (float)num2 / (float)num4);
Action <BattleSideEnum, float> powerChangedEvent = this.OnTeamPowerChangedEvent;
if (powerChangedEvent == null)
{
return;
}
powerChangedEvent(team.Side, num5);
}
public void PlaceOnWorld(World pWorld, RaycastHit pHitSpot, VirtualPlayer p)
{
transform.localScale = Vector3.zero;
transform.DOScale(new Vector3(pWorld.blockSize * _proportions.x, pWorld.blockSize * _proportions.y,
pWorld.blockSize * _proportions.z), _scaleTime);
Vector3 scaledNormal = Vector3.Scale(pHitSpot.normal, _proportions);
transform.position = pHitSpot.transform.position + scaledNormal * pWorld.blockSize;
Quaternion rot = Quaternion.LookRotation(-p.transform.forward, pWorld.transform.up);
Quaternion blockSpacesRot = pWorld.gridSpaces.transform.rotation;
Vector3 eulerRot = rot.eulerAngles;
eulerRot = new Vector3(GetAngle(eulerRot.x), GetAngle(eulerRot.y), GetAngle(eulerRot.z))
+ new Vector3(0, blockSpacesRot.eulerAngles.y, blockSpacesRot.eulerAngles.z);
rot.eulerAngles = eulerRot;
transform.rotation = rot;
}
private void HandleScoring()
{
if (VirtualPlayer.CurrentFrame < VirtualPlayer.Replay.Frames.Count)
{
VirtualPlayer.PlayAllFrames();
}
for (var i = CurrentVirtualReplayStat + 1; i < VirtualPlayer.ScoreProcessor.Stats.Count; i++)
{
var hom = Screen.Ruleset.HitObjectManager as HitObjectManagerKeys;
if (hom?.CurrentAudioPosition >= VirtualPlayer.ScoreProcessor.Stats[i].SongPosition)
{
var judgement = VirtualPlayer.ScoreProcessor.Stats[i].Judgement;
((ScoreProcessorKeys)Screen.Ruleset.ScoreProcessor).CalculateScore(judgement);
// Update Scoreboard
var view = (GameplayScreenView)Screen.View;
view.UpdateScoreAndAccuracyDisplays();
var playfield = (GameplayPlayfieldKeys)Screen.Ruleset.Playfield;
playfield.Stage.ComboDisplay.MakeVisible();
if (judgement != Judgement.Miss)
{
playfield.Stage.HitError.AddJudgement(judgement, VirtualPlayer.ScoreProcessor.Stats[i].HitDifference);
}
playfield.Stage.JudgementHitBurst.PerformJudgementAnimation(judgement);
CurrentVirtualReplayStat++;
}
else
{
break;
}
}
}
private void CheckForPlayersSpawningAsBots()
{
foreach (MissionPeer peer in VirtualPlayer.Peers <MissionPeer>())
{
if (peer.GetNetworkPeer().IsSynchronized&& peer.ControlledAgent == null && (peer.Team != null && peer.ControlledFormation != null) && peer.SpawnCountThisRound > 0)
{
if (!peer.HasSpawnTimerExpired && peer.SpawnTimer.Check(MBCommon.GetTime(MBCommon.TimeType.Mission)))
{
peer.HasSpawnTimerExpired = true;
}
if (peer.HasSpawnTimerExpired && peer.WantsToSpawnAsBot && peer.ControlledFormation.HasUnitsWithCondition((Func <Agent, bool>)(agent => agent.IsActive() && agent.IsAIControlled)))
{
Agent newAgent = (Agent)null;
Agent followingAgent = peer.FollowedAgent;
if (followingAgent != null && followingAgent.IsActive() && (followingAgent.IsAIControlled && peer.ControlledFormation.HasUnitsWithCondition((Func <Agent, bool>)(agent => agent == followingAgent))))
{
newAgent = followingAgent;
}
else
{
float maxHealth = 0.0f;
peer.ControlledFormation.ApplyActionOnEachUnit((Action <Agent>)(agent =>
{
if ((double)agent.Health <= (double)maxHealth)
{
return;
}
maxHealth = agent.Health;
newAgent = agent;
}));
}
Mission.Current.ReplaceBotWithPlayer(newAgent, peer);
peer.WantsToSpawnAsBot = false;
peer.HasSpawnTimerExpired = false;
}
}
}
}
private void SendNotificationToTeam(
Team team,
MultiplayerGameNotificationsComponent.MultiplayerNotificationEnum message,
int param1 = -1,
int param2 = -1)
{
NetworkCommunicator myPeer = GameNetwork.MyPeer;
MissionPeer missionPeer = myPeer != null?myPeer.GetComponent <MissionPeer>() : (MissionPeer)null;
if (!GameNetwork.IsDedicatedServer && (missionPeer?.Team != null && missionPeer.Team.IsEnemyOf(team)))
{
this.ShowNotification(message, param1, param2);
}
foreach (MissionPeer peer in VirtualPlayer.Peers <MissionPeer>())
{
if (peer.Team != null && !peer.IsMine && !peer.Team.IsEnemyOf(team))
{
GameNetwork.BeginModuleEventAsServer(peer.Peer);
GameNetwork.WriteMessage((GameNetworkMessage) new NotificationMessage((int)message, param1, param2));
GameNetwork.EndModuleEventAsServer();
}
}
}
private void UpdateRoster(int playerId, int level, int spriteId, string name)
{
//Skip if this is "us"
//Debug.Log("Roster update for player ID " + playerId + ", name " + name);
if (playerId == _myPlayerId)
{
//Debug.Log("Received roster update for yourself!");
return;
}
;
//If this is an existing player, update their stats
foreach (GameObject go in _players)
{
VirtualPlayer player = go.GetComponent <VirtualPlayer>();
if (player.Id == playerId)
{
//If the level == -1, this player is disconnecting
if (level == -1)
{
_players.Remove(go);
//Debug.Log("Removing player " + player.Name + " from roster");
Destroy(go);
return;
}
//Debug.Log("Updating player " + player.Name);
player.UpdateStats(level, spriteId, name);
return;
}
}
//Else create a new player
Debug.Log("Creating new player " + playerId + ": " + name);
var newPlayer = Instantiate(VirtualPlayerPrefab);
newPlayer.GetComponent <VirtualPlayer>().InitializeStats(playerId, level, spriteId, name);
GameObject.DontDestroyOnLoad(newPlayer);
_players.Add(newPlayer);
}
