> ## 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 Gaming Runtime en prenant un pointeur vers une structure d'options qui peut modifier la façon dont le runtime est initialisé. Si les jeux doivent généralement continuer à utiliser la méthode existante [XGameRuntimeInitialize](/fr/reference/system/xgameruntimeinit/functions/xgameruntimeinitialize), certains moteurs de jeu ou middlewares peuvent nécessiter 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/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 middleware peut être utilisé pour charger et exécuter plusieurs jeux dans le même processus. Il suppose l'existence du 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 en tant que variable globale dans l'éditeur et représente le jeu actuel. Le runtime peut être initialisé avec une configuration de jeu différente, comme indiqué ci-dessous. Il peut également être réinitialisé avec une autre configuration de jeu après sa 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 présente 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. S'il s'agit de la première initialisation du runtime, les 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 été précédemment initialisé avec un autre ensemble d'options, cet appel échoue avec E\_GAMERUNTIME\_OPTIONS\_MISMATCH. Les composants middleware, 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 entièrement désinitialisé. Cela nécessite que tous les modules ayant appelé l'une des méthodes XGameRuntimeInitialize\* appellent 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. Dans le cas contraire, 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 dans lesquels le runtime est initialisé en dehors des jeux. Les erreurs d'E/S de fichier, telles que FILE\_NOT\_FOUND, ne sont pas transformées en E\_GAMERUNTIME\_GAMECONFIG\_BAD\_FORMAT afin de faciliter le diagnostic. **Désinitialisation**\ Il existe également deux couches ici. La désinitialisation de XgameRuntime.lib désinitialise la bibliothèque, puis libère sa référence sur la DLL. Les appels de désinitialisation suivants à 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 inchangé. La désinitialisation de la DLL peut échouer s'il reste des objets 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 toute tentative de l'initialiser échouera systématiquement. Lorsque le Gaming Runtime 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 fuité lors d'une initialisation précédente du runtime retourne 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/reference/system/xgameruntimeinit/functions/xgameruntimeuninitialize)\ [XGameRuntimeInitialize](/fr/reference/system/xgameruntimeinit/functions/xgameruntimeinitialize)\ [XGameRuntimeInit](/fr/reference/system/xgameruntimeinit/xgameruntimeinit_members)\ [Développement de nouveaux titres avec le Gaming Runtime](/fr/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)