/// <summary>
        /// Call this to rotate an active player out and start the next waiting player.
        /// </summary>
        /// <param name="netPlayer">The NetPlayer of the player to return</param>
        public void ReturnPlayer(NetPlayer netPlayer)
        {
            NetPlayerState netPlayerState = GetActiveNetPlayerState(netPlayer);

            if (netPlayerState != null)
            {
                m_activePlayers.Remove(netPlayerState); // on enleve le netPlayer de la liste des actifs, s'il y est
            }
            else
            {
                netPlayerState = GetWaitingNetPlayerState(netPlayer);
                if (netPlayerState != null)
                {
                    m_waitingPlayers.Remove(netPlayerState);                     // on enleve le netPlayer de la file d'attente, s'il y est
                }
            }

            AddWaitingPlayer(netPlayerState);

            PlayerState playerState = GetPlayerState(netPlayer);

            if (playerState != null)
            {
                playerState.netPlayer = null;
                // Make the slot available immediately.
                playerState.disconnectTime = Time.time - m_timeoutForDisconnectedPlayersToReconnect;

                StartWaitingPlayers();
            }
        }
Esempio n. 2
0
 public void LeaveRoom()
 {
     playerState = NetPlayerState.InMainLobby;
     clientState = ClientTCPState.MainLobby;
     race        = null;
     room        = null;
 }
        // The player has disconnected
        void RemoveNetPlayer(object sender, EventArgs e)
        {
            NetPlayer      netPlayer      = (NetPlayer)sender;
            NetPlayerState netPlayerState = GetActiveNetPlayerState(netPlayer);

            if (netPlayerState != null)
            {
                m_activePlayers.Remove(netPlayerState);
            }

            netPlayerState = GetWaitingNetPlayerState(netPlayer);
            if (netPlayerState != null)
            {
                m_waitingPlayers.Remove(netPlayerState);
            }

            PlayerState playerState = GetPlayerState(netPlayer);

            if (playerState != null)
            {
                playerState.netPlayer      = null;
                playerState.disconnectTime = Time.time;
                StartWaitingPlayers();
            }
        }
        void StartNewPlayer(PlayerConnectMessageArgs e)
        {
            NetPlayerState netPlayerState = new NetPlayerState(e.netPlayer, e.data);
            string         id             = e.netPlayer.GetSessionId();

            if (id.Length > 0)
            {
                // Check if there is a slot with this id
                for (int pndx = 0; pndx < m_playerState.Length; ++pndx)
                {
                    PlayerState playerState = m_playerState[pndx];
                    if (playerState.id == id)
                    {
                        if (playerState.netPlayer == null)
                        {
                            StartActivePlayer(m_getGameObject(pndx), playerState, netPlayerState);
                            return;
                        }
                        else
                        {
                            m_log.Error("Player with same ID joined but they're already playing???");
                        }
                    }
                }
            }

            // Add player to list of all people connected
            AddWaitingPlayer(netPlayerState);
            StartWaitingPlayers();
        }
        void SendSpawnInfoToGameObject(string msg, GameObject gameObject, NetPlayerState netPlayerState, SendMessageOptions sendMessageOptions = SendMessageOptions.RequireReceiver)
        {
            SpawnInfo spawnInfo = new SpawnInfo();

            spawnInfo.netPlayer = netPlayerState.netPlayer;
            spawnInfo.data      = netPlayerState.data;
            gameObject.SendMessage(msg, spawnInfo, sendMessageOptions);
        }
        NetPlayerState DequeFirstWaitingPlayer()
        {
            IEnumerator <NetPlayerState> iter = m_waitingPlayers.GetEnumerator();

            iter.MoveNext();
            NetPlayerState netPlayerState = iter.Current;

            m_waitingPlayers.Remove(netPlayerState);
            return(netPlayerState);
        }
        void AddWaitingPlayer(NetPlayerState netPlayerState)
        {
            NetPlayer netPlayer = netPlayerState.netPlayer;

            netPlayer.RemoveAllHandlers();
            netPlayer.OnDisconnect += RemoveNetPlayer;
            m_waitingPlayers.Add(netPlayerState);

            // Execute WaitingNetPlayer on the GameObject using this class. In otherwords
            // the game object with the PlayerConnector or PlayerSpawer script component
            SendSpawnInfoToGameObject("WaitingNetPlayer", m_gameObject, netPlayerState, SendMessageOptions.DontRequireReceiver);
        }
        void StartActivePlayer(GameObject gameObject, PlayerState playerState, NetPlayerState netPlayerState)
        {
            m_activePlayers.Add(netPlayerState);

            NetPlayer netPlayer = netPlayerState.netPlayer;

            netPlayer.RemoveAllHandlers();
            netPlayer.OnDisconnect += RemoveNetPlayer;

            playerState.netPlayer = netPlayer;
            playerState.id        = netPlayer.GetSessionId();

            SendSpawnInfoToGameObject("InitializeNetPlayer", gameObject, netPlayerState);
        }
 public void StartWaitingPlayers()
 {
     if (m_waitingPlayers.Count > 0)
     {
         for (int pndx = 0; pndx < m_playerState.Length; ++pndx)
         {
             PlayerState playerState = m_playerState[pndx];
             if (SlotCanAcceptNewPlayer(playerState)) // le playerState n'est pas deconnecte
             {
                 NetPlayerState netPlayerState = DequeFirstWaitingPlayer();
                 if (netPlayerState == null)
                 {
                     return;                                                            // la file d'attente ne contient plus de netPlayerState, sortie de boucle
                 }
                 StartActivePlayer(m_getGameObject(pndx), playerState, netPlayerState); // on ajoute le netPlayer aux joueurs actifs
             }
         }
     }
 }
Esempio n. 10
0
 public void StartWaitingPlayers()
 {
     if (m_waitingPlayers.Count > 0)
     {
         for (int pndx = 0; pndx < m_playerState.Length; ++pndx)
         {
             PlayerState playerState = m_playerState[pndx];
             if (SlotCanAcceptNewPlayer(playerState))
             {
                 NetPlayerState netPlayerState = DequeFirstWaitingPlayer();
                 if (netPlayerState == null)
                 {
                     return;
                 }
                 StartActivePlayer(m_getGameObject(pndx), playerState, netPlayerState);
             }
         }
     }
 }
Esempio n. 11
0
 public void LogIn(string username)
 {
     accountData = Global.data.GetAccount(username);
     nickname    = accountData.Nickname;
     playerState = NetPlayerState.InMainLobby;
     clientState = ClientTCPState.MainLobby;
     foreach (string guideKey in accountData.Friends.ToArray())
     {
         foreach (ClientTCP friend in Global.clientList)
         {
             if (friend.accountData.GuideKey.Equals(guideKey))
             {
                 friends.Add(friend);
                 friend.friends.Add(this);
                 SendDataTCP.SendFriendInfo(friend, this);
                 break;
             }
         }
     }
     SendDataTCP.SendLoginOk(nickname, this);
 }
        void StartNewPlayer(object sender, PlayerConnectMessageArgs e)
        {
            NetPlayerState netPlayerState = new NetPlayerState(e.netPlayer, e.data);
            string id = e.netPlayer.GetSessionId();
            if (id.Length > 0) {
            // Check if there is a slot with this id
            for (int pndx = 0; pndx < m_playerState.Length; ++pndx) {
                PlayerState playerState = m_playerState[pndx];
                if (playerState.id == id) {
                    if (playerState.netPlayer == null) {
                        StartActivePlayer(m_getGameObject(pndx), playerState, netPlayerState);
                        return;
                    } else {
                        m_log.Error("Player with same ID joined but they're already playing???");
                    }
                }
            }
            }

            // Add player to list of all people connected
            AddWaitingPlayer(netPlayerState);
            StartWaitingPlayers();
        }
        void StartActivePlayer(GameObject gameObject, PlayerState playerState, NetPlayerState netPlayerState)
        {
            m_activePlayers.Add(netPlayerState);

            NetPlayer netPlayer = netPlayerState.netPlayer;
            netPlayer.RemoveAllHandlers();
            netPlayer.OnDisconnect += RemoveNetPlayer;

            playerState.netPlayer = netPlayer;
            playerState.id = netPlayer.GetSessionId();

            SendSpawnInfoToGameObject("InitializeNetPlayer", gameObject, netPlayerState);
        }
 void SendSpawnInfoToGameObject(string msg, GameObject gameObject, NetPlayerState netPlayerState, SendMessageOptions sendMessageOptions = SendMessageOptions.RequireReceiver)
 {
     SpawnInfo spawnInfo = new SpawnInfo();
     spawnInfo.netPlayer = netPlayerState.netPlayer;
     spawnInfo.data = netPlayerState.data;
     gameObject.SendMessage(msg, spawnInfo, sendMessageOptions);
 }
        void AddWaitingPlayer(NetPlayerState netPlayerState)
        {
            NetPlayer netPlayer = netPlayerState.netPlayer;
            netPlayer.RemoveAllHandlers();
            netPlayer.OnDisconnect += RemoveNetPlayer;
            m_waitingPlayers.Add(netPlayerState);

            // Execute WaitingNetPlayer on the GameObject using this class. In otherwords
            // the game object with the PlayerConnector or PlayerSpawer script component
            SendSpawnInfoToGameObject("WaitingNetPlayer", m_gameObject, netPlayerState, SendMessageOptions.DontRequireReceiver);
        }