Beispiel #1
0
    void    Update()
    {
        // 오류 핸들링.
        NetEventHandling();

        // ---------------------------------------------------------------- //
        // 스텝 내 경과 시간 진행.

        this.step_timer += Time.deltaTime;

        // ---------------------------------------------------------------- //
        // 다음 상태로 전환할지 체크한다.


        if (this.next_step == STEP.NONE)
        {
            switch (this.step)
            {
            case STEP.WAIT:
            {
            }
            break;
            }
        }

        // ---------------------------------------------------------------- //
        // 전환 시 초기화.

        while (this.next_step != STEP.NONE)
        {
            this.step      = this.next_step;
            this.next_step = STEP.NONE;

            switch (this.step)
            {
            case STEP.MATCHING:
            {
#if !UNUSE_MATCHING_SERVER
                int serverNode = -1;
                if (m_network != null)
                {
                    serverNode = m_network.Connect(m_serverAddress, NetConfig.MATCHING_SERVER_PORT, Network.ConnectionType.Reliable);
                    if (serverNode >= 0)
                    {
                        GameObject obj = new GameObject("MatchingClient");
                        m_client = obj.AddComponent <MatchingClient>();
                        if (m_client == null)
                        {
                            // 오류 강제 전환.
                            m_errorMessage = "매칭을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                            this.step      = STEP.ERROR;
                        }
                        m_client.SetServerNode(serverNode);
                    }
                    else
                    {
                        // 오류.
                        m_errorMessage = "매칭 서버에\n접속할 수 없습니다.\n\n버튼을 누르세요.";
                        this.step      = STEP.ERROR;
                    }
                }
                else
                {
                    // 오류.
                    m_errorMessage = "통신을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                    this.step      = STEP.ERROR;
                }
#else
                GameObject obj = new GameObject("MatchingClient");
                m_client = obj.AddComponent <MatchingClient>();
                if (m_client == null)
                {
                    // 오류로 강제 전환.
                    m_errorMessage = "매칭을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                    this.step      = STEP.ERROR;
                }
#endif
            }
            break;

            case STEP.SERVER_START:
            {
                m_network.ClearReceiveNotification();

                Debug.Log("Launch Listening socket.");
                // 같은 단말에서 실행할 수 있게 포토 번호를 다르게 한다.
                // 다른 단말에서 실행할 때는 포트 번호가 같은 것을 사용한다.
                int  port = NetConfig.GAME_PORT + GlobalParam.getInstance().global_account_id;
                bool ret  = m_network.StartServer(port, NetConfig.PLAYER_MAX, Network.ConnectionType.Unreliable);
                if (m_isHost)
                {
                    // 게임 서버 시작.
                    int playerNum = m_client.GetMemberNum();
                    ret &= m_network.StartGameServer(playerNum);
                }
                if (ret == false)
                {
                    // 오류로 강제 전환.
                    m_errorMessage = "게임 통신을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                    this.step      = STEP.ERROR;
                }
            }
            break;

            case STEP.SERVER_CONNECT:
            {
                // 호스트 이름 획득.
                if (m_isHost)
                {
                    string      hostname = Dns.GetHostName();
                    IPAddress[] adrList  = Dns.GetHostAddresses(hostname);
                    m_serverAddress = adrList[0].ToString();
                }
                // 게임 서버에 접속.
                Debug.Log("Connect to GameServer.");
                int serverNode = m_network.Connect(m_serverAddress, NetConfig.GAME_SERVER_PORT, Network.ConnectionType.Reliable);
                if (serverNode >= 0)
                {
                    m_network.SetServerNode(serverNode);
                }
                else
                {
                    // 오류로 강제 전환.
                    m_errorMessage = "게임 서버와 통신할 수 없습니다.\n\n버튼을 누르세요.";
                    this.step      = STEP.ERROR;
                }
            }
            break;

            case STEP.CLIENT_CONNECT:
            {
                Debug.Log("Connect to host.");
                MatchingClient.MemberList[] list = m_client.GetMemberList();
                int playerNum = m_client.GetMemberNum();
                for (int i = 0; i < playerNum; ++i)
                {
                    // 같은 단말에서 실행할 때는 전용으로 부여한 플레이어ID로 판별한다.
                    // 다른 단말에서 실행할 때는 IP주소로 판별할 수 있다.
                    // 샘플 코드에서는 양쪽에 대응할 수 있는 플레어ID로 판별한다.
                    if (m_client.GetPlayerId() == i)
                    {
                        // 자기 자신은 접속하지 않는다.
                        continue;
                    }
                    if (list[i] == null)
                    {
                        continue;
                    }
                    // 같은 단말에서 실행할 수 있게 포트 번호를 다르게 한다.
                    // 다른 단말에서 실행할 때는 포트 번호가 같은 것을 사용한다.
                    int    port          = NetConfig.GAME_PORT + i;
                    string memberAddress = list[i].endPoint.Address.ToString();
                    int    clientNode    = m_network.Connect(memberAddress, port, Network.ConnectionType.Unreliable);

                    if (clientNode >= 0)
                    {
                        m_network.SetClientNode(i, clientNode);
                    }
                    else
                    {
                        // 오류로 강제 전환.
                        m_errorMessage = "게임을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                        this.step      = STEP.ERROR;
                    }
                }
            }
            break;

#if UNUSE_MATCHING_SERVER
            case STEP.WAIT_SYNC:
            {
                CharEquipment equip = new CharEquipment();

                equip.globalId = GlobalParam.get().global_account_id;
                equip.shotType = (int)SHOT_TYPE.NEGI;

                EquipmentPacket packet     = new EquipmentPacket(equip);
                int             serverNode = m_network.GetServerNode();
                m_network.SendReliable <CharEquipment>(serverNode, packet);
            }
            break;
#endif

            case STEP.GAME_START:
            {
                GlobalParam.getInstance().fadein_start = true;
                Application.LoadLevel("WeaponSelectScene");
            }
            break;


            case STEP.WAIT_RESTART:
            {
                if (m_isHost)
                {
                    m_network.StopGameServer();
                }
                m_network.StopServer();
                m_network.Disconnect();
            }
            break;
            }
            this.step_timer = 0.0f;
        }

        // ---------------------------------------------------------------- //
        // 각 상태에서의 실행 처리.

        switch (this.step)
        {
        case STEP.WAIT:
        {
        }
        break;

        case STEP.MATCHING:
        {
            this.next_step = STEP.WAIT_MATCHING;
        }
        break;

        case STEP.WAIT_MATCHING:
        {
#if !UNUSE_MATCHING_SERVER
            if (m_client != null && m_client.IsFinishedMatching())
            {
                GlobalParam.get().global_account_id = m_client.GetPlayerId();

                m_isHost = m_client.IsRoomOwner();
#else
            {
#endif
                if (m_isHost)
                {
                    GlobalParam.get().is_host = true;
                }

                this.next_step = STEP.SERVER_START;
            }
        }
        break;

        case STEP.SERVER_START:
        {
            // 서버가 시작하길 기다린다.
#if UNUSE_MATCHING_SERVER
            if (this.step_timer > 5.0f)
            {
#else
            if (this.step_timer > 3.0f)
            {
#endif
                this.next_step = STEP.SERVER_CONNECT;
            }
        }
        break;

        case STEP.SERVER_CONNECT:
        {
            this.next_step = STEP.CLIENT_CONNECT;
        }
        break;

        case STEP.CLIENT_CONNECT:
        {
#if UNUSE_MATCHING_SERVER
            this.next_step = STEP.WAIT_SYNC;
#else
            this.next_step = STEP.GAME_START;
#endif
        }
        break;

#if UNUSE_MATCHING_SERVER
        case STEP.WAIT_SYNC:
        {
            // 클라이언트끼리 접속하길 기다린다.
            // 예제 코드에서는 대기 시간을 넣어서 접속을 기다렸다.
            // 원래는 UDP로 접속 처리를 작성해 커넥션을 펼 수 있게 하는 편이 좋다

            bool   isConnected = true;
            string connect     = "Connect:[sync:" + m_syncFlag;
            for (int i = 0; i < m_client.GetMemberNum(); ++i)
            {
                if (i == GlobalParam.get().global_account_id)
                {
                    continue;
                }

                int node = m_network.GetClientNode(i);
                isConnected &= m_network.IsConnected(node);

                connect += "[" + i + "(" + node + "):" + m_network.IsConnected(node) + "] ";
            }
            //Debug.Log(connect);

            if (isConnected || this.step_timer > 10.0f)
            {
                this.next_step = STEP.GAME_START;
            }

            ++count_;
        }
        break;
#endif

        case STEP.GAME_START:
        {
        }
        break;

        case STEP.ERROR:
        {
            this.next_step = STEP.WAIT_RESTART;
        }
        break;

        case STEP.WAIT_RESTART:
        {
        }
        break;
        }

        // ---------------------------------------------------------------- //
    }
    void    Update()
    {
        // 오류 핸들링.
        NetEventHandling();

        // ---------------------------------------------------------------- //
        // 스텝 내 경과 시간 진행.

        this.step_timer += Time.deltaTime;

        // ---------------------------------------------------------------- //
        // 전환 시 초기화.

        while (this.next_step != STEP.NONE)
        {
            this.step      = this.next_step;
            this.next_step = STEP.NONE;

            switch (this.step)
            {
            case STEP.MATCHING:
            {
                int serverNode = -1;
                if (m_network != null)
                {
                    serverNode = m_network.Connect(m_serverAddress, NetConfig.MATCHING_SERVER_PORT, Network.ConnectionType.Reliable);
                    if (serverNode >= 0)
                    {
                        GameObject obj = new GameObject("MatchingClient");
                        m_client = obj.AddComponent <MatchingClient>();
                        if (m_client == null)
                        {
                            // 오류 강제 전환.
                            m_errorMessage = "매칭을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                            this.step      = STEP.ERROR;
                        }
                        m_client.SetServerNode(serverNode);
                    }
                    else
                    {
                        // 오류.
                        m_errorMessage = "매칭 서버에\n접속할 수 없습니다.\n\n버튼을 누르세요.";
                        this.step      = STEP.ERROR;
                    }
                }
                else
                {
                    // 오류.
                    m_errorMessage = "통신을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                    this.step      = STEP.ERROR;
                }
            }
            break;

            case STEP.SERVER_START:
            {
                m_network.ClearReceiveNotification();

                Debug.Log("Launch Listening socket.");
                // 같은 단말에서 실행할 수 있게 포트 번호를 다르게 한다.
                // 다른 단말에서 실행할 때는 포트 번호가 같은 것을 사용한다.
                int  port = NetConfig.GAME_PORT + GlobalParam.get().global_account_id;
                bool ret  = m_network.StartServer(port, NetConfig.PLAYER_MAX, Network.ConnectionType.Unreliable);
                if (m_isHost)
                {
                    // 게임 서버 시작.
                    int playerNum = m_client.GetMemberNum();
                    ret &= m_network.StartGameServer(playerNum);
                }
                if (ret == false)
                {
                    // 오류로 강제 전환.
                    m_errorMessage = "게임 통신을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                    this.step      = STEP.ERROR;
                }
            }
            break;

            case STEP.SERVER_CONNECT:
            {
                // 호스트 이름 획득.
                if (m_isHost)
                {
                    string      hostname = Dns.GetHostName();
                    IPAddress[] adrList  = Dns.GetHostAddresses(hostname);
                    m_serverAddress = adrList[0].ToString();
                }
                // 게임 서버에 접속.
                Debug.Log("Connect to GameServer.");
                int serverNode = m_network.Connect(m_serverAddress, NetConfig.GAME_SERVER_PORT, Network.ConnectionType.Reliable);
                if (serverNode >= 0)
                {
                    m_network.SetServerNode(serverNode);
                }
                else
                {
                    // 오류로 강제 전환.
                    m_errorMessage = "게임 서버와 통신할 수 없습니다.\n\n버튼을 누르세요.";
                    this.step      = STEP.ERROR;
                }
            }
            break;

            case STEP.CLIENT_CONNECT:
            {
                Debug.Log("Connect to host.");
                MatchingClient.MemberList[] list = m_client.GetMemberList();
                int playerNum = m_client.GetMemberNum();
                for (int i = 0; i < playerNum; ++i)
                {
                    // 같은 단말에서 실행할 때는 전용으로 부여한 플레이어ID로 판별한다.
                    // 다른 단말에서 실행할 때는 IP주소로 판별할 수 있다.
                    if (m_client.GetPlayerId() == i)
                    {
                        // 자기 자신은 접속하지 않는다.
                        continue;
                    }
                    if (list[i] == null)
                    {
                        continue;
                    }
                    // 같은 단말에서 실행할 수 있게 포트 번호를 다르게 한다.
                    // 다른 단말에서 실행할 때는 포트 번호가 같은 것을 사용한다.
                    int    port          = NetConfig.GAME_PORT + i;
                    string memberAddress = list[i].endPoint.Address.ToString();
                    int    clientNode    = m_network.Connect(memberAddress, port, Network.ConnectionType.Unreliable);

                    if (clientNode >= 0)
                    {
                        m_network.SetClientNode(i, clientNode);
                    }
                    else
                    {
                        // 오류로 강제 전환.
                        m_errorMessage = "게임을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                        this.step      = STEP.ERROR;
                    }
                }
            }
            break;

            case STEP.GAME_START:
            {
                GlobalParam.get().fadein_start = true;
                GlobalParam.get().playerNum    = m_client.GetMemberNum();
                Application.LoadLevel("scGame");
            }
            break;


            case STEP.WAIT_RESTART:
            {
                if (m_isHost)
                {
                    m_network.StopGameServer();
                }
                m_network.StopServer();
                m_network.Disconnect();
            }
            break;
            }
            this.step_timer = 0.0f;
        }

        // ---------------------------------------------------------------- //
        // 각 상태에서의 실행 처리.

        switch (this.step)
        {
        case STEP.MATCHING:
        {
            this.next_step = STEP.WAIT_MATCHING;
        }
        break;

        case STEP.WAIT_MATCHING:
        {
            if (m_client != null && m_client.IsFinishedMatching())
            {
                GlobalParam.get().global_account_id = m_client.GetPlayerId();

                m_isHost = m_client.IsRoomOwner();

                if (m_isHost)
                {
                    GlobalParam.get().is_host = true;
                }

                this.next_step = STEP.SERVER_START;
            }
        }
        break;

        case STEP.SERVER_START:
        {
            // 서버가 시작하길 기다린다.
            if (this.step_timer > 3.0f)
            {
                this.next_step = STEP.SERVER_CONNECT;
            }
        }
        break;

        case STEP.SERVER_CONNECT:
        {
            this.next_step = STEP.CLIENT_CONNECT;
        }
        break;

        case STEP.CLIENT_CONNECT:
        {
            this.next_step = STEP.GAME_START;
        }
        break;

        case STEP.ERROR:
        {
            this.next_step = STEP.WAIT_RESTART;
        }
        break;
        }

        // ---------------------------------------------------------------- //
    }
    void Update()
    {
        // 오류 핸들링.
        NetEventHandling();

        // ---------------------------------------------------------------- //
        // 스텝 내 경과 시간 진행.

        this.step_timer += Time.deltaTime;

        // ---------------------------------------------------------------- //
        // 전환 시 초기화.

        while(this.next_step != STEP.NONE) {

            this.step      = this.next_step;
            this.next_step = STEP.NONE;

            switch(this.step) {

            case STEP.MATCHING:
            {
                int serverNode = -1;
                if (m_network != null) {
                    serverNode = m_network.Connect(m_serverAddress, NetConfig.MATCHING_SERVER_PORT, Network.ConnectionType.Reliable);
                    if (serverNode >= 0) {

                        GameObject obj = new GameObject("MatchingClient");
                        m_client = obj.AddComponent<MatchingClient>();
                        if (m_client == null) {
                            // 오류 강제 전환.
                            m_errorMessage = "매칭을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                            this.step = STEP.ERROR;
                        }
                        m_client.SetServerNode(serverNode);

                    }
                    else {
                        // 오류.
                        m_errorMessage = "매칭 서버에\n접속할 수 없습니다.\n\n버튼을 누르세요.";
                        this.step = STEP.ERROR;
                    }
                }
                else {
                    // 오류.
                    m_errorMessage = "통신을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                    this.step = STEP.ERROR;
                }
            }
            break;

            case STEP.SERVER_START:
                {
                    m_network.ClearReceiveNotification();

                    Debug.Log("Launch Listening socket.");
                    // 같은 단말에서 실행할 수 있게 포트 번호를 다르게 한다.
                    // 다른 단말에서 실행할 때는 포트 번호가 같은 것을 사용한다.
                    int port = NetConfig.GAME_PORT + GlobalParam.get().global_account_id;
                    bool ret = m_network.StartServer(port, NetConfig.PLAYER_MAX, Network.ConnectionType.Unreliable);
                    if (m_isHost) {
                        // 게임 서버 시작.
                        int playerNum = m_client.GetMemberNum();
                        ret &= m_network.StartGameServer(playerNum);
                    }
                    if (ret == false) {
                        // 오류로 강제 전환.
                        m_errorMessage = "게임 통신을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                        this.step = STEP.ERROR;
                    }
                }
                break;

            case STEP.SERVER_CONNECT:
                {
                    // 호스트 이름 획득.
                    if (m_isHost) {
                        string hostname = Dns.GetHostName();
                        IPAddress[] adrList = Dns.GetHostAddresses(hostname);
                        m_serverAddress = adrList[0].ToString();
                    }
                    // 게임 서버에 접속.
                    Debug.Log("Connect to GameServer.");
                    int serverNode = m_network.Connect(m_serverAddress, NetConfig.GAME_SERVER_PORT, Network.ConnectionType.Reliable);
                    if (serverNode >= 0) {
                        m_network.SetServerNode(serverNode);
                    }
                    else {
                        // 오류로 강제 전환.
                        m_errorMessage = "게임 서버와 통신할 수 없습니다.\n\n버튼을 누르세요.";
                        this.step = STEP.ERROR;
                    }
                }
                break;

            case STEP.CLIENT_CONNECT:
                {
                    Debug.Log("Connect to host.");
                    MatchingClient.MemberList[] list = m_client.GetMemberList();
                    int playerNum = m_client.GetMemberNum();
                    for (int i = 0; i < playerNum; ++i) {
                        // 같은 단말에서 실행할 때는 전용으로 부여한 플레이어ID로 판별한다.
                        // 다른 단말에서 실행할 때는 IP주소로 판별할 수 있다.
                        if (m_client.GetPlayerId() == i) {
                            // 자기 자신은 접속하지 않는다.
                            continue;
                        }
                        if (list[i] == null) {
                            continue;
                        }
                        // 같은 단말에서 실행할 수 있게 포트 번호를 다르게 한다.
                        // 다른 단말에서 실행할 때는 포트 번호가 같은 것을 사용한다.
                        int port = NetConfig.GAME_PORT + i;
                        string memberAddress = list[i].endPoint.Address.ToString();
                        int clientNode = m_network.Connect(memberAddress, port, Network.ConnectionType.Unreliable);

                        if (clientNode >= 0) {
                            m_network.SetClientNode(i, clientNode);
                        }
                        else {
                            // 오류로 강제 전환.
                            m_errorMessage = "게임을 시작할 수 없습니다.\n\n버튼을 누르세요.";
                            this.step = STEP.ERROR;
                        }
                    }
                }
                break;

            case STEP.GAME_START:
                {
                        GlobalParam.get().fadein_start = true;
                        GlobalParam.get().playerNum = m_client.GetMemberNum();
                        Application.LoadLevel("scGame");
                }
                break;

            case STEP.WAIT_RESTART:
                {
                    if (m_isHost) {
                        m_network.StopGameServer();
                    }
                    m_network.StopServer();
                    m_network.Disconnect();
                }
                break;
            }
            this.step_timer = 0.0f;
        }

        // ---------------------------------------------------------------- //
        // 각 상태에서의 실행 처리.

        switch(this.step) {

            case STEP.MATCHING:
            {
                this.next_step = STEP.WAIT_MATCHING;
            }
            break;

            case STEP.WAIT_MATCHING:
            {
                if (m_client != null && m_client.IsFinishedMatching()) {

                    GlobalParam.get().global_account_id = m_client.GetPlayerId();

                    m_isHost = m_client.IsRoomOwner();

                    if (m_isHost) {
                        GlobalParam.get().is_host = true;
                    }

                    this.next_step = STEP.SERVER_START;
                }
            }
            break;

            case STEP.SERVER_START:
            {
            // 서버가 시작하길 기다린다.
                if (this.step_timer > 3.0f){
                    this.next_step = STEP.SERVER_CONNECT;
                }
            }
            break;

            case STEP.SERVER_CONNECT:
            {
                this.next_step = STEP.CLIENT_CONNECT;
            }
            break;

            case STEP.CLIENT_CONNECT:
            {
                this.next_step = STEP.GAME_START;
            }
            break;

            case STEP.ERROR:
                {
                    this.next_step = STEP.WAIT_RESTART;
                }
                break;
        }

        // ---------------------------------------------------------------- //
    }
Beispiel #4
0
	void	Update()
	{
		// 오류 핸들링.
		NetEventHandling();

		// ---------------------------------------------------------------- //
		// 스텝 내 경과 시간 진행.

		this.step_timer += Time.deltaTime;

		// ---------------------------------------------------------------- //
		// 다음 상태로 전환할지 체크한다.


		if(this.next_step == STEP.NONE) {

			switch(this.step) {
	
				case STEP.WAIT:
				{

				}
				break;
			}
		}

		// ---------------------------------------------------------------- //
		// 전환 시 초기화.

		while(this.next_step != STEP.NONE) {

			this.step      = this.next_step;
			this.next_step = STEP.NONE;

			switch(this.step) {
	
			case STEP.MATCHING:
				{
#if !UNUSE_MATCHING_SERVER
					int serverNode = -1;
					if (m_network != null) {
						serverNode = m_network.Connect(m_serverAddress, NetConfig.MATCHING_SERVER_PORT, Network.ConnectionType.Reliable);
						if (serverNode >= 0) {

							GameObject obj = new GameObject("MatchingClient");
							m_client = obj.AddComponent<MatchingClient>();
							if (m_client == null) {
								// 오류 강제 전환.
								m_errorMessage = "매칭을 시작할 수 없습니다.\n\n버튼을 누르세요.";
								this.step = STEP.ERROR;
							}
							m_client.SetServerNode(serverNode);

						}
						else {
							// 오류.
							m_errorMessage = "매칭 서버에\n접속할 수 없습니다.\n\n버튼을 누르세요.";
							this.step = STEP.ERROR;
						}
					}
					else {
						// 오류.
						m_errorMessage = "통신을 시작할 수 없습니다.\n\n버튼을 누르세요.";
						this.step = STEP.ERROR;
					}
#else
					GameObject obj = new GameObject("MatchingClient");
					m_client = obj.AddComponent<MatchingClient>();
					if (m_client == null) {
						// 오류로 강제 전환.
						m_errorMessage = "매칭을 시작할 수 없습니다.\n\n버튼을 누르세요.";
						this.step = STEP.ERROR;
					}
#endif
				}
				break;

			case STEP.SERVER_START:
				{
					m_network.ClearReceiveNotification();

					Debug.Log("Launch Listening socket.");
					// 같은 단말에서 실행할 수 있게 포토 번호를 다르게 한다.
					// 다른 단말에서 실행할 때는 포트 번호가 같은 것을 사용한다.
					int port = NetConfig.GAME_PORT + GlobalParam.getInstance().global_account_id;
					bool ret = m_network.StartServer(port, NetConfig.PLAYER_MAX, Network.ConnectionType.Unreliable);
					if (m_isHost) {
						// 게임 서버 시작.
						int playerNum = m_client.GetMemberNum();
						ret &= m_network.StartGameServer(playerNum);
					}
					if (ret == false) {
						// 오류로 강제 전환.
						m_errorMessage = "게임 통신을 시작할 수 없습니다.\n\n버튼을 누르세요.";
						this.step = STEP.ERROR;
					}
				}
				break;

			case STEP.SERVER_CONNECT:
				{
					// 호스트 이름 획득.
					if (m_isHost) {
						string hostname = Dns.GetHostName();
						IPAddress[] adrList = Dns.GetHostAddresses(hostname);
						m_serverAddress = adrList[0].ToString();
					}
					// 게임 서버에 접속.
					Debug.Log("Connect to GameServer.");
					int serverNode = m_network.Connect(m_serverAddress, NetConfig.GAME_SERVER_PORT, Network.ConnectionType.Reliable);
					if (serverNode >= 0) {
						m_network.SetServerNode(serverNode);
					}
					else {
						// 오류로 강제 전환.
						m_errorMessage = "게임 서버와 통신할 수 없습니다.\n\n버튼을 누르세요.";
						this.step = STEP.ERROR;
					}
				}
				break;
				
			case STEP.CLIENT_CONNECT:
				{
					Debug.Log("Connect to host.");
					MatchingClient.MemberList[] list = m_client.GetMemberList();
					int playerNum = m_client.GetMemberNum();
					for (int i = 0; i < playerNum; ++i) {
						// 같은 단말에서 실행할 때는 전용으로 부여한 플레이어ID로 판별한다.
						// 다른 단말에서 실행할 때는 IP주소로 판별할 수 있다.
						// 샘플 코드에서는 양쪽에 대응할 수 있는 플레어ID로 판별한다.
						if (m_client.GetPlayerId() == i) {
							// 자기 자신은 접속하지 않는다.
							continue;
						}
						if (list[i] == null) {
							continue;
						}
						// 같은 단말에서 실행할 수 있게 포트 번호를 다르게 한다.
						// 다른 단말에서 실행할 때는 포트 번호가 같은 것을 사용한다.
						int port = NetConfig.GAME_PORT + i;
						string memberAddress = list[i].endPoint.Address.ToString();
						int clientNode = m_network.Connect(memberAddress, port, Network.ConnectionType.Unreliable);

						if (clientNode >= 0) {
							m_network.SetClientNode(i, clientNode);
						}
						else {
							// 오류로 강제 전환.
							m_errorMessage = "게임을 시작할 수 없습니다.\n\n버튼을 누르세요.";
							this.step = STEP.ERROR;
						}
					}
				}
				break;

#if UNUSE_MATCHING_SERVER
			case STEP.WAIT_SYNC:
				{
					CharEquipment equip = new CharEquipment();
					
					equip.globalId = GlobalParam.get().global_account_id;
					equip.shotType = (int)SHOT_TYPE.NEGI;

					EquipmentPacket packet = new EquipmentPacket(equip);
					int serverNode = m_network.GetServerNode();
					m_network.SendReliable<CharEquipment>(serverNode, packet);
				}
				break;
#endif

			case STEP.GAME_START:
				{
					GlobalParam.getInstance().fadein_start = true;
					Application.LoadLevel("WeaponSelectScene");
				}
				break;

				
			case STEP.WAIT_RESTART:
				{
					if (m_isHost) {
						m_network.StopGameServer();
					}
					m_network.StopServer();
					m_network.Disconnect();
				}
				break;
			}
			this.step_timer = 0.0f;
		}

		// ---------------------------------------------------------------- //
		// 각 상태에서의 실행 처리.

		switch(this.step) {

			case STEP.WAIT:
			{
			}
			break;
				
			case STEP.MATCHING:
			{
				this.next_step = STEP.WAIT_MATCHING;
			}
			break;

			case STEP.WAIT_MATCHING:
			{
#if !UNUSE_MATCHING_SERVER
				if (m_client != null && m_client.IsFinishedMatching()) {
				
					GlobalParam.get().global_account_id = m_client.GetPlayerId();

					m_isHost = m_client.IsRoomOwner();
#else
				{
#endif
					if (m_isHost) {
						GlobalParam.get().is_host = true;
					}

					this.next_step = STEP.SERVER_START;
				}
			}
			break;

			case STEP.SERVER_START:
			{
			// 서버가 시작하길 기다린다.
#if UNUSE_MATCHING_SERVER
				if (this.step_timer > 5.0f){
#else
				if (this.step_timer > 3.0f){
#endif
					this.next_step = STEP.SERVER_CONNECT;
				}
			}
			break;
				
			case STEP.SERVER_CONNECT:
			{
				this.next_step = STEP.CLIENT_CONNECT;
			}
			break;
				
			case STEP.CLIENT_CONNECT:
			{
#if UNUSE_MATCHING_SERVER
				this.next_step = STEP.WAIT_SYNC;
#else
				this.next_step = STEP.GAME_START;
#endif
			}
			break;
	
#if UNUSE_MATCHING_SERVER
			case STEP.WAIT_SYNC:
			{
				// 클라이언트끼리 접속하길 기다린다.
				// 예제 코드에서는 대기 시간을 넣어서 접속을 기다렸다.
				// 원래는 UDP로 접속 처리를 작성해 커넥션을 펼 수 있게 하는 편이 좋다

				bool isConnected = true;
				string connect = "Connect:[sync:" + m_syncFlag;
				for (int i = 0; i < m_client.GetMemberNum(); ++i) {

					if (i == GlobalParam.get().global_account_id) {
						continue;
					}

					int node = m_network.GetClientNode(i);
					isConnected &= m_network.IsConnected(node);

					connect += "[" + i +"(" + node + "):" + m_network.IsConnected(node) + "] ";
				}
				//Debug.Log(connect);

				if (isConnected || this.step_timer > 10.0f) {
					this.next_step = STEP.GAME_START;
				}

				++count_;
			}
			break;
#endif

			case STEP.GAME_START:
			{
			}
			break;

			case STEP.ERROR:
			{
				this.next_step = STEP.WAIT_RESTART;
			}
			break;
				
			case STEP.WAIT_RESTART:
			{
			}
			break;
		}

		// ---------------------------------------------------------------- //
	}