Mirror

Mirror sur Edgegap

Ce guide vous aidera à créer un serveur sans interface sur Edgegap pour un projet Unity utilisant Mirror comme solution réseau.

Ce guide utilisera le projet d'exemple open-source Tanks, qui est déjà disponible dans votre exemple Mirror, emplacement Assets/Mirror/Examples/Tanks.

L'exemple final peut être trouvé sur notre GitHub.

Construire le serveur de jeu

Une fois votre jeu prêt, rendez-vous sur la Construction de l'éditeur Unity, sous Fichier -> Paramètres de compilation dans les menus supérieurs. Assurez-vous de sélectionner les bons préréglages selon votre version d'Unity.

• Avant la version 2021.2 :

  • Définir Plateforme cible vers Linux;

  • Définir Architecture vers x86_64;

  • Cochez la Compilation serveur .

• Sinon :

  • Définir Plateforme vers Serveur dédié;

  • Définir Plateforme cible vers Linux.

Puis appuyez sur construire et sélectionnez un nouveau dossier vide nommé linux_server comme destination du fichier. Transférez le linux_server dossier dans un second dossier vide, qui sera appelé [BUILD DU SERVEUR] dans ce document.

Conteneurisation du serveur de jeu dédié

Nous allons créer une image docker contenant le serveur de jeu dédié dans cette partie. Vous pourriez aussi être intéressé par la lecture de Unity Server in Docker.

Si vous avez besoin de plus d'informations sur Docker avec Edgegap, veuillez vous référer à cette documentation.

Dockerfile

FROM ubuntu:bionic
MAINTENEUR <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 [PORT_JEU]/TCP
EXPOSE [PORT_JEU]/UDP

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

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

Notez le port que vous utilisez pour les communications réseau, appelé [PORT_JEU]. Par défaut, le port utilisé est 7777. Vous pouvez trouver cette information dans l'éditeur Unity, sur le NetworkManager objet de jeu, dans le propriété Transport composant.

• Copiez les lignes ci-dessus et collez-les dans votre Dockerfile, placé à l'intérieur de [BUILD DU SERVEUR]. Modifiez les [PORT_JEU] espaces réservés pour votre port de jeu.

Avoir le [PORT_JEU] ouvert à la fois en TCP et UDP vous permet d'utiliser le transport que vous préférez dans le composant NetworkManager . Enfin, créez un fichier nommé boot.sh à la racine du [BUILD DU SERVEUR] dossier. Il sera exécuté au démarrage de l'image dans un conteneur.

• Copiez les deux lignes suivantes, assurez-vous de remplacer les [VOTRE JEU] espaces réservés par le nom du fichier généré.

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

À ce stade, vous devriez avoir la hiérarchie suivante :

• dossier [BUILD DU SERVEUR] > > - Dockerfile > > - boot.sh > > - linux_server dossier > > > - Fichiers générés par Unity

• Démarrez une invite de commande dans le [BUILD DU SERVEUR] dossier, et exécutez les commandes Docker suivantes :

Pour les utilisateurs de CPU ARM (Mac M1, M2, etc.), voir la page dédiée.

Utilisation de Linux

# construire l'image
docker build . -t <NOM_IMAGE>:<VERSION_IMAGE>

# connexion, une invite demandera le mot de passe
docker login -u '<NOM_UTILISATEUR_REGISTRE>' <URL_REGISTRE>

# ajouter une autre étiquette à votre image correspondant au registre
docker image tag <NOM_IMAGE>:<VERSION_IMAGE> <URL_REGISTRE>/<NOM_PROJET>/<NOM_IMAGE>:<VERSION_IMAGE>

# pousser l'image
docker push <URL_REGISTRE>/<NOM_PROJET>/<NOM_IMAGE>:<VERSION_IMAGE>

Utilisation de cmd

# construire l'image
docker build . -t <NOM_IMAGE>:<VERSION_IMAGE>

# connexion, une invite demandera le mot de passe
docker login -u <NOM_UTILISATEUR_REGISTRE> <URL_REGISTRE>

# ajouter une autre étiquette à votre image correspondant au registre
docker image tag <NOM_IMAGE>:<VERSION_IMAGE> <URL_REGISTRE>/<NOM_PROJET>/<NOM_IMAGE>:<VERSION_IMAGE>

# pousser l'image
docker push <URL_REGISTRE>/<NOM_PROJET>/<NOM_IMAGE>:<VERSION_IMAGE>

Utilisation de Powershell

# construire l'image
docker build . -t <NOM_IMAGE>:<VERSION_IMAGE>

# connexion, une invite demandera le mot de passe
docker login -u '<NOM_UTILISATEUR_REGISTRE>' <URL_REGISTRE>

# ajouter une autre étiquette à votre image correspondant au registre
docker image tag <NOM_IMAGE>:<VERSION_IMAGE> <URL_REGISTRE>/<NOM_PROJET>/<NOM_IMAGE>:<VERSION_IMAGE>

# pousser l'image
docker push <URL_REGISTRE>/<NOM_PROJET>/<NOM_IMAGE>:<VERSION_IMAGE>

Après ces commandes, vous devriez pouvoir voir votre image téléchargée sur le site Edgegap si vous utilisez le registre de conteneurs Edgegap. Voir ce doc si vous souhaitez utiliser le registre Edgegap. Vous pouvez également utiliser un autre registre privé.

Déploiement sur Edgegap

Naviguez vers la page Applications & Jeux du site web. Cliquez sur le Créer Nouveau bouton en haut à droite pour accéder au formulaire d'application. Voici les champs et comment les remplir correctement :

• Nom de l'application : Peut être n'importe quel nom notable que vous souhaitez utiliser pour reconnaître facilement votre application parmi les autres.

• Image : Peut être n'importe quelle image spécifique que vous souhaitez utiliser pour reconnaître facilement votre application parmi les autres.

• Nom de version : Vous pouvez utiliser un nom de version pour décrire la portée de la version que vous déployez. Des exemples peuvent être « demo », « production », « v1 », « v2 »

• Conteneur :

  • Registre : « [URL] », où [URL] est la valeur des identifiants affichables sur la page du dépôt de conteneurs.

  • Répertoire d'image : « [PROJET]/[VOTRE JEU] », où [PROJET] et [VOTRE JEU] sont les valeurs que vous avez utilisées précédemment lors de la poussée de l'image docker.

  • Tag : « [TAG] », où [TAG] est la valeur que vous avez utilisée précédemment lors de la poussée de l'image docker.

  • Cochez « Utiliser un dépôt privé »

  • Nom d'utilisateur du registre privé : « [NOM_UTILISATEUR] », où [NOM_UTILISATEUR] est la valeur de vos identifiants.

  • Jeton du registre privé : « [TOKEN] », où [TOKEN] est la valeur de vos identifiants.

  • Exigences : Laisser tel quel.

  • Ports :

    • Cliquez sur le + Ajouter un port lien pour ajouter un nouveau port, et ajoutez les entrées suivantes :

      • [PORT_JEU] - TCP/UDP - désactiver les Vérifications

      • 3389 - TCP - désactiver les Vérifications

Une fois votre application créée, vous pouvez appuyer sur le API Deploy bouton pour procéder au déploiement de votre serveur de jeu. Choisissez la région dans laquelle vous souhaitez déployer et saisissez le nombre de joueurs aléatoires que vous souhaitez générer en fonction de votre jeu. Vérifiez que tout fonctionne correctement en vérifiant ce qui suit :

• Le dernier statut doit être défini sur Prêt.

• Dans l'onglet Mappage des ports onglet, vous devriez voir le port que vous avez défini dans le formulaire de création de l'application :

Ajouter le HUD d'exemple dans votre application cliente

• Définissez le Port valeur de la propriété Transport composant du NetworkManager vers le port externe défini dans l'onglet Mappage des ports de votre déploiement.

Dans cet exemple, le port a été défini sur 31887. Cela dépend principalement du jeu que vous développez et sera très probablement défini de manière programmatique dans la base de code du jeu.

• Définissez la valeur de Adresse réseau du Gestionnaire réseau sur le Hôte. Cette URL peut être trouvée dans le Résumé du déploiement sur le tableau de bord ou via l'API.

Dans cet exemple, l'adresse a été définie sur 0ace560706a5.pr.edgegap.net. Encore une fois, cette valeur sera très probablement définie de manière programmatique lors de la communication du client avec le serveur master/API responsable du processus de matchmaking.

Avec les bonnes informations, vous devriez pouvoir vous connecter normalement au serveur de jeu et commencer à jouer immédiatement.

Vous avez maintenant un projet Mirror disponible à déployer à la demande !

Avec des déploiements basés sur des places, il est possible d'utiliser Mirror pour créer un système qui supprime automatiquement les sessions Edgegap bloquées une fois qu'un joueur se déconnecte du serveur, en utilisant NetworkManager fonctions de rappel, et un NetworkBehaviour script attaché au prefab du joueur qui utilise une procédure distante (RPC) et une fonction Command.

Lorsque le serveur démarre, le NetworkManager récupère la liste des ID de session liés à son déploiement depuis l'API Edgegap et les stocke. Ensuite, lorsqu'un nouveau joueur se connecte au serveur, une fonction côté client est initiée via RPC qui enverra l' adresse IP du joueur au serveur avec une commande. Avec l'IP du joueur, le serveur vérifie s'il existe une IP correspondante dans les données de chaque session ; Le serveur obtient les données de la session en utilisant son ID mis en cache avec l'API Edgegap. Si une correspondance est trouvée, l' ID de session est mappé à la NetworkConnectionToClient.

Étant donné que de nouvelles sessions peuvent être ajoutées après le démarrage du serveur, la liste des ID de session est mise à jour et les nouvelles sessions sont vérifiées si une correspondance n'a pas pu être trouvée la première fois.

Enfin, une fois qu'un joueur se déconnecte du serveur, le serveur utilise le NetworkConnectionToClient de ce joueur pour récupérer leur ID de sessionassocié, puis utilise l'API Edgegap pour supprimer cette session. Cela libère une socket dans le déploiement pour qu'un nouveau joueur puisse rejoindre.

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("Échec de la récupération de l'adresse IP publique.");
        }
    }

    [Command]
    public void CmdSendIpAddressToServer(string clientIp)
    {
        NetworkConnectionToClient conn = connectionToClient;
        if (conn != null)
        {
            CustomNetworkManager.Instance.StoreClientIpAddress(conn, clientIp);
        }
        else
        {
            Debug.LogError("Connexion non trouvée.");
        }
    }
}

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("Jeton API Edgegap introuvable dans les variables d'environnement.");
        }

        StartCoroutine(GetNewSessionList());
    }

    public override void OnServerAddPlayer(NetworkConnectionToClient conn)
    {
        base.OnServerAddPlayer(conn);
        Debug.Log($"Ajout d'un joueur pour la connexion : {conn.connectionId}");

        // Obtenir le PlayerNetworkBehaviour à partir de l'objet joueur
        PlayerNetworkBehaviour playerNetworkBehaviour = conn.identity.GetComponent<PlayerNetworkBehaviour>();
        playerNetworkBehaviour.RpcSendClientIpAddress();
    }

    public void StoreClientIpAddress(NetworkConnectionToClient conn, string clientIp)
    {
        mappingInProgress[conn] = true; // Définir la mise en correspondance en cours sur true
        Debug.Log($"Adresse IP stockée pour la connexion {conn.connectionId} : {clientIp}");

        // Démarrer la mise en correspondance de la session avec la connexion
        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("Réponse du statut du déploiement : " + 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("Nouvelle liste de sessions initialisée");
        }
    }

    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("Impossible de mapper le joueur avec les sessions mises en cache actuelles");
            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($"Récupération des détails de la session pour l'ID de session : {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 récupérée avec succès.");
            string responseText = request.downloadHandler.text;
            Debug.Log("Réponse de la session : " + responseText);

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

            if (sessionUsers != null && sessionUsers.Count > 0)
            {
                Debug.Log($"Trouvé {sessionUsers.Count} utilisateur(s) dans la session.");
                foreach (var user in sessionUsers)
                {
                    string playerIp = user["ip"]?.ToString();
                    Debug.Log($"IP du joueur : {playerIp}, IP de la connexion : {clientAddress}");
                    if (playerIp == clientAddress)
                    {
                        connectionToSessionIdMap[conn] = sessionId;
                        Debug.Log($"Session ID {sessionId} mappé à la connexion {conn.connectionId} avec l'IP {playerIp}");

                        // Journalisation de confirmation supplémentaire
                        if (connectionToSessionIdMap.ContainsKey(conn))
                        {
                            Debug.Log($"ID de session {sessionId} stocké avec succès pour la connexion {conn.connectionId} avec l'IP {playerIp}");
                        }
                        else
                        {
                            Debug.LogError($"Échec du stockage de l'ID de session {sessionId} pour la connexion {conn.connectionId} avec l'IP {playerIp}");
                        }

                        break;
                    }
                }
            }
            else
            {
                Debug.LogError("Aucun utilisateur trouvé dans la session.");
            }
        }
        else
        {
            Debug.LogError($"Erreur lors de la récupération de la session : {request.error}");
            Debug.LogError($"Code de réponse : {request.responseCode}");
            Debug.LogError($"Texte de la réponse : {request.downloadHandler.text}");
        }

        mappingInProgress[conn] = false; // Définir la mise en correspondance en cours sur false une fois terminée
    }

    public override void OnServerDisconnect(NetworkConnectionToClient conn)
    {
        base.OnServerDisconnect(conn);
        Debug.Log($"Le serveur a déconnecté le client : {conn.connectionId}");

        StartCoroutine(HandleDisconnect(conn));
    }

    private IEnumerator HandleDisconnect(NetworkConnectionToClient conn)
    {
        while (mappingInProgress.ContainsKey(conn) && mappingInProgress[conn])
        {
            Debug.Log($"Attente de la fin du mappage de session pour la connexion {conn.connectionId}...");
            yield return new WaitForSeconds(0.1f);
        }

        if (connectionToSessionIdMap.TryGetValue(conn, out string sessionId))
        {
            Debug.Log($"Suppression de l'ID de session : {sessionId}");
            StartCoroutine(DeleteSession(sessionId));
            connectionToSessionIdMap.Remove(conn);
            mappingInProgress.Remove(conn);
            currentDeploymentSessions.Remove(sessionId);
        }
        else
        {
            Debug.LogWarning("Aucun ID de session trouvé pour cette connexion.");
        }
    }

    private IEnumerator DeleteSession(string sessionId)
    {
        Debug.Log($"Envoi de la requête pour supprimer l'ID de session : {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 supprimée avec succès.");
        }
        else
        {
            Debug.LogError($"Erreur lors de la suppression de la session : {request.error}");
            Debug.LogError($"Code de réponse : {request.responseCode}");
            Debug.LogError($"Texte de la réponse : {request.downloadHandler.text}");
        }
    }

}

Fonctionnalités optionnelles

Ce script peut être étendu avec des fonctionnalités optionnelles et indépendantes qui aident à gérer les sessions dans des cas spécifiques.

Par exemple, un délai d'expiration peut être défini pour supprimer les sessions de places vides après un laps de temps configurable suite à l'initialisation complète du serveur. C'est une fonctionnalité utile dans le cas d'un joueur qui quitte avant que son ticket de matchmaking soit résolu, ce qui créerait une session vide une fois qu'une correspondance est trouvée. Si le joueur n'envoie jamais son adresse IP pour être mappée à l'ID de session avant l'expiration du délai, alors cette session est supprimée pour libérer une socket.

Une autre fonctionnalité peut être de déconnecter les joueurs inactifs après une longue période afin de libérer des sockets. Une fois connecté au serveur, le client doit envoyer un message de battement minimaliste au serveur toutes les quelques secondes, ou est autrement déconnecté si trop de battements sont manqués d'affilée. À la fois l'intervalle entre les battements et le nombre maximum de messages manquants consécutifs peuvent être configurés, en fonction des besoins du jeu. Dans cet exemple, un battement est envoyé toutes les quelques secondes si le tank se déplace sur la carte ou tire.

PlayerNetworkBehaviour - Gestion des sessions par siège

    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("Connexion non trouvée.");
            }
        }
    }

CustomNetworkManager - Gestion des sessions par siège

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

    [Header("Délai d'expiration de session vide")]
    [SerializeField] private bool enableEmptyTimeout;
    [SerializeField] private float deleteAfterSeconds = 15f;

    [Header("Délai d'inactivité du joueur")]
    [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("Jeton API Edgegap introuvable dans les variables d'environnement.");
        }
        else
        {
            Debug.Log("Jeton API Edgegap trouvé : " + 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("Réponse du statut du déploiement : " + 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("Nouvelle liste de sessions initialisée");
        }
        else
        {
            Debug.LogError($"Erreur lors de la récupération de la liste des sessions : {request.error}");
            Debug.LogError($"Code de réponse : {request.responseCode}");
            Debug.LogError($"Texte de la réponse : {request.downloadHandler.text}");
        }

        listInProgress = false;
    }

    ...

    private IEnumerator GetSessionAndMap(NetworkConnectionToClient conn, string sessionId, string clientAddress)
    {
        Debug.Log($"Récupération des détails de la session pour l'ID de session : {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 récupérée avec succès.");
            string responseText = request.downloadHandler.text;
            Debug.Log("Réponse de la session : " + responseText);

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

            if (sessionUsers != null && sessionUsers.Count > 0)
            {
                Debug.Log($"Trouvé {sessionUsers.Count} utilisateur(s) dans la session.");
                foreach (var user in sessionUsers)
                {
                    string playerIp = user["ip"]?.ToString();
                    Debug.Log($"IP du joueur : {playerIp}, IP de la connexion : {clientAddress}");
                    if (playerIp == clientAddress)
                    {
                        connectionToSessionIdMap[conn] = sessionId;
                        Debug.Log($"Session ID {sessionId} mappé à la connexion {conn.connectionId} avec l'IP {playerIp}");

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

                        // Journalisation de confirmation supplémentaire
                        if (connectionToSessionIdMap.ContainsKey(conn))
                        {
                            Debug.Log($"ID de session {sessionId} stocké avec succès pour la connexion {conn.connectionId} avec l'IP {playerIp}");
                        }
                        else
                        {
                            Debug.LogError($"Échec du stockage de l'ID de session {sessionId} pour la connexion {conn.connectionId} avec l'IP {playerIp}");
                        }

                        break;
                    }
                }
            }
            else
            {
                Debug.LogError("Aucun utilisateur trouvé dans la session.");
            }
        }
        else
        {
            Debug.LogError($"Erreur lors de la récupération de la session : {request.error}");
            Debug.LogError($"Code de réponse : {request.responseCode}");
            Debug.LogError($"Texte de la réponse : {request.downloadHandler.text}");
        }

        mappingInProgress[conn] = false; // Définir la mise en correspondance en cours sur false une fois terminée
    }

    ...

    #region EmptySessionTimeout

    private IEnumerator StartServerInitSessionsTimeout()
    {
        while (listInProgress)
        {
            Debug.Log($"En attente de la récupération de la liste des sessions...");
            yield return new WaitForSeconds(0.1f);
        }

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

    private IEnumerator WaitForConnectionTimeout(string sessionID)
    {
        Debug.Log($"Vérification du délai d'expiration vide pour la 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($"Aucune connexion initiée par le client après {deleteAfterSeconds}s, suppression de la 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($"La connexion {conn.connectionId} a manqué {counter} battement(s) de suite");
            }
            else
            {
                counter = 0;
                Debug.Log($"Réinitialisation du compteur de battements pour la connexion {conn.connectionId}");
            }

            yield return new WaitForSeconds(secondsBetweenHeartbeats);
        }

        if (counter >= maxMissedHeartbeats && conn.isReady)
        {
            Debug.Log($"La connexion {conn.connectionId} est inactive depuis trop longtemps, déconnexion");
            conn.Disconnect();
            connectionToLastHeartbeatMap.Remove(conn);
        }
    }

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

    public float GetSecondsBetweenHeartbeats() => secondsBetweenHeartbeats;

    public bool IsEnableInactiveTimeout() => enableInactiveTimeout;

    #endregion
}