> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # XGameRuntimeInitializeWithOptions > XGameRuntimeInitializeWithOptions # XGameRuntimeInitializeWithOptions Cette API initialise le runtime de jeu en prenant un pointeur vers une structure d'options qui peut modifier la façon dont le runtime est initialisé. Bien que les jeux doivent généralement continuer à utiliser la méthode existante [XGameRuntimeInitialize](/fr-CA/reference/system/xgameruntimeinit/functions/xgameruntimeinitialize), certains moteurs de jeu ou intergiciels peuvent avoir besoin d'une initialisation plus configurable. ## Syntaxe ```cpp theme={null} HRESULT XGameRuntimeInitializeWithOptions( _In_ const XGameRuntimeOptions* options ) ``` ### Paramètres *options* \_In\_\ Type : XGameRuntimeOptions\* Pointeur vers une structure d'options qui peut modifier la façon dont le runtime est initialisé. ### Valeur de retour Type : [HRESULT](https://learn.microsoft.com/openspecs/windows_protocols/ms-erref/0642cb2f-2075-4469-918c-4441e69c548a) Retourne **S\_OK** en cas de réussite; sinon, retourne un code d'erreur. Pour obtenir la liste des codes d'erreur, consultez [Codes d'erreur](/fr-CA/reference/errorcodes). Si la fonction échoue parce que la bibliothèque du Gaming Runtime (xgameruntime.dll) est introuvable, la valeur de retour est définie sur **E\_GAMERUNTIME\_DLL\_NOT\_FOUND**. ## Remarques L'exemple suivant montre comment un éditeur de jeu ou un autre intergiciel peut être utilisé pour charger et exécuter plusieurs jeux dans le même processus. Il suppose le code externe suivant : * Une classe appelée « GameEngine » qui prend le chemin d'accès aux fichiers du jeu et démarre le jeu. Il s'agit du même moteur que celui utilisé au moment de l'exécution par le « lecteur » du moteur de jeu. * Une instance de cette classe est stockée comme variable globale dans l'éditeur et représente le jeu actuel. Le runtime peut être initialisé avec une configuration de jeu différente, comme illustré ci-dessous. Il peut également être réinitialisé avec une configuration de jeu différente après la désinitialisation. ```cpp theme={null} void StartGame(const char* gamePath) { // If there is an existing game running, shut it down if (g_game.IsRunning()) { g_game.Stop() } // Initialize the runtime in this process for this path std::string gameConfig(gamePath); gameConfig.append(“\\MicrosoftGame.config”); XGameRuntimeOptions options{}; options.gameConfigSource = XGameRuntimeGameConfigSource::File; options.gameConfig = gameConfig.c_str(); THROW_IF_FAILED(XGameRuntimeInitializeWithOptions(&options)); // Now launch the game normally. GameEngine game; game.Launch(gamePath); g_game = std::move(game); } // Examples of Launch / Stop behavior in GameEngine void GameEngine::Stop() { // Disconnect all globals from the runtime, closing handles and removing event // handlers // Handle game shut down before uninitializing the runtime XGameRuntimeUninitialize(); } void GameEngine::Launch(const char* gamePath) { // Standard XGameRuntimeInitialize here is fine to call – it will adopt the // GameConfig settings from the earlier XGameRuntimeInitializeWithOptions call. XGameRuntimeInitialize(); RunGame(gamePath); } ``` **Initialisation**\ Le runtime comporte deux couches d'initialisation : XGameRuntime.lib, à laquelle un composant est lié, et XGameRuntime.dll, qui est l'implémentation réelle du runtime. Lorsque XGameRuntime.lib est initialisée, elle charge XGameRuntime.dll et l'initialise. L'initialisation de la DLL utilise un décompte de références, ce qui permet à plusieurs bibliothèques de s'y connecter. L'initialisation de la bibliothèque n'utilise pas de décompte de références : les appels multiples pour l'initialiser sont ignorés (toutefois, si XGameRuntimeInitializeWithOptions est appelée, les options fournies sont comparées aux options actuellement initialisées et E\_GAMERUNTIME\_OPTIONS\_MISMATCH est retourné si elles diffèrent). Chaque API d'initialisation a le comportement suivant : * **XGameRuntimeInitialize** : si la DLL du runtime a déjà été initialisée par un autre appel, cette API s'aligne sur les options d'initialisation fournies lors de cet autre appel. Si c'est la première fois que le runtime est initialisé, des valeurs par défaut sont utilisées pour les options d'initialisation. Les jeux doivent toujours initialiser le runtime à l'aide de cette API. * **XGameRuntimeInitializeWithOptions** : tous les composants qui initialisent le runtime doivent transmettre les mêmes options s'ils utilisent cette méthode. Si le runtime a déjà été initialisé avec un autre ensemble d'options, cet appel échoue avec E\_GAMERUNTIME\_OPTIONS\_MISMATCH. Les composants intergiciels, comme un éditeur de jeu Unity, peuvent utiliser cette API pour initialiser le runtime avec un GameConfig personnalisé avant de démarrer le jeu. Le runtime peut être réinitialisé avec des options différentes s'il est d'abord complètement désinitialisé. Pour cela, tous les modules qui ont appelé l'une des méthodes XGameRuntimeInitialize\* doivent appeler XGameRuntimeUninitialize. Si le jeu est empaqueté dans un XVC ou un MSIXVC, toutes les options personnalisées fournies doivent correspondre aux paramètres de la configuration de jeu du package. Sinon, l'appel d'initialisation échoue avec E\_GAMERUNTIME\_OPTIONS\_NOT\_SUPPORTED. Notez qu'une erreur ERROR\_NOT\_FOUND pour la configuration de jeu n'est pas considérée comme un échec, car il existe actuellement des scénarios où le runtime est initialisé en dehors des jeux. Les erreurs d'E/S de fichier, comme FILE\_NOT\_FOUND, ne sont pas transformées en E\_GAMERUNTIME\_GAMECONFIG\_BAD\_FORMAT afin de faciliter le diagnostic. **Désinitialisation**\ Il y a également deux couches ici. La désinitialisation de XgameRuntime.lib désinitialise la bibliothèque et libère sa référence sur la DLL. Les appels de désinitialisation subséquents à la bibliothèque sont ignorés jusqu'à ce que la bibliothèque soit réinitialisée. La désinitialisation de la DLL décrémente le décompte de références. Lorsqu'il atteint zéro, la DLL est désinitialisée. Ce comportement reste le même. La désinitialisation de la DLL peut échouer s'il reste des objets du runtime actifs lorsque le décompte de références de la DLL atteint zéro. Dans ce cas, le runtime : * Ne décharge pas la DLL du runtime, car cela pourrait provoquer un plantage. * Stocke l'erreur afin de la retourner lors d'un appel ultérieur à XGameRuntimeInitialize\* * Un XErrorReport est émis. Notez qu'en raison de ce comportement, un échec de désinitialisation est définitif : le runtime n'est plus initialisé et les tentatives de l'initialiser échoueront toujours. Lorsque le runtime de jeu est désinitialisé, tous les handles doivent être fermés par le jeu. Tout handle laissé ouvert est considéré comme une fuite de mémoire. Toute tentative d'utilisation d'un handle ayant fui lors d'une initialisation antérieure du runtime retournera E\_GAMERUNTIME\_INVALID\_HANDLE. ## Configuration requise **En-tête :** XGameRuntimeInit.h **Bibliothèque :** xgameruntime.lib **Plateformes prises en charge :** Windows, consoles de la famille XBOX One et consoles XBOX Series ## Voir aussi [XGameRuntimeUninitialize](/fr-CA/reference/system/xgameruntimeinit/functions/xgameruntimeuninitialize)\ [XGameRuntimeInitialize](/fr-CA/reference/system/xgameruntimeinit/functions/xgameruntimeinitialize)\ [XGameRuntimeInit](/fr-CA/reference/system/xgameruntimeinit/xgameruntimeinit_members)\ [Développement de nouveaux titres à l'aide du Gaming Runtime](/fr-CA/build/gdk-and-engines/guides/gdk-project-templates) ## Related topics - [XGameRuntimeInitializeWithOptions](/reference/system/xgameruntimeinit/functions/xgameruntimeinitializewithoptions.md) - [XGameRuntimeInitialize](/reference/system/xgameruntimeinit/functions/xgameruntimeinitialize.md) - [XGameRuntimeOptions](/reference/system/xgameruntimeinit/Structures/xgameruntimeoptions.md)