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

# Démarrage rapide (Windows) - Configuration du SDK Core

> Ajoutez le SDK unifié PlayFab à un projet Windows, initialisez Core et authentifiez un joueur avec XBOX ou Steam pour obtenir un PFEntityHandle.

Ce guide vous montre comment intégrer le SDK unifié PlayFab à votre projet Windows, initialiser le SDK et authentifier un joueur. C'est la base pour effectuer des appels d'API PlayFab.

## Prérequis

Avant de commencer, suivez les étapes de configuration de [Configuration du démarrage rapide](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-setup) pour configurer votre environnement de développement et votre projet.

## Ce que vous allez accomplir

À la fin de ce démarrage rapide, vous aurez :

* Configuré le SDK unifié PlayFab dans votre projet Windows
* Initialisé le SDK avec votre ID de titre
* Authentifié un joueur à l'aide de XBOX ou de Steam
* Obtenu un handle d'entité pour effectuer des appels d'API
* Nettoyé correctement les ressources

## Dans ce démarrage rapide

1. [Initialiser le SDK](#étape-1-initialiser-le-sdk)
2. [Authentifier un joueur](#étape-2-authentifier-un-joueur)
3. [Nettoyer les ressources](#étape-3-nettoyer-les-ressources)

## Étape 1. Initialiser le SDK

### Inclure les en-têtes requis

Commencez par inclure les en-têtes PlayFab et XBOX Game Runtime nécessaires dans votre projet :

```cpp theme={null}
#include <playfab/core/PFCore.h>
#include <XGameRuntimeInit.h>
```

### Initialiser les services XBOX Gaming Runtime

Le SDK unifié PlayFab nécessite XBOX Game Runtime. Initialisez-le d'abord :

```cpp theme={null}
HRESULT hr = XGameRuntimeInitialize();
if (FAILED(hr))
{
    std::wcerr << L"Failed to initialize Xbox Game Runtime: 0x" << std::hex << hr << std::endl;
    return hr;
}
std::wcout << L"Xbox Game Runtime initialized successfully." << std::endl;
```

### Initialiser PlayFab Core

Initialisez le SDK PlayFab et créez un handle de configuration de service. Remplacez `ABCDEF` par votre véritable ID de titre PlayFab :

```cpp theme={null}
// Initialize PlayFab
HRESULT hr = PFInitialize(nullptr);
if (FAILED(hr))
{
    std::wcerr << L"Failed to initialize PlayFab: 0x" << std::hex << hr << std::endl;
    return hr;
}

// Create service configuration handle
PFServiceConfigHandle serviceConfigHandle{ nullptr };
hr = PFServiceConfigCreateHandle(
    "https://ABCDEF.playfabapi.com", // Replace ABCDEF with your Title ID
    "ABCDEF",                        // Replace ABCDEF with your Title ID
    &serviceConfigHandle);
if (FAILED(hr))
{
    std::wcerr << L"Failed to create service config handle: 0x" << std::hex << hr << std::endl;
    return hr;
}
std::wcout << L"PlayFab initialized successfully." << std::endl;
```

<Tip>
  Vous trouverez votre ID de titre dans le [tableau de bord Game Manager](https://developer.playfab.com), dans les paramètres de votre jeu.
</Tip>

## Étape 2. Authentifier un joueur

PlayFab exige l'authentification du joueur avant tout appel d'API. Le SDK fournit plusieurs méthodes d'authentification en fonction de votre plateforme et de vos besoins.

### Choisir votre méthode d'authentification

#### Option A : connexion avec XBOX (recommandée pour Windows/XBOX)

Utilisez `PFAuthenticationLoginWithXUserAsync` pour vous connecter avec un compte d'utilisateur XBOX. C'est la méthode recommandée pour les applications Windows et XBOX.

```cpp theme={null}
// Assume you have obtained an XUserHandle (userHandle) through XUser APIs
// For details on obtaining XUserHandle, see the Xbox Game Development Kit documentation

PFAuthenticationLoginWithXUserRequest request{};
request.createAccount = true;  // Create account if it doesn't exist
request.user = userHandle;     // XUserHandle obtained from Xbox user APIs

XAsyncBlock async{};
HRESULT hr = PFAuthenticationLoginWithXUserAsync(serviceConfigHandle, &request, &async);
if (FAILED(hr))
{
    std::wcerr << L"Failed to start Xbox login: 0x" << std::hex << hr << std::endl;
    return hr;
}

// Wait for login to complete
hr = XAsyncGetStatus(&async, true); // Blocking wait
if (FAILED(hr))
{
    std::wcerr << L"Xbox login failed: 0x" << std::hex << hr << std::endl;
    return hr;
}

// Get the result
std::vector<char> loginResultBuffer;
PFAuthenticationLoginResult const* loginResult;
size_t bufferSize;
hr = PFAuthenticationLoginWithXUserGetResultSize(&async, &bufferSize);
if (SUCCEEDED(hr))
{
    loginResultBuffer.resize(bufferSize);
    PFEntityHandle entityHandle{ nullptr };
    hr = PFAuthenticationLoginWithXUserGetResult(&async, &entityHandle, 
        loginResultBuffer.size(), loginResultBuffer.data(), &loginResult, nullptr);
    
    if (SUCCEEDED(hr))
    {
        std::wcout << L"Successfully logged in with Xbox. Player ID: " 
                   << loginResult->playFabId << std::endl;
        // entityHandle is now ready for making API calls
    }
}
```

#### Option B : connexion avec Steam

Pour les jeux intégrés à Steam, utilisez `PFAuthenticationLoginWithSteamAsync` avec un ticket d'authentification Steam.

```cpp theme={null}
// Assume you have obtained a Steam ticket through Steam APIs
PFAuthenticationLoginWithSteamRequest request{};
request.createAccount = true;         // Create account if it doesn't exist
request.steamTicket = steamTicket;    // Steam authentication ticket

XAsyncBlock async{};
HRESULT hr = PFAuthenticationLoginWithSteamAsync(serviceConfigHandle, &request, &async);
if (FAILED(hr))
{
    std::wcerr << L"Failed to start Steam login: 0x" << std::hex << hr << std::endl;
    return hr;
}

// Wait for login to complete
hr = XAsyncGetStatus(&async, true);
if (FAILED(hr))
{
    std::wcerr << L"Steam login failed: 0x" << std::hex << hr << std::endl;
    return hr;
}

// Get the result
std::vector<char> loginResultBuffer;
PFAuthenticationLoginResult const* loginResult;
size_t bufferSize;
hr = PFAuthenticationLoginWithSteamGetResultSize(&async, &bufferSize);
if (SUCCEEDED(hr))
{
    loginResultBuffer.resize(bufferSize);
    PFEntityHandle entityHandle{ nullptr };
    hr = PFAuthenticationLoginWithSteamGetResult(&async, &entityHandle, 
        loginResultBuffer.size(), loginResultBuffer.data(), &loginResult, nullptr);
    
    if (SUCCEEDED(hr))
    {
        std::wcout << L"Successfully logged in with Steam. Player ID: " 
                   << loginResult->playFabId << std::endl;
        // entityHandle is now ready for making API calls
    }
}
```

<Note>
  Le `PFEntityHandle` retourné lors de la connexion est requis pour tous les appels d'API PlayFab ultérieurs. Gardez ce handle disponible pendant toute la durée de vie de votre application.
</Note>

## Étape 3. Nettoyer les ressources

Lorsque votre application s'arrête, nettoyez correctement toutes les ressources pour éviter les fuites de mémoire et garantir un arrêt propre :

```cpp theme={null}
// Clean up in reverse order of initialization

// 1. Close the entity handle
if (entityHandle)
{
    PFEntityCloseHandle(entityHandle);
    entityHandle = nullptr;
    std::wcout << L"Entity handle closed." << std::endl;
}

// 2. Close the service config handle
if (serviceConfigHandle)
{
    PFServiceConfigCloseHandle(serviceConfigHandle);
    serviceConfigHandle = nullptr;
    std::wcout << L"Service config handle closed." << std::endl;
}

// 3. Uninitialize PlayFab
XAsyncBlock async{};
HRESULT hr = PFUninitializeAsync(&async);
if (SUCCEEDED(hr))
{
    hr = XAsyncGetStatus(&async, true); // Wait for completion
    if (SUCCEEDED(hr))
    {
        std::wcout << L"PlayFab uninitialized successfully." << std::endl;
    }
    else
    {
        std::wcerr << L"PlayFab uninitialization failed: 0x" << std::hex << hr << std::endl;
    }
}

std::wcout << L"Cleanup complete." << std::endl;
```

<Info>
  Nettoyez toujours les ressources dans l'ordre inverse de l'initialisation afin de garantir un arrêt correct.
</Info>

## Étapes suivantes

Maintenant que vous avez initialisé le SDK et authentifié un joueur, vous êtes prêt à appeler les services PlayFab :

### Effectuer votre premier appel d'API

* **[Appel des services PlayFab](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-services)** : découvrez comment appeler les API PlayFab pour gérer les données des joueurs et utiliser les services de jeu

### Concepts de base

* [Opérations asynchrones](/fr-CA/services/playfab/sdks/unified-sdk/async-model) : comprendre le modèle de programmation asynchrone de PlayFab
* [Gestion de la mémoire](/fr-CA/services/playfab/sdks/unified-sdk/memory-management) : pratiques exemplaires de gestion de la mémoire du SDK
* [Traçage et diagnostics](/fr-CA/services/playfab/sdks/unified-sdk/debug-trace) : déboguer et surveiller votre intégration

### Authentification avancée

* **Authentification multiplateforme** : prenez en charge plusieurs fournisseurs d'authentification
* **Authentification par ID personnalisé** : utilisez votre propre système d'authentification
* **Liaison de comptes** : liez plusieurs méthodes d'authentification à un même compte

### Résolution des problèmes

**Problèmes courants et solutions :**

| Problème | Solution |
| - | - |
| Erreurs d'édition des liens | Vérifiez que tous les fichiers `.lib` requis sont ajoutés à Dépendances supplémentaires |
| Erreurs de DLL à l'exécution | Copiez les fichiers `.dll` requis dans votre répertoire de sortie |
| Échecs d'authentification | Vérifiez votre ID de titre et votre connectivité réseau |
| Échecs d'appels d'API | Activez le traçage pour afficher des informations détaillées sur les erreurs |

## Documentation de référence

* [Référence de l'API du SDK unifié PlayFab](/fr-CA/services/playfab/api-references/c/pfauthentication/pfauthentication_members)
* [Référence de l'API PlayFab Services](/fr-CA/services/playfab/api-references)
* [Documentation du XBOX Game Development Kit](https://docs.microsoft.com/gaming/gdk/)


## Related topics

- [Configuration du démarrage rapide du SDK unifié PlayFab](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-setup.md)
- [Démarrage rapide du SDK Generator](/fr-CA/services/playfab/sdks/sdkgenerator/quickstart.md)
- [Démarrage rapide du SDK Matchmaking](/fr-CA/services/playfab/multiplayer/matchmaking/quickstart-client-sdk.md)
- [Démarrage rapide du SDK Lobby](/fr-CA/services/playfab/multiplayer/lobby/lobby-getting-started.md)
- [Démarrage rapide (Windows) - Party et Multiplayer](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-windows-party.md)