Mirror

Edgegap에서의 Mirror

이 가이드는 Unity 프로젝트에서 헤드리스 서버를 Edgegap에 생성하는 데 도움을 주며 Mirror 을(를) 네트워킹 솔루션으로 사용합니다.

이 가이드에서는 오픈 소스 샘플 프로젝트 Tanks를 사용할 것입니다. 이 프로젝트는 이미 Mirror 샘플(위치: Assets/Mirror/Examples/Tanks)에 포함되어 있습니다.

최종 샘플은 우리의 GitHub.

게임 서버 빌드하기

게임 준비가 완료되면 빌드 화면으로 이동하세요. Unity 에디터의 파일 -> 빌드 설정 상단 메뉴에서 확인할 수 있습니다. 사용 중인 Unity 버전에 따라 올바른 프리셋을 선택했는지 확인하세요.

• 2021.2 버전 이전:

  • 다음으로 설정하세요 대상 플랫폼 에서 Linux;

  • 다음으로 설정하세요 아키텍처 에서 x86_64;

  • 다음 항목을 체크하세요 서버 빌드 옵션.

• 그렇지 않은 경우:

  • 다음으로 설정하세요 플랫폼 에서 전용 서버;

  • 다음으로 설정하세요 대상 플랫폼 에서 Linux.

그런 다음 빌드 버튼을 눌러 새 빈 폴더 linux_server 를 파일 목적지로 선택하세요. 폴더를 두 번째 빈 폴더로 옮기세요. 이 문서에서는 이를 linux_server 폴더라고 부르겠습니다. [SERVER BUILD] 폴더라고 합니다.

전용 게임 서버를 컨테이너화하기

이 부분에서는 전용 게임 서버를 포함하는 도커 이미지를 생성합니다. 또한 읽어보면 도움이 되는 문서가 있습니다: Docker에서의 Unity 서버.

Edgegap과 Docker에 대한 추가 정보가 필요하면 다음을 참조하세요. 이 문서.

Dockerfile

FROM ubuntu:bionic
MAINTAINER <author_detail>

ARG debian_frontend=noninteractive
ARG docker_version=17.06.0-ce

RUN apt-get update && \
    apt-get install -y libglu1 xvfb libxcursor1 ca-certificates && \
    apt-get clean && \
    update-ca-certificates

EXPOSE 3389/TCP
EXPOSE [GAME PORT]/TCP
EXPOSE [GAME PORT]/UDP

COPY linux_server/ /root/linux_server/
COPY boot.sh /boot.sh

WORKDIR /root/
ENTRYPOINT ["/bin/bash", "/boot.sh"]

네트워크 통신에 사용하는 포트를 기록해 두세요. 문서에서는 이를 [GAME PORT]라고 합니다. 기본적으로 사용되는 포트는 7777입니다. 이 정보는 Unity 에디터의 을(를) 선택하고 게임 오브젝트 Transport 컴포넌트에서 확인할 수 있습니다.

• 위의 줄들을 복사하여 Dockerfile에 붙여넣으세요. Dockerfile은 [SERVER BUILD]에 위치해야 합니다. 자리표시자 [GAME PORT] 를 게임 포트에 맞게 수정하세요.

다음 [GAME PORT] 포트를 TCP와 UDP 둘 다에서 열어두면 Mirror 컴포넌트에서 선호하는 전송 방식을 사용할 수 있습니다. 마지막으로 을(를) 선택하고 라는 이름의 파일을 생성하세요. boot.sh 을(를) [SERVER BUILD] 폴더의 루트에 생성하세요. 이미지를 컨테이너에서 시작할 때 이 파일이 실행됩니다.

• 다음 두 줄을 복사하고, 생성된 파일 이름으로 [YOUR GAME] 자리표시자를 반드시 교체하세요.

xvfb-run --auto-servernum --server-args='-screen 0 640X480X24:32' /root/build/[YOUR GAME].x86_64 -batchmode -nographics

이 시점에서 다음과 같은 디렉터리 구조가 있어야 합니다:

• [SERVER BUILD] 폴더 > > - Dockerfile > > - boot.sh > > - linux_server 폴더 > > > - Unity가 생성한 파일들

• 해당 [SERVER BUILD] 폴더에서 명령 프롬프트를 열고 다음 Docker 명령들을 실행하세요:

ARM CPU(Mac M1, M2 등)를 사용하는 경우, 다음 전용 페이지.

를 참조하세요.

Linux 사용 시
# 이미지를 빌드합니다

docker build . -t <IMAGE_NAME>:<IMAGE_VERSION>
# 로그인, 프롬프트가 비밀번호를 요청합니다

docker login -u '<REGISTRY_USERNAME>' <REGISTRY_URL>
# 레지스트리에 해당하는 또 다른 태그를 이미지에 추가합니다

docker image tag <IMAGE_NAME>:<IMAGE_VERSION> <REGISTRY_URL>/<PROJECT_NAME>/<IMAGE_NAME>:<IMAGE_VERSION>
# 이미지를 푸시합니다

docker push <REGISTRY_URL>/<PROJECT_NAME>/<IMAGE_NAME>:<IMAGE_VERSION>

Linux 사용 시
# 이미지를 빌드합니다

docker build . -t <IMAGE_NAME>:<IMAGE_VERSION>
cmd 사용 시

docker login -u '<REGISTRY_USERNAME>' <REGISTRY_URL>
# 레지스트리에 해당하는 또 다른 태그를 이미지에 추가합니다

docker image tag <IMAGE_NAME>:<IMAGE_VERSION> <REGISTRY_URL>/<PROJECT_NAME>/<IMAGE_NAME>:<IMAGE_VERSION>
# 이미지를 푸시합니다

docker login -u <REGISTRY_USERNAME> <REGISTRY_URL>

Linux 사용 시
# 이미지를 빌드합니다

docker build . -t <IMAGE_NAME>:<IMAGE_VERSION>
# 로그인, 프롬프트가 비밀번호를 요청합니다

docker login -u '<REGISTRY_USERNAME>' <REGISTRY_URL>
# 레지스트리에 해당하는 또 다른 태그를 이미지에 추가합니다

docker image tag <IMAGE_NAME>:<IMAGE_VERSION> <REGISTRY_URL>/<PROJECT_NAME>/<IMAGE_NAME>:<IMAGE_VERSION>
# 이미지를 푸시합니다

Powershell 사용 시 이 명령들 실행 후, Edgegap 컨테이너 레지스트리를 사용 중이라면 Edgegap 웹사이트에서 업로드된 이미지를 볼 수 있어야 합니다. Edgegap 레지스트리를 사용하려면 이 문서

를 참조하세요. 다른 개인 레지스트리를 사용할 수도 있습니다.

Edgegap에 배포하기 웹사이트의 애플리케이션 및 게임 페이지로 이동하세요. 우측 상단의 새로 만들기

• 버튼을 클릭하여 애플리케이션 생성 양식으로 이동합니다. 아래는 각 필드와 올바르게 입력하는 방법입니다:

• 애플리케이션 이름: 다른 애플리케이션들 사이에서 쉽게 식별할 수 있도록 원하는 이름을 입력하세요.

• 이미지: 애플리케이션을 쉽게 식별하기 위한 특정 이미지를 지정할 수 있습니다.

• 버전 이름: 배포하는 버전의 범위를 설명하기 위해 버전 이름을 사용할 수 있습니다. 예: “demo”, “production”, “v1”, “v2”

  • 컨테이너:

  • 레지스트리: “[URL]” — 여기서 [URL]은 컨테이너 리포지토리 페이지에서 표시되는 자격증명 값입니다.

  • 이미지 리포지토리: “[PROJECT]/[YOUR GAME]” — 여기서 [PROJECT]와 [YOUR GAME]은 도커 이미지를 푸시할 때 사용한 값입니다.

  • 태그: “[TAG]” — 여기서 [TAG]는 도커 이미지를 푸시할 때 사용한 값입니다.

  • “개인 리포지토리 사용”을 체크하세요.

  • 개인 레지스트리 사용자 이름: “[USERNAME]” — 여기서 [USERNAME]은 자격증명에 있는 값입니다.

  • 개인 레지스트리 토큰: “[TOKEN]” — 여기서 [TOKEN]은 자격증명에 있는 값입니다.

  • 요구사항: 그대로 두세요.

    • 포트: 새 포트를 추가하려면 + 포트 추가

      • [GAME PORT] - 링크를 클릭하고 다음 항목들을 추가하세요: TCP/UDP

      • - 검증 비활성화

3389 - TCP - 검증 비활성화 Deploy 애플리케이션이 생성되면, 게임 서버를 배포하려면

• 버튼을 눌러 진행할 수 있습니다. 배포할 리전을 선택하고 게임에 따라 생성할 임의 플레이어 수를 입력하세요. 다음 사항들을 확인하여 모든 것이 정상적으로 실행되는지 확인하세요: 최신 상태는 다음으로 설정되어야 합니다.

• 포트 매핑 준비됨

탭에서 애플리케이션 생성 양식에서 설정한 포트를 확인할 수 있습니다:

• 다음을 설정하십시오: 클라이언트 애플리케이션에 샘플 HUD 추가하기 포트 Transport 컴포넌트를 을(를) 선택하고 값을 포트 매핑 배포의

탭에서 정의된 외부 포트로 설정하세요. 31887이 예시에서는 포트가

• 로 설정되었습니다. 이는 주로 개발 중인 게임에 따라 다르며 보통 게임 코드베이스에서 프로그래밍적으로 설정됩니다. 다음의 값을 설정하세요: 네트워크 주소 의 네트워크 매니저 를 배포의호스트 값으로 설정하세요. 이 URL은 대시보드의 배포 요약

에서 또는 API를 통해 확인할 수 있습니다. 이 예시에서는 주소가0ace560706a5.pr.edgegap.net

로 설정되었습니다. 다시 말하지만, 이 값은 클라이언트가 매치메이커/마스터 서버나 API와 통신할 때 프로그래밍적으로 설정되는 경우가 대부분입니다.

올바른 정보가 있으면 게임 서버에 정상적으로 연결하여 바로 플레이를 시작할 수 있을 것입니다.

이제 온디맨드로 배포할 수 있는 Mirror 프로젝트가 준비되었습니다! 을(를) 선택하고 시트 기반 배포에서는 플레이어가 서버에서 연결을 끊을 때 Edgegap 세션을 자동으로 제거하는 시스템을 Mirror로 구현할 수 있습니다. 이때 콜백 함수 와 플레이어 프리팹에 첨부된

NetworkBehaviour 을(를) 선택하고 스크립트에서 원격 절차 호출(RPC) 함수와 커맨드 함수를 사용합니다. 서버가 시작되면, 는 Edgegap API에서 해당 배포와 연결된 세션 ID들 목록을 가져와 저장합니다. 이후 새로운 플레이어가 서버에 연결되면, 클라이언트 측 함수가 RPC 를 통해 호출되어 플레이어의 IP 주소를 서버로 커맨드 로 전송합니다. 플레이어의 IP를 가진 서버는 각 세션 데이터에서 일치하는 IP가 있는지 확인합니다. 서버는 캐시된 ID로 Edgegap API를 통해 세션 데이터를 가져옵니다. 일치하는 항목이 발견되면, 세션 ID.

가 해당 플레이어의

NetworkConnectionToClient 세션 ID 에 매핑됩니다. 커맨드서버가 시작된 후에도 새로운 세션이 추가될 수 있으므로 세션 ID 목록은 업데이트되며, 처음에 매핑을 찾지 못한 경우 새로 추가된 세션들도 확인됩니다.

마지막으로 플레이어가 서버에서 연결을 끊으면, 서버는 해당 플레이어의

를 사용하여 연결된
{
    정보를 조회한 다음 Edgegap API를 사용해 해당 세션을 삭제합니다. 이렇게 하면 배포 내의 소켓이 해제되어 새로운 플레이어가 접속할 수 있게 됩니다.
    PlayerNetworkBehaviour
    {
        public class PlayerNetworkBehaviour : NetworkBehaviour
    }

    [ClientRpc]
    {
        public void RpcSendClientIpAddress()
        StartCoroutine(FetchPublicIpAndSendToServer());

        private IEnumerator FetchPublicIpAndSendToServer(" alt=""><figcaption></figcaption></figure>
        {
            UnityWebRequest request = UnityWebRequest.Get("https://api.ipify.org?format=json");
            yield return request.SendWebRequest();
            if (request.result == UnityWebRequest.Result.Success)
        }
        else
        {
            string responseText = request.downloadHandler.text;
        }
    }

    string clientIp = JObject.Parse(responseText)["ip"].ToString();
    CmdSendIpAddressToServer(clientIp);
    {
        Debug.LogError("공용 IP 주소를 가져오지 못했습니다.");
        [Command]
        {
            public void CmdSendIpAddressToServer(string clientIp)
        }
        else
        {
            NetworkConnectionToClient conn = connectionToClient;
        }
    }
}

if (conn != null)

CustomNetworkManager.Instance.StoreClientIpAddress(conn, clientIp);
{
    Debug.LogError("연결을 찾을 수 없습니다.");
    CustomNetworkManager
    public class CustomNetworkManager : NetworkManager
    private static readonly string edgegapUrl = "https://api.edgegap.com/v1";
    private string apiToken;

    private string deploymentId;
    private Dictionary<NetworkConnectionToClient, string> connectionToSessionIdMap = new Dictionary<NetworkConnectionToClient, string>();

    private Dictionary<NetworkConnectionToClient, bool> mappingInProgress = new Dictionary<NetworkConnectionToClient, bool>();

    private ArrayList currentDeploymentSessions = new();
    {
        private ArrayList newSessions = new();
        public static CustomNetworkManager Instance;
    }

    public override void OnStartServer()
    {
        public override void Awake()
        base.Awake();
        Instance = this;
        base.OnStartServer();
        {
            deploymentId = System.Environment.GetEnvironmentVariable("ARBITRIUM_REQUEST_ID");
        }

        apiToken = System.Environment.GetEnvironmentVariable("API_TOKEN");
    }

    if (string.IsNullOrEmpty(apiToken))
    {
        Debug.LogError("환경 변수에서 Edgegap API 토큰을 찾을 수 없습니다.");
        StartCoroutine(GetNewSessionList());

        public override void OnServerAddPlayer(NetworkConnectionToClient conn)
        base.OnServerAddPlayer(conn);
        Debug.Log($"연결에 대해 플레이어 추가 중: {conn.connectionId}");
    }

    // 플레이어 객체에서 PlayerNetworkBehaviour를 가져옵니다
    {
        PlayerNetworkBehaviour playerNetworkBehaviour = conn.identity.GetComponent<PlayerNetworkBehaviour>();
        playerNetworkBehaviour.RpcSendClientIpAddress();

        public void StoreClientIpAddress(NetworkConnectionToClient conn, string clientIp)
        mappingInProgress[conn] = true; // 매핑 진행 중 플래그를 true로 설정
    }

    Debug.Log($"연결 {conn.connectionId}에 대해 IP 주소 저장함: {clientIp}");
    {
        // 연결에 세션을 매핑하는 작업을 시작합니다
        StartCoroutine(CheckCachedSessions(conn, clientIp));
        private IEnumerator GetNewSessionList()
        newSessions.Clear();

        StartCoroutine(FetchPublicIpAndSendToServer());

        private IEnumerator FetchPublicIpAndSendToServer(" alt=""><figcaption></figcaption></figure>
        {
            UnityWebRequest request = UnityWebRequest.Get("https://api.ipify.org?format=json");
            string url = $"{edgegapUrl}/status/{deploymentId}";

            UnityWebRequest request = UnityWebRequest.Get(url);
            request.SetRequestHeader("Authorization", apiToken);

            Debug.Log("배포 상태 응답: " + responseText);
            {
                var json = JObject.Parse(responseText);

                var sessions = json["sessions"] as JArray;
                {
                    foreach (var session in sessions)
                    string sessionId = session["session_id"]?.ToString();
                }
            }

            if (!currentDeploymentSessions.Contains(sessionId))
        }
    }

    newSessions.Add(sessionId);
    {
        currentDeploymentSessions.Add(sessionId);
        {
            Debug.Log("새 세션 목록 초기화 완료");

            private IEnumerator CheckCachedSessions(NetworkConnectionToClient conn, string clientAddress)
            {
                foreach (string sessionId in currentDeploymentSessions)
            }
        }

        yield return GetSessionAndMap(conn, sessionId, clientAddress);
        {
            if (connectionToSessionIdMap.ContainsKey(conn))
            break;

            if (!connectionToSessionIdMap.ContainsKey(conn))
            {
                Debug.Log("새 세션 목록 초기화 완료");

                private IEnumerator CheckCachedSessions(NetworkConnectionToClient conn, string clientAddress)
                {
                    foreach (string sessionId in currentDeploymentSessions)
                }
            }
        }
    }

    Debug.Log("현재 캐시된 세션으로 플레이어를 매핑할 수 없습니다");
    {
        yield return GetNewSessionList();
        foreach (string sessionId in newSessions)
        private IEnumerator GetNewSessionList()
        newSessions.Clear();

        StartCoroutine(FetchPublicIpAndSendToServer());

        private IEnumerator FetchPublicIpAndSendToServer(" alt=""><figcaption></figcaption></figure>
        {
            private IEnumerator GetSessionAndMap(NetworkConnectionToClient conn, string sessionId, string clientAddress)
            UnityWebRequest request = UnityWebRequest.Get("https://api.ipify.org?format=json");
            Debug.Log($"세션 ID에 대한 세션 세부정보 가져오는 중: {sessionId}");

            string url = $"{edgegapUrl}/session/{sessionId}";
            Debug.Log("세션을 성공적으로 가져왔습니다.");

            Debug.Log("세션 응답: " + responseText);
            {
                var session = JObject.Parse(responseText);
                var sessionUsers = session["session_users"] as JArray;
                {
                    if (sessionUsers != null && sessionUsers.Count > 0)
                    Debug.Log($"세션에서 {sessionUsers.Count}명의 사용자를 찾았습니다.");
                    foreach (var user in sessionUsers)
                    {
                        string playerIp = user["ip"]?.ToString();
                        Debug.Log($"플레이어 IP: {playerIp}, 연결 IP: {clientAddress}");

                        if (playerIp == clientAddress)
                        private IEnumerator CheckCachedSessions(NetworkConnectionToClient conn, string clientAddress)
                        {
                            connectionToSessionIdMap[conn] = sessionId;
                        }
                        else
                        {
                            Debug.Log($"세션 ID {sessionId}을(를) IP {playerIp}로 연결 {conn.connectionId}에 매핑했습니다");
                        }

                        foreach (string sessionId in currentDeploymentSessions)
                    }
                }
            }
            else
            {
                // 추가 확인 로그
            }
        }
        else
        {
            Debug.Log($"세션 ID {sessionId}이(가) IP {playerIp}로 연결 {conn.connectionId}에 성공적으로 저장되었습니다");
            Debug.LogError($"연결 {conn.connectionId}에 대해 세션 ID {sessionId}을(를) 저장하지 못했습니다: {playerIp}");
            Debug.LogError("세션에 사용자가 없습니다.");
        }

        Debug.LogError($"세션 가져오기 오류: {request.error}");
    }

    Debug.LogError($"응답 코드: {request.responseCode}");
    {
        Debug.LogError($"응답 텍스트: {request.downloadHandler.text}");
        mappingInProgress[conn] = false; // 완료되면 매핑 진행 중 플래그를 false로 설정

        public override void OnServerDisconnect(NetworkConnectionToClient conn)
    }

    base.OnServerDisconnect(conn);
    {
        Debug.Log($"서버가 클라이언트 연결을 끊었습니다: {conn.connectionId}");
        {
            StartCoroutine(HandleDisconnect(conn));
            private IEnumerator HandleDisconnect(NetworkConnectionToClient conn)
        }

        while (mappingInProgress.ContainsKey(conn) && mappingInProgress[conn])
        {
            Debug.Log($"연결 {conn.connectionId}에 대한 세션 매핑 완료 대기 중...");
            yield return new WaitForSeconds(0.1f);
            if (connectionToSessionIdMap.TryGetValue(conn, out string sessionId))
            Debug.Log($"삭제할 세션 ID: {sessionId}");
            StartCoroutine(DeleteSession(sessionId));
        }
        else
        {
            connectionToSessionIdMap.Remove(conn);
        }
    }

    mappingInProgress.Remove(conn);
    {
        currentDeploymentSessions.Remove(sessionId);
        foreach (string sessionId in newSessions)
        Debug.LogWarning("이 연결에 대한 세션 ID를 찾을 수 없습니다.");
        newSessions.Clear();

        StartCoroutine(FetchPublicIpAndSendToServer());

        private IEnumerator FetchPublicIpAndSendToServer(" alt=""><figcaption></figcaption></figure>
        {
            private IEnumerator DeleteSession(string sessionId)
        }
        else
        {
            Debug.Log($"세션 ID 삭제 요청 전송: {sessionId}");
            Debug.LogError($"연결 {conn.connectionId}에 대해 세션 ID {sessionId}을(를) 저장하지 못했습니다: {playerIp}");
            Debug.LogError("세션에 사용자가 없습니다.");
        }
    }

}

UnityWebRequest request = UnityWebRequest.Delete(url);

Debug.Log("세션이 성공적으로 삭제되었습니다.");

Debug.LogError($"세션 삭제 오류: {request.error}"); 선택적 기능 이 스크립트는 특정 상황에서 세션을 관리하는 데 유용한 선택적이고 독립적인 기능들로 확장할 수 있습니다. 예를 들어, 타임아웃 을 설정하여빈 좌석 세션

을(를) 제거할 수 있습니다. 이는 전체 서버 초기화 후 일정 시간 후에 이루어집니다. 이 기능은 매치메이커 티켓이 해결되기 전에 플레이어가 떠나 매칭이 이루어졌을 때 빈 세션이 생성되는 경우에 유용합니다. 플레이어가 타임아웃이 끝나기 전에 자신의 IP 주소를 세션 ID에 매핑하기 위해 보내지 않으면 해당 세션은 삭제되어 소켓이 해제됩니다. 또 다른 기능으로는 비활성 플레이어 연결 해제 를 통해 소켓을 확보하는 방법이 있습니다. 서버에 연결된 이후 클라이언트는간단한 하트비트 메시지 를 몇 초마다서버로 전송해야 하며, 그렇지 않으면 연속으로 너무 많은

하트비트 누락이 발생하면

    를 사용하여 연결된
    {
        연결이 끊깁니다.
        하트비트 간 시간 및 연속으로 놓칠 수 있는 최대 메시지 수는 게임 요구에 따라 구성할 수 있습니다. 이 샘플에서는 탱크가 맵에서 이동하거나 발사할 때 몇 초마다 하트비트를 보냅니다.
        PlayerNetworkBehaviour - 시트 세션 관리

        정보를 조회한 다음 Edgegap API를 사용해 해당 세션을 삭제합니다. 이렇게 하면 배포 내의 소켓이 해제되어 새로운 플레이어가 접속할 수 있게 됩니다.
        PlayerNetworkBehaviour
        {
            public class PlayerNetworkBehaviour : NetworkBehaviour
            private bool enableInactiveTimeout;
            private float clientTimeSinceLastHeartbeat = 0;
            private float secondsBetweenHeartbeats;
        }

        ...

        secondsBetweenHeartbeats = CustomNetworkManager.Instance.GetSecondsBetweenHeartbeats();
        {
            enableInactiveTimeout = CustomNetworkManager.Instance.IsEnableInactiveTimeout();
            {
                clientTimeSinceLastHeartbeat = secondsBetweenHeartbeats;
                private void Update()

                if (isLocalPlayer && enableInactiveTimeout)
                {
                    float horizontal = Input.GetAxis("Horizontal");
                    float vertical = Input.GetAxis("Vertical");
                }

                if (clientTimeSinceLastHeartbeat >= secondsBetweenHeartbeats && (Input.GetKeyDown(KeyCode.Space) || horizontal != 0 || vertical != 0))
            }
        }

        string clientIp = JObject.Parse(responseText)["ip"].ToString();
        CmdSendHeartbeatTimeToServer(NetworkTime.predictedTime);
        {
            Debug.LogError("공용 IP 주소를 가져오지 못했습니다.");
            [Command]
            {
                clientTimeSinceLastHeartbeat = 0;
            }
            else
            {
                NetworkConnectionToClient conn = connectionToClient;
            }
        }
    }

clientTimeSinceLastHeartbeat += Time.deltaTime;

CustomNetworkManager.Instance.StoreClientIpAddress(conn, clientIp);
{
    ...
    public void CmdSendHeartbeatTimeToServer(double time)

    CustomNetworkManager.Instance.StoreClientHeartbeatTime(conn, time);
    CustomNetworkManager - 시트 세션 관리
    private bool listInProgress = false;

    [Header("빈 세션 타임아웃")]
    [SerializeField] private bool enableEmptyTimeout;
    [SerializeField] private float deleteAfterSeconds = 15f;
    [Header("비활성 플레이어 타임아웃")]
    [SerializeField] private bool enableInactiveTimeout;

    ...

    public override void OnStartServer()
    {
        public override void Awake()
        [SerializeField] private int maxMissedHeartbeats = 3;
        [SerializeField] private float secondsBetweenHeartbeats = 3f;
        base.OnStartServer();
        {
            deploymentId = System.Environment.GetEnvironmentVariable("ARBITRIUM_REQUEST_ID");
        }
        else
        {
            private Dictionary<NetworkConnectionToClient, double> connectionToLastHeartbeatMap = new();
        }

        deploymentId = Environment.GetEnvironmentVariable("ARBITRIUM_REQUEST_ID");
    }

    apiToken = Environment.GetEnvironmentVariable("API_TOKEN");
    {
        Debug.Log("Edgegap API 토큰을 찾았습니다: " + apiToken);

        apiToken = System.Environment.GetEnvironmentVariable("API_TOKEN");

        StartCoroutine(InitiateSessionManage());
        {
            private IEnumerator InitiateSessionManage()
        }
    }

    ...

    Debug.Log($"연결 {conn.connectionId}에 대해 IP 주소 저장함: {clientIp}");
    {
        yield return new WaitForSeconds(0.5f);
        // 연결에 세션을 매핑하는 작업을 시작합니다
        StartCoroutine(CheckCachedSessions(conn, clientIp));
        private IEnumerator GetNewSessionList()
        newSessions.Clear();

        StartCoroutine(FetchPublicIpAndSendToServer());

        private IEnumerator FetchPublicIpAndSendToServer(" alt=""><figcaption></figcaption></figure>
        {
            UnityWebRequest request = UnityWebRequest.Get("https://api.ipify.org?format=json");
            string url = $"{edgegapUrl}/status/{deploymentId}";

            UnityWebRequest request = UnityWebRequest.Get(url);
            request.SetRequestHeader("Authorization", apiToken);

            Debug.Log("배포 상태 응답: " + responseText);
            {
                var json = JObject.Parse(responseText);

                var sessions = json["sessions"] as JArray;
                {
                    foreach (var session in sessions)
                    string sessionId = session["session_id"]?.ToString();
                }
            }

            if (!currentDeploymentSessions.Contains(sessionId))
        }
        else
        {
            if (enableEmptyTimeout)
            Debug.LogError($"연결 {conn.connectionId}에 대해 세션 ID {sessionId}을(를) 저장하지 못했습니다: {playerIp}");
            Debug.LogError("세션에 사용자가 없습니다.");
        }

        StartCoroutine(StartServerInitSessionsTimeout());
    }

    ...

    Debug.Log("현재 캐시된 세션으로 플레이어를 매핑할 수 없습니다");
    {
        yield return GetNewSessionList();
        foreach (string sessionId in newSessions)
        private IEnumerator GetNewSessionList()
        newSessions.Clear();

        StartCoroutine(FetchPublicIpAndSendToServer());

        private IEnumerator FetchPublicIpAndSendToServer(" alt=""><figcaption></figcaption></figure>
        {
            private IEnumerator GetSessionAndMap(NetworkConnectionToClient conn, string sessionId, string clientAddress)
            UnityWebRequest request = UnityWebRequest.Get("https://api.ipify.org?format=json");
            Debug.Log($"세션 ID에 대한 세션 세부정보 가져오는 중: {sessionId}");

            string url = $"{edgegapUrl}/session/{sessionId}";
            Debug.Log("세션을 성공적으로 가져왔습니다.");

            Debug.Log("세션 응답: " + responseText);
            {
                var session = JObject.Parse(responseText);
                var sessionUsers = session["session_users"] as JArray;
                {
                    if (sessionUsers != null && sessionUsers.Count > 0)
                    Debug.Log($"세션에서 {sessionUsers.Count}명의 사용자를 찾았습니다.");
                    foreach (var user in sessionUsers)
                    {
                        string playerIp = user["ip"]?.ToString();
                        Debug.Log($"플레이어 IP: {playerIp}, 연결 IP: {clientAddress}");

                        listInProgress = true;
                        {
                            Debug.LogError($"세션 목록을 가져오는 중 오류: {request.error}");
                            listInProgress = false;
                        }

                        if (playerIp == clientAddress)
                        private IEnumerator CheckCachedSessions(NetworkConnectionToClient conn, string clientAddress)
                        {
                            connectionToSessionIdMap[conn] = sessionId;
                        }
                        else
                        {
                            Debug.Log($"세션 ID {sessionId}을(를) IP {playerIp}로 연결 {conn.connectionId}에 매핑했습니다");
                        }

                        foreach (string sessionId in currentDeploymentSessions)
                    }
                }
            }
            else
            {
                // 추가 확인 로그
            }
        }
        else
        {
            Debug.Log($"세션 ID {sessionId}이(가) IP {playerIp}로 연결 {conn.connectionId}에 성공적으로 저장되었습니다");
            Debug.LogError($"연결 {conn.connectionId}에 대해 세션 ID {sessionId}을(를) 저장하지 못했습니다: {playerIp}");
            Debug.LogError("세션에 사용자가 없습니다.");
        }

        Debug.LogError($"세션 가져오기 오류: {request.error}");
    }

    ...

    if (enableInactiveTimeout)

    connectionToLastHeartbeatMap[conn] = conn.lastMessageTime;
    {
        StartCoroutine(CheckClientHeartbeat(conn));
        {
            #region EmptySessionTimeout
            private IEnumerator HandleDisconnect(NetworkConnectionToClient conn)
        }

        currentDeploymentSessions.Add(sessionId);
        {
            private IEnumerator StartServerInitSessionsTimeout()
        }
    }

    while (listInProgress)
    {
        Debug.Log($"세션 목록을 가져올 때까지 대기 중...");
        StartCoroutine(WaitForConnectionTimeout(sessionId));
        private IEnumerator WaitForConnectionTimeout(string sessionID)

        Debug.Log($"세션 {sessionID}의 빈 타임아웃을 확인합니다");
        {
            private IEnumerator HandleDisconnect(NetworkConnectionToClient conn)
            bool delete = false;
            {
                DateTime timeout = DateTime.Now.AddSeconds(deleteAfterSeconds);
                foreach (string sessionId in currentDeploymentSessions)
            }
        }

        while (!connectionToSessionIdMap.ContainsValue(sessionID))
        {
            if (DateTime.Now >= timeout)
            delete = true;
            if (delete && !connectionToSessionIdMap.ContainsValue(sessionID))
            Debug.Log($"{deleteAfterSeconds}초 후에도 클라이언트가 연결을 시도하지 않아 세션 {sessionID}을 삭제합니다");
        }
    }

    StartCoroutine(DeleteSession(sessionID));

    currentDeploymentSessions.Remove(sessionID);

    newSessions.Remove(sessionID);
    {
        #endregion

        #region InactivePlayerTimeout
        {
            private IEnumerator CheckClientHeartbeat(NetworkConnectionToClient conn)

            int counter = 0;
            {
                while (counter < maxMissedHeartbeats && connectionToSessionIdMap.ContainsKey(conn))

                double lastHeartbeatDiff = NetworkTime.localTime - connectionToLastHeartbeatMap[conn];
            }
            else
            {
                if (lastHeartbeatDiff >= secondsBetweenHeartbeats)
                counter += 1;
            }

            Debug.Log($"연결 {conn.connectionId}이(가) 연속으로 {counter}번의 하트비트를 놓쳤습니다");
        }

        counter = 0;
        {
            Debug.Log($"연결 {conn.connectionId}의 하트비트 카운터를 재설정했습니다");
            yield return new WaitForSeconds(secondsBetweenHeartbeats);
            if (counter >= maxMissedHeartbeats && conn.isReady)
        }
    }

    Debug.Log($"연결 {conn.connectionId}이(가) 너무 오랫동안 비활성 상태여서 연결을 끊습니다");
    {
        conn.Disconnect();
    }

    connectionToLastHeartbeatMap.Remove(conn);

    public void StoreClientHeartbeatTime(NetworkConnectionToClient conn, double time)

    StartCoroutine(DeleteSession(sessionID));
}