> ## 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.

# WdLaunchRemoteGame

> WdLaunchRemoteGame

# WdLaunchRemoteGame

Lance un jeu sur un appareil distant.

## Syntaxe

```cpp theme={null}
HRESULT WdLaunchRemoteGame(  
         _In_z_ const char* remoteDevice,  
         _In_z_ const char* remotePath,  
         _In_opt_z_ const char* args,  
         _In_opt_ const WdLaunchOptions* launchOptions,  
         _Out_opt_ uint32_t* processId,  
         _Out_opt_ uint32_t* threadId  
);  
```

### Paramètres

`_In_z_ remoteDevice`\
Type : **const char\***

Nom d'hôte ou adresse IP de l'appareil distant (par exemple, `"192.168.1.100"` ou `"MyDevKit"`).

`_In_z_ remotePath`\
Type : **const char\***

Chemin d'accès à l'exécutable du jeu sur l'appareil distant. Il peut s'agir d'un chemin absolu (par exemple, `"D:\\Games\\MyGame\\game.exe"`) ou d'un chemin relatif résolu par rapport à la racine commune (par exemple, `"MyGame\\game.exe"`).

`_In_opt_z_ args`\
Type : **const char\***

Facultatif. Arguments de ligne de commande à transmettre à l'exécutable du jeu (par exemple, `"-windowed -debug"`). Passez `nullptr` si aucun argument n'est nécessaire.

`_In_opt_ launchOptions`\
Type : **[WdLaunchOptions](/fr/reference/remoting/structs/wdlaunchoptions)\***

Facultatif. Spécifie le mode de lancement et l'alias de racine commune. Passez `nullptr` pour utiliser les paramètres par défaut (lancement `Immediate`, racine commune par défaut).

`_Out_opt_ processId`\
Type : **uint32\_t\***

Facultatif. Reçoit l'ID de processus du jeu lancé. Passez `nullptr` si l'ID de processus n'est pas nécessaire.

`_Out_opt_ threadId`\
Type : **uint32\_t\***

Facultatif. Reçoit l'ID du thread principal du jeu lancé. Passez `nullptr` si l'ID de thread n'est pas nécessaire.

### Valeur de retour

Type : **HRESULT**

Renvoie `S_OK` en cas de réussite ; sinon, renvoie un code d'erreur.

#### Codes d'erreur

| Code | Valeur | Description | Cause racine | Résolution des problèmes |
| - | - | - | - | - |
| E\_GAMEFILEPATHNOTEXIST | 0x8C114010 | Le chemin d'accès au fichier du jeu n'existe pas. | Le chemin de l'exécutable ou du package du jeu fourni n'est pas valide ou n'est pas accessible sur l'ordinateur distant. | Vérifiez que le chemin existe sur l'appareil distant ; Confirmez que l'opération de copie a réussi |
| E\_CONNECTIONERROR | 0x8C114014 | Erreur de connexion. | Échec générique lors de l'établissement de la connexion réseau (échec au niveau du transport), sans rapport avec la validité de l'adresse IP ou la résolution du nom de l'ordinateur distant | Vérifiez la connectivité réseau, les règles de pare-feu et la disponibilité du service sur l'ordinateur distant ; Vérifiez la visibilité entre les appareils, qui doivent pouvoir s'envoyer des pings ; Réessayez la connexion avec la journalisation activée. |
| E\_NAMERESOLUTIONFAILED | 0x8C114012 | Impossible de résoudre le nom de l'ordinateur distant. | Le nom d'hôte ne peut pas être résolu via DNS ou la résolution de noms locale. | Vérifiez l'orthographe du nom d'hôte, la configuration DNS et la connectivité réseau. ; Utilisez l'adresse IP pour isoler les problèmes de résolution de noms. |
| E\_INVALIDADDRESS | 0x8C114013 | Adresse non valide. | Adresse réseau fournie incorrecte, mal formée ou non prise en charge (par exemple, format IP incorrect, IP erronée ou protocole non pris en charge). | Confirmez que l'adresse IP est correcte ; Corrigez le format de l'adresse et assurez-vous qu'elle utilise le protocole IPv4 |
| E\_CLIENTNOTAUTHORIZED | 0x8C114008 | L'appareil a rejeté le client. | Le client ne figure pas dans la liste des clients approuvés de l'appareil. La tentative de connexion a démarré avant la fin du processus d'appairage | Terminez correctement le processus d'appairage par code PIN ; Exécutez à nouveau la demande de connexion |
| E\_SERVERNOTAUTHORIZED | 0x8C114009 | Le client a rejeté l'appareil. | L'appareil cible ne figure pas dans la liste des points de terminaison approuvés du client. La tentative de connexion a démarré avant la fin du processus d'appairage | Terminez correctement le processus d'appairage par code PIN ; Exécutez à nouveau la demande de connexion |
| E\_SERVERTOOOLD | 0x8C114011 | La version du serveur est trop ancienne pour ce client. | La version de l'API côté client est plus récente que la version du point de terminaison sur l'appareil distant | Mettez à jour wdEndpoint sur l'ordinateur distant vers une version compatible |
| E\_ADMIN\_REQUIRED | 0x8C114016 | Privilèges d'administrateur requis. | Le point de terminaison ne s'exécute pas avec des privilèges élevés et l'opération nécessite des autorisations de niveau Administrateur | Réexécutez le point de terminaison en tant qu'administrateur |

## Remarques

Un seul processus de jeu peut s'exécuter à la fois sur l'appareil distant. Si un jeu est déjà en cours d'exécution, cette fonction l'arrête automatiquement et le relance. Le jeu existant peut être arrêté à l'aide de [WdTerminateRemoteGame](/fr/reference/remoting/functions/wdterminateremotegame) avant d'en lancer un nouveau.

Lorsqu'il est lancé avec [WdLaunchMode::Suspended](/fr/reference/remoting/enums/wdlaunchmode), le processus du jeu démarre à l'état suspendu. Utilisez [WdResumeRemoteGame](/fr/reference/remoting/functions/wdresumeremotegame) pour reprendre l'exécution. Cela est utile pour attacher un débogueur avant que le jeu ne commence à s'exécuter.

## Exemples

### Exemple 1 : Lancer un jeu sur un appareil distant

Lance un exécutable de jeu précédemment copié à l'aide des paramètres par défaut (exécution immédiate, racine commune par défaut).

```cpp theme={null}
// LaunchGame.cpp
// Launches a game executable on a remote device.
// Build: Link against wdremoteapi.lib

#include <windows.h>
#include <stdio.h>
#include "WdRemoteIteration.h"

int main()
{
    // TODO: Replace with your remote device IP address or hostname
    const char* remoteDevice = "192.168.1.100";

    // TODO: Replace with the path to your game executable on the remote device.
    // Relative paths resolve against the default common root.
    const char* remotePath = "MyGame\\Binaries\\MyGame.exe";

    uint32_t processId = 0;
    uint32_t threadId  = 0;

    HRESULT hr = WdLaunchRemoteGame(
        remoteDevice,
        remotePath,
        nullptr,       // args — no command-line arguments
        nullptr,       // launchOptions — defaults to Immediate mode, default common root
        &processId,
        &threadId);

    if (SUCCEEDED(hr))
    {
        printf("Game launched — PID: %u, TID: %u\n", processId, threadId);
    }
    else
    {
        printf("Launch failed: HRESULT 0x%08X\n", hr);
    }

    return hr;
}
```

### Exemple 2 : Lancer en mode suspendu pour le débogage

Lance le jeu à l'état suspendu afin qu'un débogueur puisse être attaché avant le début de l'exécution. Une fois le débogueur connecté, l'utilisateur appuie sur Entrée pour reprendre le processus.

```cpp theme={null}
// LaunchSuspended.cpp
// Launches a game in suspended mode, waits for debugger attach, then resumes.
// Build: Link against wdremoteapi.lib

#include <windows.h>
#include <stdio.h>
#include "WdRemoteIteration.h"

int main()
{
    const char* remoteDevice = "192.168.1.100";
    const char* remotePath   = "MyGame\\Binaries\\MyGame.exe";

    WdLaunchOptions launchOptions = {};
    launchOptions.launchMode     = WdLaunchMode::Suspended;
    launchOptions.commonRootAlias = nullptr;  // Use default common root

    uint32_t processId = 0;
    uint32_t threadId  = 0;

    HRESULT hr = WdLaunchRemoteGame(
        remoteDevice,
        remotePath,
        "-debug -log",    // Command-line arguments passed to the executable
        &launchOptions,
        &processId,
        &threadId);

    if (FAILED(hr))
    {
        printf("Launch failed: HRESULT 0x%08X\n", hr);
        return hr;
    }

    printf("Game suspended — PID: %u\n", processId);
    printf("Attach your debugger to the remote process, then press Enter to resume...\n");
    getchar();

    hr = WdResumeRemoteGame(remoteDevice);
    if (SUCCEEDED(hr))
    {
        printf("Game resumed.\n");
    }
    else
    {
        printf("Resume failed: HRESULT 0x%08X\n", hr);
    }

    return hr;
}
```

### Exemple 3 : Flux de travail de copie et de lancement

Illustre le cycle d'itération typique : copier les fichiers du jeu sur l'appareil distant, puis lancer l'exécutable. Il s'agit du flux de travail de bout en bout le plus courant pour l'API XBOX PC Remote Iteration.

```cpp theme={null}
// CopyAndLaunch.cpp
// Copies game files to a remote device, then launches the game.
// Build: Link against wdremoteapi.lib

#include <windows.h>
#include <stdio.h>
#include "WdRemoteIteration.h"

int main()
{
    // TODO: Replace these values with your own
    const char* remoteDevice   = "192.168.1.100";
    const char* localBuildPath = "C:\\builds\\MyGame";
    const char* gameFolderName = "MyGame";
    const char* gameExePath    = "MyGame\\Binaries\\MyGame.exe";

    // Step 1: Copy game files to the remote device
    printf("Copying files...\n");
    HRESULT hr = WdRemoteCopy(
        remoteDevice,
        localBuildPath,
        gameFolderName,
        nullptr, nullptr, nullptr, nullptr);

    if (FAILED(hr))
    {
        printf("Copy failed: HRESULT 0x%08X\n", hr);
        return hr;
    }

    // Step 2: Launch the game
    printf("Launching game...\n");
    hr = WdLaunchRemoteGame(
        remoteDevice,
        gameExePath,
        nullptr, nullptr, nullptr, nullptr);

    if (FAILED(hr))
    {
        printf("Launch failed: HRESULT 0x%08X\n", hr);
        return hr;
    }

    printf("Game files copied and launched successfully.\n");
    return 0;
}
```

## Configuration requise

| Exigence | Valeur |
| - | - |
| **En-tête** | WdRemoteIteration.h |
| **Bibliothèque** | wdremoteapi.lib |
| **Système d'exploitation pris en charge** | Windows 11 et versions ultérieures |
| **Architectures prises en charge** | x64, ARM64 |

## Voir aussi

* [WdResumeRemoteGame](/fr/reference/remoting/functions/wdresumeremotegame)
* [WdTerminateRemoteGame](/fr/reference/remoting/functions/wdterminateremotegame)
* [WdLaunchOptions](/fr/reference/remoting/structs/wdlaunchoptions)
* [WdLaunchMode](/fr/reference/remoting/enums/wdlaunchmode)
* [Codes d'erreur de l'API XBOX PC Remote Iteration](/fr/reference/remoting/error-codes)
* [API XBOX PC Remote Iteration](/fr/reference/remoting/remoteiteration_members)


## Related topics

- [WdLaunchMode](/fr/reference/remoting/enums/wdlaunchmode.md)
- [WdLaunchOptions](/fr/reference/remoting/structs/wdlaunchoptions.md)
- [WdResumeRemoteGame](/fr/reference/remoting/functions/wdresumeremotegame.md)
- [WdTerminateRemoteGame](/fr/reference/remoting/functions/wdterminateremotegame.md)
- [WdRegisterRemoteXboxGame](/fr/reference/remoting/functions/wdregisterremotexboxgame.md)