Mirror

Mirror на Edgegap

Это руководство поможет вам создать безголовый сервер на Edgegap для Unity-проекта, использующего Mirror в качестве сетевого решения.

В этом руководстве будет использован открытый пример проекта Tanks, который уже доступен в вашем примере Mirror, по пути Assets/Mirror/Examples/Tanks.

Окончательный пример можно найти в нашем GitHub.

Собрать игровой сервер

Когда игра будет готова, перейдите на Экран сборки в Unity Editor, в меню Файл -> Параметры сборки в верхних меню. Убедитесь, что выбрали правильные пресеты в зависимости от вашей версии Unity.

• До версии 2021.2:

  • Установите Целевую платформу к Linux;

  • Установите Архитектуру к x86_64;

  • Отметьте Серверная сборка опции.

• В противном случае:

  • Установите Платформа к Выделенный сервер;

  • Установите Целевую платформу к Linux.

Затем нажмите собрать и выберите новую пустую папку с именем linux_server в качестве места назначения файлов. Перенесите linux_server папку во вторую пустую папку, которая в этом документе будет называться [SERVER BUILD] папкой.

Контейнеризация выделенного игрового сервера

В этой части мы создадим образ Docker, содержащий выделенный игровой сервер. Вам также может быть полезно прочитать Unity Server в Docker.

Если вам нужна дополнительная информация о Docker с Edgegap, обратитесь к этой документации.

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 Editor, на NetworkManager игровом объекте, в свойство компоненте.

• Скопируйте приведённые выше строки и вставьте их в ваш Dockerfile, помещённый внутри [SERVER BUILD]. Измените [GAME PORT] заполнители на ваш игровой порт.

Наличие [GAME PORT] открытого как для TCP, так и для UDP позволяет вам использовать любой транспорт, который вы предпочитаете, в NetworkManager компоненте 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>

Использование cmd

# собрать образ
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>

Использование Powershell

# собрать образ
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>

После выполнения этих команд вы должны увидеть загруженный образ на сайте Edgegap, если вы используете Edgegap Container Registry. См. эту документацию если вы хотите использовать реестр Edgegap. Вы также можете использовать другой приватный реестр.

Развёртывание на Edgegap

Перейдите на страницу Приложения и игры веб-сайта. Нажмите на кнопку Создать новое в правом верхнем углу, чтобы получить доступ к форме создания приложения. Ниже поля и как их правильно заполнить:

• Название приложения: Может быть любым заметным именем, которое вы хотите использовать, чтобы легко распознать приложение среди других.

• Изображение: Может быть любым конкретным изображением, которое вы хотите использовать, чтобы легко распознать приложение среди других.

• Имя версии: Вы можете указать имя версии, чтобы описать назначение версии, которую вы разворачиваете. Примеры: «demo», «production», «v1», «v2»

• Контейнер:

  • Реестр: «[URL]», где [URL] — значение из учётных данных, которые можно отобразить на странице репозитория контейнеров.

  • Репозиторий образа: «[PROJECT]/[YOUR GAME]», где [PROJECT] и [YOUR GAME] — значения, которые вы использовали ранее при отправке образа Docker.

  • Тег: «[TAG]», где [TAG] — значение, которое вы использовали ранее при отправке образа Docker.

  • Отметьте «Используется приватный репозиторий»

  • Имя пользователя приватного реестра: «[USERNAME]», где [USERNAME] — значение из ваших учётных данных.

  • Токен приватного реестра: «[TOKEN]», где [TOKEN] — значение из ваших учётных данных.

  • Требования: Оставьте как есть.

  • Порты:

    • Нажмите на ссылку + Добавить порт чтобы добавить новый порт, и добавьте следующие записи:

      • [GAME PORT] - TCP/UDP - отключить проверки

      • 3389 - TCP - отключить проверки

После создания приложения вы можете нажать кнопку Deploy чтобы продолжить развёртывание вашего игрового сервера. Выберите регион для развёртывания и укажите количество случайных игроков, которое вы хотите сгенерировать в зависимости от вашей игры. Проверьте, что всё работает корректно, проверив следующее:

• Последний статус должен быть установлен в Готов.

• В Сопоставление портов вкладке, вы должны видеть порт, который вы указали в форме создания приложения:

Добавьте пример HUD в ваше клиентское приложение

• Установите Порт значение свойство Relay GUI NetworkManager к внешнему порту, определённому в Сопоставление портов вкладке вашего развёртывания.

В этом примере порт был установлен в 31887. Это в первую очередь зависит от вашей игры и, скорее всего, будет задаваться программно в кодовой базе игры.

• Установите значение Сетевой адрес в Сетевом менеджере на адрес Хост. Этот URL можно найти в Сводке развёртывания на панели управления или через API.

В этом примере адрес был установлен в 0ace560706a5.pr.edgegap.net. Опять же, это значение, скорее всего, будет установлено программно во время того, как клиент будет общаться с мастер-сервером/API, отвечающим за процесс матчмейкинга.

С правильной информацией вы сможете нормально подключиться к игровому серверу и сразу начать играть.

Теперь у вас есть проект на Mirror, доступный для развёртывания по требованию!

С развёртываниями на основе мест возможно использовать Mirror для создания системы, которая автоматически удаляет зависшие сессии Edgegap, когда игрок отключается от сервера, используя NetworkManager функции обратного вызова, и скрипт NetworkBehaviour , прикреплённый к префабу игрока, который использует функцию удалённого вызова (RPC) и функцию команды (Command).

Когда сервер запускается, NetworkManager извлекает список ID сессий связанных с его развёртыванием через Edgegap API и сохраняет его. Затем, когда новый игрок подключается к серверу, на стороне клиента инициируется функция через RPC , которая отправит IP-адрес игрока назад на сервер с помощью команды. Зная IP игрока, сервер проверяет совпадающий IP в данных каждой сессии; сервер получает данные сессии, используя её сохранённый ID через Edgegap API. Если совпадение найдено, ID сессии отображается на NetworkConnectionToClient.

Поскольку новые сессии могут добавляться после запуска сервера, список ID сессий обновляется и новые сессии проверяются, если сопоставление не удалось найти с первого раза.

Наконец, когда игрок отключается от сервера, сервер использует IP этого игрока, NetworkConnectionToClient чтобы получить связанную с ним 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)
        {
            string responseText = request.downloadHandler.text;
            string clientIp = JObject.Parse(responseText)["ip"].ToString();
            CmdSendIpAddressToServer(clientIp);
        }
        else
        {
            Debug.LogError("Не удалось получить публичный IP-адрес.");
        }
    }

    [Command]
    public void CmdSendIpAddressToServer(string clientIp)
    {
        NetworkConnectionToClient conn = connectionToClient;
        if (conn != null)
        {
            CustomNetworkManager.Instance.StoreClientIpAddress(conn, clientIp);
        }
        else
        {
            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 Awake()
    {
        base.Awake();
        Instance = this;
    }

    public override void OnStartServer()
    {
        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; // Установить, что сопоставление в процессе
        Debug.Log($"Сохранён IP-адрес для соединения {conn.connectionId}: {clientIp}");

        // Начать сопоставление сессии с соединением
        StartCoroutine(CheckCachedSessions(conn, clientIp));
    }

    private IEnumerator GetNewSessionList()
    {
        newSessions.Clear();
        string url = $"{edgegapUrl}/status/{deploymentId}";
        UnityWebRequest request = UnityWebRequest.Get(url);
        request.SetRequestHeader("Authorization", apiToken);

        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            string responseText = request.downloadHandler.text;
            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("Не удалось сопоставить игрока с текущими кэшированными сессиями");
            yield return GetNewSessionList();

            foreach (string sessionId in newSessions)
            {
                yield return GetSessionAndMap(conn, sessionId, clientAddress);

                if (connectionToSessionIdMap.ContainsKey(conn))
                {
                    break;
                }
            }
        }
    }

    private IEnumerator GetSessionAndMap(NetworkConnectionToClient conn, string sessionId, string clientAddress)
    {
        Debug.Log($"Получение деталей сессии для ID сессии: {sessionId}");
        string url = $"{edgegapUrl}/session/{sessionId}";
        UnityWebRequest request = UnityWebRequest.Get(url);
        request.SetRequestHeader("Authorization", apiToken);

        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            Debug.Log("Сессия успешно получена.");
            string responseText = request.downloadHandler.text;
            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)
                    {
                        connectionToSessionIdMap[conn] = sessionId;
                        Debug.Log($"Сопоставлен ID сессии {sessionId} с соединением {conn.connectionId} и IP {playerIp}");

                        // Дополнительное логирование подтверждения
                        if (connectionToSessionIdMap.ContainsKey(conn))
                        {
                            Debug.Log($"ID сессии {sessionId} успешно сохранён для соединения {conn.connectionId} с IP {playerIp}");
                        }
                        else
                        {
                            Debug.LogError($"Не удалось сохранить ID сессии {sessionId} для соединения {conn.connectionId} с IP {playerIp}");
                        }

                        break;
                    }
                }
            }
            else
            {
                Debug.LogError("В сессии не найдено пользователей.");
            }
        }
        else
        {
            Debug.LogError($"Ошибка при получении сессии: {request.error}");
            Debug.LogError($"Код ответа: {request.responseCode}");
            Debug.LogError($"Текст ответа: {request.downloadHandler.text}");
        }

        mappingInProgress[conn] = 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));
            connectionToSessionIdMap.Remove(conn);
            mappingInProgress.Remove(conn);
            currentDeploymentSessions.Remove(sessionId);
        }
        else
        {
            Debug.LogWarning("Для этого соединения не найден ID сессии.");
        }
    }

    private IEnumerator DeleteSession(string sessionId)
    {
        Debug.Log($"Отправка запроса на удаление ID сессии: {sessionId}");
        string url = $"{edgegapUrl}/session/{sessionId}";
        UnityWebRequest request = UnityWebRequest.Delete(url);
        request.SetRequestHeader("Authorization", apiToken);

        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            Debug.Log("Сессия успешно удалена.");
        }
        else
        {
            Debug.LogError($"Ошибка при удалении сессии: {request.error}");
            Debug.LogError($"Код ответа: {request.responseCode}");
            Debug.LogError($"Текст ответа: {request.downloadHandler.text}");
        }
    }

}

Дополнительные функции

Этот скрипт можно расширить дополнительными, независимыми функциями, которые помогают управлять сессиями в отдельных случаях.

Например, можно задать тайм-аут для удаления сессий с пустыми местами после настраиваемого промежутка времени после полной инициализации сервера. Это полезная функция в случае, когда игрок выходит до того, как его билет матчмейкера будет обработан, что создаёт пустую сессию после нахождения матча. Если игрок никогда не отправит свой IP для сопоставления с ID сессии до истечения тайм-аута, то такая сессия удаляется, освобождая сокет.

Ещё одной функцией может быть отключение неактивных игроков после длительного периода времени, чтобы освободить сокеты. После подключения к серверу клиент должен отправлять минималистичное сообщение сердцебиения на сервер каждые несколько секунд, иначе он будет отключён, если подряд будет пропущено слишком много сообщений сердцебиения. Интервал между сердцебиениями и максимальное число подряд пропущенных сообщений можно настроить в зависимости от потребностей игры. В этом примере сигнал сердцебиения отправляется каждые несколько секунд, если танк перемещается по карте или стреляет.

PlayerNetworkBehaviour - управление сессиями мест

    public class PlayerNetworkBehaviour : NetworkBehaviour
    {
        private bool enableInactiveTimeout;
        private float clientTimeSinceLastHeartbeat = 0;
        private float secondsBetweenHeartbeats;

        [ClientRpc]
        public void RpcSendClientIpAddress()
        {
            StartCoroutine(FetchPublicIpAndSendToServer());
            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))
                {
                    CmdSendHeartbeatTimeToServer(NetworkTime.predictedTime);
                    clientTimeSinceLastHeartbeat = 0;
                }

                clientTimeSinceLastHeartbeat += Time.deltaTime;
            }
        }

        [Command]
        public void CmdSendHeartbeatTimeToServer(double time)
        {
            NetworkConnectionToClient conn = connectionToClient;
            if (conn != null)
            {
                CustomNetworkManager.Instance.StoreClientHeartbeatTime(conn, time);
            }
            else
            {
                Debug.LogError("Соединение не найдено.");
            }
        }
    }

CustomNetworkManager - управление сессиями мест

public class CustomNetworkManager : NetworkManager
{
    ...
    private bool listInProgress = false;

    [Header("Тайм-аут пустой сессии")]
    [SerializeField] private bool enableEmptyTimeout;
    [SerializeField] private float deleteAfterSeconds = 15f;

    [Header("Тайм-аут неактивного игрока")]
    [SerializeField] private bool enableInactiveTimeout;
    [SerializeField] private int maxMissedHeartbeats = 3;
    [SerializeField] private float secondsBetweenHeartbeats = 3f;
    private Dictionary<NetworkConnectionToClient, double> connectionToLastHeartbeatMap = new();

    ...

    public override void OnStartServer()
    {
        base.OnStartServer();
        deploymentId = Environment.GetEnvironmentVariable("ARBITRIUM_REQUEST_ID");
        apiToken = Environment.GetEnvironmentVariable("API_TOKEN");
        if (string.IsNullOrEmpty(apiToken))
        {
            Debug.LogError("Токен Edgegap API не найден в переменных окружения.");
        }
        else
        {
            Debug.Log("Токен Edgegap API найден: " + apiToken);
        }

        StartCoroutine(InitiateSessionManage());
    }

    private IEnumerator InitiateSessionManage()
    {
        yield return new WaitForSeconds(0.5f);

        StartCoroutine(GetNewSessionList());

        if (enableEmptyTimeout)
        {
            StartCoroutine(StartServerInitSessionsTimeout());
        }
    }

    ...

    private IEnumerator GetNewSessionList()
    {
        listInProgress = true;
        newSessions.Clear();
        string url = $"{edgegapUrl}/status/{deploymentId}";
        UnityWebRequest request = UnityWebRequest.Get(url);
        request.SetRequestHeader("Authorization", apiToken);

        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            string responseText = request.downloadHandler.text;
            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("Инициализирован новый список сессий");
        }
        else
        {
            Debug.LogError($"Ошибка при получении списка сессий: {request.error}");
            Debug.LogError($"Код ответа: {request.responseCode}");
            Debug.LogError($"Текст ответа: {request.downloadHandler.text}");
        }

        listInProgress = false;
    }

    ...

    private IEnumerator GetSessionAndMap(NetworkConnectionToClient conn, string sessionId, string clientAddress)
    {
        Debug.Log($"Получение деталей сессии для ID сессии: {sessionId}");
        string url = $"{edgegapUrl}/session/{sessionId}";
        UnityWebRequest request = UnityWebRequest.Get(url);
        request.SetRequestHeader("Authorization", apiToken);

        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            Debug.Log("Сессия успешно получена.");
            string responseText = request.downloadHandler.text;
            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)
                    {
                        connectionToSessionIdMap[conn] = sessionId;
                        Debug.Log($"Сопоставлен ID сессии {sessionId} с соединением {conn.connectionId} и IP {playerIp}");

                        if (enableInactiveTimeout)
                        {
                            connectionToLastHeartbeatMap[conn] = conn.lastMessageTime;
                            StartCoroutine(CheckClientHeartbeat(conn));
                        }

                        // Дополнительное логирование подтверждения
                        if (connectionToSessionIdMap.ContainsKey(conn))
                        {
                            Debug.Log($"ID сессии {sessionId} успешно сохранён для соединения {conn.connectionId} с IP {playerIp}");
                        }
                        else
                        {
                            Debug.LogError($"Не удалось сохранить ID сессии {sessionId} для соединения {conn.connectionId} с IP {playerIp}");
                        }

                        break;
                    }
                }
            }
            else
            {
                Debug.LogError("В сессии не найдено пользователей.");
            }
        }
        else
        {
            Debug.LogError($"Ошибка при получении сессии: {request.error}");
            Debug.LogError($"Код ответа: {request.responseCode}");
            Debug.LogError($"Текст ответа: {request.downloadHandler.text}");
        }

        mappingInProgress[conn] = false; // Установить, что сопоставление завершено
    }

    ...

    #region EmptySessionTimeout

    private IEnumerator StartServerInitSessionsTimeout()
    {
        while (listInProgress)
        {
            Debug.Log($"Ожидание получения списка сессий...");
            yield return new WaitForSeconds(0.1f);
        }

        foreach (string sessionId in currentDeploymentSessions)
        {
            StartCoroutine(WaitForConnectionTimeout(sessionId));
        }
    }

    private IEnumerator WaitForConnectionTimeout(string sessionID)
    {
        Debug.Log($"Проверка тайм-аута пустой сессии для {sessionID}");
        bool delete = false;
        DateTime timeout = DateTime.Now.AddSeconds(deleteAfterSeconds);

        while (!connectionToSessionIdMap.ContainsValue(sessionID))
        {
            yield return new WaitForSeconds(0.1f);
            if (DateTime.Now >= timeout)
            {
                delete = true;
                break;
            }
        }

        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];

            if (lastHeartbeatDiff >= secondsBetweenHeartbeats)
            {
                counter += 1;

                Debug.Log($"Соединение {conn.connectionId} пропустило {counter} сердцебиение(й) подряд");
            }
            else
            {
                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)
    {
        connectionToLastHeartbeatMap[conn] = time;
    }

    public float GetSecondsBetweenHeartbeats() => secondsBetweenHeartbeats;

    public bool IsEnableInactiveTimeout() => enableInactiveTimeout;

    #endregion
}