> ## 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\***

Le nom d'hôte ou l'adresse IP de l'appareil distant (p. ex., `"192.168.1.100"` ou `"MyDevKit"`).

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

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

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

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

`_In_opt_ launchOptions`\
Type : **[WdLaunchOptions](/fr-CA/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 requis.

`_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 requis.

### Valeur de retour

Type : **HRESULT**

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

#### Codes d'erreur

| Code | Valeur | Description | Cause première | Dépannage |
| - | - | - | - | - |
| E\_GAMEFILEPATHNOTEXIST | 0x8C114010 | Le chemin du fichier du jeu n'existe pas. | Le chemin de l'exécutable ou du package du jeu fourni est non valide ou inaccessible 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 lien 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 du pare-feu et la disponibilité du service sur l'ordinateur distant; Vérifiez la visibilité entre les appareils, qui devraient pouvoir se joindre par ping; Relancez 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 au moyen du DNS ou de 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 (p. ex., format IP incorrect, mauvaise adresse IP ou protocole non pris en charge). | Confirmez que l'adresse IP est la bonne; 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 été lancée avant la fin du processus de jumelage | Terminez correctement le processus de jumelage par NIP; Exécutez de 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 été lancée avant la fin du processus de jumelage | Terminez correctement le processus de jumelage par NIP; Exécutez de 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 requiert des autorisations de niveau administrateur | Exécutez de nouveau 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 y met fin automatiquement et le relance. Il est possible de mettre fin au jeu existant au moyen de [WdTerminateRemoteGame](/fr-CA/reference/remoting/functions/wdterminateremotegame) avant d'en lancer un nouveau.

Lorsqu'il est lancé avec [WdLaunchMode::Suspended](/fr-CA/reference/remoting/enums/wdlaunchmode), le processus du jeu démarre dans un état suspendu. Utilisez [WdResumeRemoteGame](/fr-CA/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 copié précédemment en utilisant les 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 dans un é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-CA/reference/remoting/functions/wdresumeremotegame)
* [WdTerminateRemoteGame](/fr-CA/reference/remoting/functions/wdterminateremotegame)
* [WdLaunchOptions](/fr-CA/reference/remoting/structs/wdlaunchoptions)
* [WdLaunchMode](/fr-CA/reference/remoting/enums/wdlaunchmode)
* [Codes d'erreur de l'API XBOX PC Remote Iteration](/fr-CA/reference/remoting/error-codes)
* [API XBOX PC Remote Iteration](/fr-CA/reference/remoting/remoteiteration_members)


## Related topics

- [WdLaunchRemoteGame](/ko/reference/remoting/functions/wdlaunchremotegame.md)
- [WdLaunchMode](/ko/reference/remoting/enums/wdlaunchmode.md)