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

# Inicio rápido (Windows): configuración del SDK de Core

> Agregue el SDK unificado de PlayFab a un proyecto de Windows, inicialice Core y autentique a un jugador con XBOX o Steam para obtener un PFEntityHandle.

Esta guía muestra cómo integrar el SDK unificado de PlayFab en su proyecto de Windows, inicializar el SDK y autenticar a un jugador. Esta es la base para realizar llamadas a la API de PlayFab.

## Requisitos previos

Antes de empezar, complete los pasos de configuración en [Configuración del inicio rápido](/services/playfab/sdks/unified-sdk/quickstart-setup) para configurar su entorno de desarrollo y su proyecto.

## Qué logrará

Al final de este inicio rápido, habrá:

* Configurado el SDK unificado de PlayFab en su proyecto de Windows
* Inicializado el SDK con su Title ID
* Autenticado a un jugador con XBOX o Steam
* Obtenido un identificador de entidad para realizar llamadas a la API
* Limpiado los recursos correctamente

## En este inicio rápido

1. [Inicializar el SDK](#step-1-initialize-the-sdk)
2. [Autenticar a un jugador](#step-2-authenticate-a-player)
3. [Limpiar los recursos](#step-3-clean-up-resources)

## Paso 1: inicializar el SDK

### Incluir los encabezados necesarios

Empiece por incluir los encabezados necesarios de PlayFab y XBOX Game Runtime en su proyecto:

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

### Inicializar los servicios de XBOX Gaming Runtime

El SDK unificado de PlayFab requiere XBOX Game Runtime. Inicialícelo primero:

```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;
```

### Inicializar PlayFab Core

Inicialice el SDK de PlayFab y cree un identificador de configuración del servicio. Reemplace `ABCDEF` por su Title ID real de 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>
  Puede encontrar su Title ID en el [panel de Game Manager](https://developer.playfab.com), en la configuración de su juego.
</Tip>

## Paso 2: autenticar a un jugador

PlayFab requiere la autenticación del jugador antes de realizar llamadas a la API. El SDK proporciona varios métodos de autenticación según su plataforma y sus requisitos.

### Elegir el método de autenticación

#### Opción A: iniciar sesión con XBOX (recomendado para Windows/XBOX)

Use `PFAuthenticationLoginWithXUserAsync` para iniciar sesión con una cuenta de usuario de XBOX. Este es el método recomendado para aplicaciones de Windows y 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
    }
}
```

#### Opción B: iniciar sesión con Steam

Para juegos integrados con Steam, use `PFAuthenticationLoginWithSteamAsync` con un ticket de autenticación de 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>
  El `PFEntityHandle` que devuelve el inicio de sesión es necesario para todas las llamadas posteriores a la API de PlayFab. Mantenga este identificador disponible durante toda la vida de su aplicación.
</Note>

## Paso 3: limpiar los recursos

Cuando su aplicación se cierre, limpie correctamente todos los recursos para evitar pérdidas de memoria y garantizar una finalización controlada:

```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>
  Limpie siempre los recursos en el orden inverso al de la inicialización para garantizar un cierre correcto.
</Info>

## Pasos siguientes

Ahora que ha inicializado el SDK y ha autenticado a un jugador, está listo para empezar a llamar a los servicios de PlayFab:

### Realice su primera llamada a la API

* **[Llamada a PlayFab Services](/services/playfab/sdks/unified-sdk/quickstart-services)**: aprenda a llamar a las API de PlayFab para administrar los datos de los jugadores y usar los servicios del juego

### Conceptos básicos

* [Operaciones asincrónicas](/services/playfab/sdks/unified-sdk/async-model): comprensión del modelo de programación asincrónica de PlayFab
* [Administración de memoria](/services/playfab/sdks/unified-sdk/memory-management): procedimientos recomendados para administrar la memoria del SDK
* [Seguimiento y diagnóstico](/services/playfab/sdks/unified-sdk/debug-trace): depuración y supervisión de su integración

### Autenticación avanzada

* **Autenticación multiplataforma**: admita varios proveedores de autenticación
* **Autenticación con Custom ID**: use su propio sistema de autenticación
* **Vinculación de cuentas**: vincule varios métodos de autenticación a una sola cuenta

### Solución de problemas

**Problemas comunes y soluciones:**

| Problema                              | Solución                                                                                        |
| ------------------------------------- | ----------------------------------------------------------------------------------------------- |
| Errores de vinculación                | Asegúrese de que todos los archivos `.lib` necesarios estén agregados a Additional Dependencies |
| Errores de DLL en tiempo de ejecución | Copie los archivos `.dll` necesarios a su directorio de salida                                  |
| Errores de autenticación              | Verifique su Title ID y compruebe la conectividad de red                                        |
| Errores en las llamadas a la API      | Habilite el seguimiento para ver información de error detallada                                 |

## Documentación de referencia

* [Referencia de la API del SDK unificado de PlayFab](/services/playfab/api-references/c/pfauthentication/pfauthentication_members)
* [Referencia de la API de PlayFab Services](/services/playfab/api-references)
* [Documentación del XBOX Game Development Kit](https://docs.microsoft.com/gaming/gdk/)


## Related topics

- [Configuración del inicio rápido del SDK unificado de PlayFab](/es/services/playfab/sdks/unified-sdk/quickstart-setup.md)
- [Inicio rápido del SDK de Matchmaking](/es/services/playfab/multiplayer/matchmaking/quickstart-client-sdk.md)
- [Inicio rápido (Windows): llamada a PlayFab Services](/es/services/playfab/sdks/unified-sdk/quickstart-services.md)
- [Inicio rápido de C++ para Windows](/es/services/playfab/sdks/playfab-cpp/quickstart-windows.md)
- [Inicio rápido (Windows): Party y Multiplayer](/es/services/playfab/sdks/unified-sdk/quickstart-windows-party.md)