Mirror

Edgegap 上的 Mirror

本指南将帮助你在 Edgegap 上为一个 Unity 项目创建无头服务器，使用 Mirror 作为其网络解决方案。

本指南将使用开源示例项目 Tanks，它已在你的 Mirror 示例中可用，位置为 Assets/Mirror/Examples/Tanks。

最终示例可以在我们的 GitHub.

构建游戏服务器

当你的游戏准备就绪后，前往 Build Unity 编辑器的界面，在 File -> Build Settings 顶端菜单中。请确保根据你的 Unity 版本选择正确的预设。

• 2021.2 之前的版本：

  • 设置 目标平台 转向 Linux;

  • 设置 架构 转向 x86_64;

  • 勾选 Server Build 选项时，动态注入环境变量。

• 否则：

  • 设置 平台 转向 Dedicated Server;

  • 设置 目标平台 转向 Linux.

然后点击构建，并选择一个名为 linux_server 的新空文件夹作为文件目标。将 linux_server 文件夹转移到第二个空文件夹中，在本文档中将其称为 [SERVER BUILD] 文件夹。

将专用游戏服务器容器化

在本部分我们将创建一个包含专用游戏服务器的 docker 镜像。你可能也会对阅读 Docker 中的 Unity Server.

感兴趣。如果你需要更多关于 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 编辑器中找到此信息，位于 NetworkManager 游戏对象 上，在 Transport 组件中。

• 复制以上行并将它们粘贴到你的 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 网站上看到你上传的镜像。参见 此文档 如果你想使用 Edgegap 注册表。你也可以使用其他私有仓库。

部署到 Edgegap

导航到网站的 Applications & Games 页面。点击右上角的 Create New 按钮进入应用程序表单。以下是各字段及其正确填写方式：

• Application name：可以是任何你希望使用的醒目名称，便于在其他应用中轻松识别你的应用。

• Image：可以是任何你希望使用的特定图像，以便在其他应用中轻松识别你的应用。

• Version name：你可能希望使用版本名称来描述你正在部署的版本范围。例如“demo”、“production”、“v1”、“v2”。

• Container：

  • Registry：“[URL]”，其中 [URL] 是你可以在容器仓库页面显示的凭据中的值。

  • Image repository：“[PROJECT]/[YOUR GAME]”，其中 [PROJECT] 和 [YOUR GAME] 是你之前推送 docker 镜像时使用的值。

  • Tag：“[TAG]”，其中 [TAG] 是你之前推送 docker 镜像时使用的值。

  • 勾选“Using a private repository”

  • Private registry username：“[USERNAME]”，其中 [USERNAME] 是你凭据中的值。

  • Private registry token：“[TOKEN]”，其中 [TOKEN] 是你凭据中的值。

  • Requirements：保持默认。

  • Ports：

    • 点击 + Add port 链接以添加新端口，并添加以下条目：

      • [GAME PORT] - TCP/UDP - 关闭 Verifications

      • 3389 - TCP - 关闭 Verifications

创建应用后，你可以按下 Deploy（部署） 按钮以继续部署你的游戏服务器。选择你要部署的区域，并根据你的游戏输入你想要生成的随机玩家数量。通过验证以下内容来检查一切是否正常运行：

• Latest Status 应设置为 Ready.

• 在 端口映射 选项卡中，你应能看到你在创建应用时设置的端口：

在你的客户端应用中添加示例 HUD

• 将 Port 的值，将 Transport 组件的 NetworkManager 设置为部署中在 端口映射 选项卡定义的外部端口。

在此示例中，端口被设置为 31887。这主要取决于你正在开发的游戏，并且很可能会在游戏代码库中以编程方式进行设置。

• 设置 Network Address 的值，将 Network Manager 设置为你的部署的 Host。该 URL 可在 Deployment Summary 仪表板上或通过 API 找到。

在此示例中，地址被设置为 0ace560706a5.pr.edgegap.net。同样，此值很可能会在客户端与负责匹配流程的主服务器/API 通信期间以编程方式设置。

有了正确的信息，你应该能够正常连接到游戏服务器，并立即开始游戏。

你现在拥有一个可按需部署的 Mirror 项目！

借助基于席位的部署，可以使用 Mirror 创建一个系统：当玩家从服务器断开连接时，利用 NetworkManager 回调函数，以及 NetworkBehaviour 脚本（附加在玩家预制体上）来使用 RPC（远程过程调用）函数和 Command 函数，自动移除挂起的 Edgegap 会话。

当服务器启动时， NetworkManager 从 Edgegap API 获取与其部署关联的 会话 ID 列表并进行存储。之后，当新玩家连接到服务器时，通过 RPC 启动客户端函数，将 玩家的 IP 地址 通过 command发送回服务器。凭借玩家的 IP，服务器在每个会话的数据中检查是否有匹配 IP；服务器使用其在 Edgegap API 中缓存的 ID 获取会话数据。如果找到匹配， 会话 ID 将映射到该玩家的 NetworkConnectionToClient.

由于在服务器启动后可能会新增会话，如果第一次未找到匹配，会更新会话 ID 列表并检查新会话。

最后，一旦玩家从服务器断开连接，服务器使用该玩家的 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("Failed to fetch public IP address.");
        }
    }

    [Command]
    public void CmdSendIpAddressToServer(string clientIp)
    {
        NetworkConnectionToClient conn = connectionToClient;
        if (conn != null)
        {
            CustomNetworkManager.Instance.StoreClientIpAddress(conn, clientIp);
        }
        else
        {
            Debug.LogError("Connection not found.");
        }
    }
}

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($"Adding player for connection: {conn.connectionId}");

        // 从玩家对象获取 PlayerNetworkBehaviour
        PlayerNetworkBehaviour playerNetworkBehaviour = conn.identity.GetComponent<PlayerNetworkBehaviour>();
        playerNetworkBehaviour.RpcSendClientIpAddress();
    }

    public void StoreClientIpAddress(NetworkConnectionToClient conn, string clientIp)
    {
        mappingInProgress[conn] = true; // 将映射进行中设置为 true
        Debug.Log($"Stored IP address for connection {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("Deployment Status Response: " + 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("New session list initialized");
        }
    }

    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("Could not map player with current cached sessions");
            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($"Fetching session details for session 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("Session fetched successfully.");
            string responseText = request.downloadHandler.text;
            Debug.Log("Session Response: " + responseText);

            var session = JObject.Parse(responseText);
            var sessionUsers = session["session_users"] as JArray;

            if (sessionUsers != null && sessionUsers.Count > 0)
            {
                Debug.Log($"Found {sessionUsers.Count} users in session.");
                foreach (var user in sessionUsers)
                {
                    string playerIp = user["ip"]?.ToString();
                    Debug.Log($"Player IP: {playerIp}, Connection IP: {clientAddress}");
                    if (playerIp == clientAddress)
                    {
                        connectionToSessionIdMap[conn] = sessionId;
                        Debug.Log($"Mapped session ID {sessionId} to connection {conn.connectionId} with IP {playerIp}");

                        // 额外的确认日志
                        if (connectionToSessionIdMap.ContainsKey(conn))
                        {
                            Debug.Log($"Session ID {sessionId} successfully stored for connection {conn.connectionId} with IP {playerIp}");
                        }
                        else
                        {
                            Debug.LogError($"Failed to store session ID {sessionId} for connection {conn.connectionId} with IP {playerIp}");
                        }

                        break;
                    }
                }
            }
            else
            {
                Debug.LogError("No users found in session.");
            }
        }
        else
        {
            Debug.LogError($"Error fetching session: {request.error}");
            Debug.LogError($"Response Code: {request.responseCode}");
            Debug.LogError($"Response Text: {request.downloadHandler.text}");
        }

        mappingInProgress[conn] = false; // 完成后将映射进行中设置为 false
    }

    public override void OnServerDisconnect(NetworkConnectionToClient conn)
    {
        base.OnServerDisconnect(conn);
        Debug.Log($"Server disconnected client: {conn.connectionId}");

        StartCoroutine(HandleDisconnect(conn));
    }

    private IEnumerator HandleDisconnect(NetworkConnectionToClient conn)
    {
        while (mappingInProgress.ContainsKey(conn) && mappingInProgress[conn])
        {
            Debug.Log($"Waiting for session mapping to complete for connection {conn.connectionId}...");
            yield return new WaitForSeconds(0.1f);
        }

        if (connectionToSessionIdMap.TryGetValue(conn, out string sessionId))
        {
            Debug.Log($"Deleting session ID: {sessionId}");
            StartCoroutine(DeleteSession(sessionId));
            connectionToSessionIdMap.Remove(conn);
            mappingInProgress.Remove(conn);
            currentDeploymentSessions.Remove(sessionId);
        }
        else
        {
            Debug.LogWarning("No session ID found for this connection.");
        }
    }

    private IEnumerator DeleteSession(string sessionId)
    {
        Debug.Log($"Sending request to delete session 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("Session deleted successfully.");
        }
        else
        {
            Debug.LogError($"Error deleting session: {request.error}");
            Debug.LogError($"Response Code: {request.responseCode}");
            Debug.LogError($"Response Text: {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("Connection not found.");
            }
        }
    }

CustomNetworkManager - 席位会话管理

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

    [Header("Empty Session Timeout")]
    [SerializeField] private bool enableEmptyTimeout;
    [SerializeField] private float deleteAfterSeconds = 15f;

    [Header("Inactive Player Timeout")]
    [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 token found: " + 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("Deployment Status Response: " + 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("New session list initialized");
        }
        else
        {
            Debug.LogError($"Error fetching session list: {request.error}");
            Debug.LogError($"Response Code: {request.responseCode}");
            Debug.LogError($"Response Text: {request.downloadHandler.text}");
        }

        listInProgress = false;
    }

    ...

    private IEnumerator GetSessionAndMap(NetworkConnectionToClient conn, string sessionId, string clientAddress)
    {
        Debug.Log($"Fetching session details for session 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("Session fetched successfully.");
            string responseText = request.downloadHandler.text;
            Debug.Log("Session Response: " + responseText);

            var session = JObject.Parse(responseText);
            var sessionUsers = session["session_users"] as JArray;

            if (sessionUsers != null && sessionUsers.Count > 0)
            {
                Debug.Log($"Found {sessionUsers.Count} users in session.");
                foreach (var user in sessionUsers)
                {
                    string playerIp = user["ip"]?.ToString();
                    Debug.Log($"Player IP: {playerIp}, Connection IP: {clientAddress}");
                    if (playerIp == clientAddress)
                    {
                        connectionToSessionIdMap[conn] = sessionId;
                        Debug.Log($"Mapped session ID {sessionId} to connection {conn.connectionId} with IP {playerIp}");

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

                        // 额外的确认日志
                        if (connectionToSessionIdMap.ContainsKey(conn))
                        {
                            Debug.Log($"Session ID {sessionId} successfully stored for connection {conn.connectionId} with IP {playerIp}");
                        }
                        else
                        {
                            Debug.LogError($"Failed to store session ID {sessionId} for connection {conn.connectionId} with IP {playerIp}");
                        }

                        break;
                    }
                }
            }
            else
            {
                Debug.LogError("No users found in session.");
            }
        }
        else
        {
            Debug.LogError($"Error fetching session: {request.error}");
            Debug.LogError($"Response Code: {request.responseCode}");
            Debug.LogError($"Response Text: {request.downloadHandler.text}");
        }

        mappingInProgress[conn] = false; // 完成后将映射进行中设置为 false
    }

    ...

    #region EmptySessionTimeout

    private IEnumerator StartServerInitSessionsTimeout()
    {
        while (listInProgress)
        {
            Debug.Log($"Waiting to retrieve session list...");
            yield return new WaitForSeconds(0.1f);
        }

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

    private IEnumerator WaitForConnectionTimeout(string sessionID)
    {
        Debug.Log($"Checking for empty timeout on session {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($"No connection initiated by client after {deleteAfterSeconds}s, deleting session {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($"Connection {conn.connectionId} has missed {counter} heartbeat(s) in a row");
            }
            else
            {
                counter = 0;
                Debug.Log($"Reset heartbeat counter for connection {conn.connectionId}");
            }

            yield return new WaitForSeconds(secondsBetweenHeartbeats);
        }

        if (counter >= maxMissedHeartbeats && conn.isReady)
        {
            Debug.Log($"Connection {conn.connectionId} inactive for too long, disconnecting");
            conn.Disconnect();
            connectionToLastHeartbeatMap.Remove(conn);
        }
    }

    public void StoreClientHeartbeatTime(NetworkConnectionToClient conn, double time)
    {
        connectionToLastHeartbeatMap[conn] = time;
    }

    public float GetSecondsBetweenHeartbeats() => secondsBetweenHeartbeats;

    public bool IsEnableInactiveTimeout() => enableInactiveTimeout;

    #endregion
}