//-----------------------------------------------------------------------------
        // server life cycle
        //-----------------------------------------------------------------------------

        public bool StartServer(int clientNum)
        {
            // can only start server when it is inactive
            if (IsServerActive())
            {
                ViveShare_Log.LogWarning(logLevel, "[ViveShare_Server] Server has started already!");
                return(false);
            }

            // try to start server on given port number
            if (!NetworkServer.Listen(portNumber))
            {
                ViveShare_Log.LogError(logLevel, "[ViveShare_Server] Failed to start server on port " + portNumber);
                ViveShare_Event.server_initFailedEvent.Invoke();
                return(false);
            }

            ViveShare_Log.LogInfo(logLevel, "[ViveShare_Server] Server started on port " + portNumber + " , anticipated client = " + clientNum);

            // initialize connection data
            anticipatedClientNum = clientNum;
            connectionDataList   = new List <ConnectionData>();
            connectionDataMap    = new Dictionary <int, ConnectionData>();

            RegisterMessageHandlers();

            // registor event callback types
            ViveShare_Event.RegistorEventEntry();

            ViveShare_Event.server_initSuccessEvent.Invoke();

            state = ViveNetworkState.Wait_Ready;

            return(true);
        }
        //-----------------------------------------------------------------------------
        // client life cycle
        //-----------------------------------------------------------------------------

        public bool StartClient()
        {
            // can only try connection when connection has not been established,
            // and previous attempt has failed
            if ((networkClient != null && networkClient.isConnected) || state != ViveNetworkState.Init)
            {
                ViveShare_Log.LogWarning(logLevel, "[ViveShare_Client] Cannot retry connection when client is busy");
                return(false);
            }

            networkClient = new NetworkClient();

            RegistorMessagHandlers();

            // registor event callback types
            ViveShare_Event.RegistorEventEntry();

            networkClient.Connect(serverAddr, portNumber);

            ViveShare_Log.LogInfo(logLevel, "[ViveShare_Client] Try to connect server (" + serverAddr + ") on port " + portNumber);

            state = ViveNetworkState.Wait_Connect;

            return(true);
        }
        public void StartGame()
        {
            // can only start game when in Wait_GameStart state
            if (state != ViveNetworkState.Wait_GameStart)
            {
                ViveShare_Log.LogWarning(logLevel, "[ViveShare_Server] Cannot start game -- either the game has started or not all clients are ready");
                return;
            }

            ViveShare_Log.LogInfo(logLevel, "[ViveShare_Server] Game start");

            // tell clients to start game
            EmptyMessage msg = new EmptyMessage();

            NetworkServer.SendToAll(ViveShareMsgType.GameStarted, msg);

            ViveShare_Event.gameStartEvent.Invoke();

            state = ViveNetworkState.Gaming;
        }
        public void SetClientReady()
        {
            // can only set client as ready when client is in Wait_Ready state
            if (state != ViveNetworkState.Wait_Ready)
            {
                ViveShare_Log.LogWarning(logLevel, "[ViveShare_Client] Cannot set ready when client is not in Wait_Ready state");
                return;
            }

            ViveShare_Log.LogInfo(logLevel, "[ViveShare_Client] Client is ready");

            // send ready message
            EmptyMessage msg = new EmptyMessage();

            networkClient.Send(MsgType.Ready, msg);

            ViveShare_Event.client_readyEvent.Invoke();

            state = ViveNetworkState.Wait_GameStart;
        }
        public void ShutdownServer()
        {
            // can't shut down server if it has not started
            if (state == ViveNetworkState.Init)
            {
                ViveShare_Log.LogWarning(logLevel, "[ViveShare_Server] Cannot shut down server since it has not been started");
                return;
            }

            // can't shut down server if game is still running
            if (state == ViveNetworkState.Gaming)
            {
                ViveShare_Log.LogWarning(logLevel, "[ViveShare_Server] Cannot shut down server when game is still running");
                return;
            }

            ViveShare_Log.LogInfo(logLevel, "[ViveShare_Server] Server shut down");

            // clear resources
            anticipatedClientNum = 0;

            foreach (NetworkConnection conn in NetworkServer.connections)
            {
                if (conn != null)
                {
                    RemoveConnectionData(conn.connectionId);
                }
            }

            // tell clients to disconnect
            EmptyMessage msg = new EmptyMessage();

            NetworkServer.SendToAll(MsgType.Disconnect, msg);

            NetworkServer.Shutdown();

            ViveShare_Event.server_shutdownEvent.Invoke();

            state = ViveNetworkState.Init;
        }
        public void EndGame()
        {
            // can only start game when game is running
            if (state != ViveNetworkState.Gaming)
            {
                ViveShare_Log.LogWarning(logLevel, "[ViveShare_Server] Cannot stop game if game has not started");
                return;
            }

            ViveShare_Log.LogInfo(logLevel, "[ViveShare_Server] Game end");

            RemoveSpawnedObjects();

            // tell clients to stop game
            EmptyMessage msg = new EmptyMessage();

            NetworkServer.SendToAll(ViveShareMsgType.GameEnd, msg);

            ViveShare_Event.gameEndEvent.Invoke();

            state = ViveNetworkState.Wait_Shutdown;
        }