> ## 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. # Configuración del proyecto con GSDK > Agregue y configure el complemento GSDK de PlayFab en un proyecto ThirdPersonMP de Unreal Engine para que la compilación del servidor dedicado pueda hospedarse en PlayFab Multiplayer Servers. # Adición del GSDK al proyecto En este artículo se describe cómo actualizar un proyecto existente para que pueda hospedarse en PlayFab Multiplayer Servers (MPS). El proceso implica agregar y configurar el GSDK de PlayFab en un proyecto de Unreal. Las instrucciones aquí presentadas están escritas usando el proyecto de plantilla ThirdPersonMP de Unreal. Tenga en cuenta que su proyecto de Unreal debe tener las siguientes capacidades: * Redes * Multijugador * Servidor de juego dedicado De lo contrario, deberá volver a la guía de [configuración del proyecto de ejemplo](/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-setup) para configurar su proyecto como un juego multijugador habilitado para red, con capacidades de servidor dedicado. ## Objetivos Agregaremos y configuraremos el GSDK de Unreal de PlayFab en su proyecto y lo probaremos localmente para verificar que se espera que funcione en PlayFab Multiplayer Services. ## Requisitos * Descargue Visual Studio. La [versión Community](https://visualstudio.microsoft.com/vs/community/) es gratuita. * Cargas de trabajo necesarias: desarrollo de escritorio de .NET y desarrollo para el escritorio con C++ * Descargue el código fuente de Unreal Engine. Para obtener instrucciones, consulte [Descarga del código fuente de Unreal Engine (externo)](https://docs.unrealengine.com/ProgrammingAndScripting/ProgrammingWithCPP/DownloadingSourceCode/). * Un [proyecto de ejemplo ThirdPersonMP](/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-setup) completado, o un proyecto con capacidades similares * [Complemento GSDK de Unreal de PlayFab](https://github.com/PlayFab/gsdk/tree/master/UnrealPlugin) * \[Opcional] [Complemento de PlayFab en el Marketplace](https://www.unrealengine.com/marketplace/product/playfab-sdk) o la [versión de código fuente en GitHub](https://github.com/PlayFab/UnrealMarketplacePlugin). Este complemento no es necesario para el GSDK, pero sí lo es para muchos servicios de PlayFab, incluido el inicio de sesión. ## Implementación en C++ ### Adición del complemento al proyecto Siga estos pasos para agregar el GSDK de Unreal a su proyecto: * Vaya a su proyecto de Unreal * Abra el Explorador de archivos y cree una carpeta **Plugins** en el directorio raíz de su juego. En la carpeta Plugins, cree una carpeta llamada **PlayFabGSDK.** * Vaya a **\{depot}\GSDK\gsdk\UnrealPlugin**. Arrastre todos los archivos de la carpeta **UnrealPlugin** a la carpeta **Plugins/PlayFabGSDK**. * Por último, abra el archivo `{ProjectName}.uproject` en el editor de texto de su elección. En la matriz de complementos, agregue el complemento "PlayFabGSDK". Vea el ejemplo siguiente: ```json theme={null} { "FileVersion": 3, "EngineAssociation": "{YourEngineVersion}", "Category": "", "Description": "", "Modules": [ { "Name": "{ProjectName}", "Type": "Runtime", "LoadingPhase": "Default", "AdditionalDependencies": [ "Engine" ] } ], "Plugins": [ // Add this if it doesn't exist { // Add this "Name": "PlayFabGSDK", // Add this "Enabled": true // Add this } // Add this ] // Add this if it doesn't exist } ``` ### Inclusión del complemento en sus módulos * Actualice el archivo \{ProjectName}.Build.cs para agregar "PlayFabGSDK" a la lista PublicDependencyModuleNames.AddRange(); de la siguiente manera: ```csharp theme={null} PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "PlayFabGSDK" }); ``` * Haga clic con el botón derecho en el archivo `{ProjectName}.uproject` y seleccione la opción **Switch Unreal Engine version**, que es la forma de comprobar rápidamente qué versión de Unreal Engine está usando actualmente. Debería aparecer la ventana emergente que se muestra a continuación. Si ya ve que la versión de Unreal Engine es una compilación de código fuente, no necesita cambiar nada, así que haga clic en Cancel. Si la versión de Unreal no es actualmente la compilación de código fuente, selecciónela en la lista desplegable y luego haga clic en OK. imagen que muestra una ventana que dice "Select Unreal Engine Version" * Haga clic de nuevo con el botón derecho en el archivo `{ProjectName}.uproject` y seleccione "Generate Visual Studio Project Files". * Por último, compile el proyecto en Visual Studio e inicie el editor seleccionando la configuración Development Editor. imagen que muestra Visual Studio con la opción de compilar en modo Development Editor ### Configuración del proyecto Una vez que su proyecto haya habilitado el modo de servidor, tendrá un archivo \{ProjectName}Server.Target.cs. El resultado debería ser similar a: ```csharp theme={null} public class {ProjectName}ServerTarget : TargetRules { public {ProjectName}ServerTarget( TargetInfo Target) : base(Target) { Type = TargetType.Server; DefaultBuildSettings = BuildSettingsVersion.V2; ExtraModuleNames.AddRange( new string[] { "{ProjectName}" } ); // You may have additional configuration based on your server needs } } ``` Para las compilaciones de Windows, es posible que necesite agregar estas configuraciones opcionales: ```csharp theme={null} DisablePlugins.Add("WMFMediaPlayer"); DisablePlugins.Add("AsyncLoadingScreen"); //if you are using this plugin DisablePlugins.Add("WindowsMoviePlayer"); DisablePlugins.Add("MediaFoundationMediaPlayer"); ``` NOTA: Estas configuraciones no son válidas para una compilación de servidor Linux. ### Creación/actualización de la clase GameInstance #### Creación de una clase GameInstance Si está creando un proyecto desde cero y aún no tiene una clase GameInstance, siga primero estas instrucciones de ejemplo para crear una clase GameInstance. Si está usando un proyecto que ya tiene una clase GameInstance (por ejemplo, ShooterGame de la biblioteca de ejemplos de Unreal), pase a la sección titulada ***Modificación de la clase GameInstance***. *** En el editor de Unreal: * Seleccione **Files** * Seleccione **Create a new C++ class** * Seleccione **Show all classes** * Escriba `GameInstance` en el campo de búsqueda * Al seleccionarla directamente como se describe, todo debería generarse correctamente y luego podrá agregar las funciones que detallamos a continuación * Cierre Unreal y vuelva a ejecutar **Generate project files** en modo de compilación de código fuente * Con Visual Studio, abra esos archivos recién creados y siga las instrucciones para modificar la clase GameInstance. #### Modificación de la clase GameInstance Según la configuración de su proyecto, puede modificar la clase GameInstance usando C++ o Blueprints. A continuación se presentan ambas formas; debe seleccionar la que se adapte a sus necesidades. #### Implementación en C++ Localice su clase GameInstance, que probablemente se llame algo similar a \{ProjectName}GameInstance o MyGameInstance. A partir de ahora, su clase GameInstance se denotará como \[YourGameInstanceClassName]. ##### Modificación del archivo de encabezado de GameInstance Primero, compruebe las instrucciones include y asegúrese de que las siguientes estén incluidas en el archivo de encabezado de su clase GameInstance (\[YourGameInstanceClassName].h): ```cpp theme={null} #include "CoreMinimal.h" #include "Engine/GameInstance.h" #include "MyGameInstance.generated.h" ``` \[Opcional] Con el código siguiente, el usuario puede introducir un canal de registro específico para la GameInstance. Como alternativa, registrar con LogTemp es suficiente. ```cpp theme={null} DECLARE_LOG_CATEGORY_EXTERN(LogPlayFabGSDKGameInstance, Log, All); ``` A continuación, agregue las siguientes declaraciones a la sección pública: (si ya tiene una función Init(), no es necesario incluir otra declaración) ```cpp theme={null} public: virtual void Init() override; virtual void OnStart() override; ``` A continuación, agregue las siguientes declaraciones a la sección protegida de métodos: ```cpp theme={null} protected: UFUNCTION() void OnGSDKShutdown(); UFUNCTION() bool OnGSDKHealthCheck(); UFUNCTION() void OnGSDKServerActive(); UFUNCTION() void OnGSDKReadyForPlayers(); }; ``` ##### Modificación del archivo CPP de GameInstance A continuación, localice el archivo \[YourGameInstanceClassName].cpp. Asegúrese de que se incluye lo siguiente: ```cpp theme={null} #include "[YourGameInstanceClassName].h" #include "PlayfabGSDK.h" #include "GSDKUtils.h" ``` Si se ha introducido el canal de registro personalizado en el archivo de encabezado, entonces es necesario el siguiente código: ```cpp theme={null} DEFINE_LOG_CATEGORY(LogPlayFabGSDKGameInstance); ``` A continuación, localice su función Init(). Si aún ***no*** tiene una función Init(), agregue la función de la siguiente manera: ###### Creación de la función Init() ```cpp theme={null} void U[YourGameInstanceClassName]::Init() { FOnGSDKShutdown_Dyn OnGSDKShutdown; OnGSDKShutdown.BindDynamic(this, &UMyGameInstance::OnGSDKShutdown); FOnGSDKHealthCheck_Dyn OnGSDKHealthCheck; OnGSDKHealthCheck.BindDynamic(this, &UMyGameInstance::OnGSDKHealthCheck); FOnGSDKServerActive_Dyn OnGSDKServerActive; OnGSDKServerActive.BindDynamic(this, &UThirdPersonGameInstance::OnGSDKServerActive); FOnGSDKReadyForPlayers_Dyn OnGSDKReadyForPlayers; OnGSDKReadyForPlayers.BindDynamic(this, &UThirdPersonGameInstance::OnGSDKReadyForPlayers); UGSDKUtils::RegisterGSDKShutdownDelegate(OnGSDKShutdown); UGSDKUtils::RegisterGSDKHealthCheckDelegate(OnGSDKHealthCheck); UGSDKUtils::RegisterGSDKServerActiveDelegate(OnGSDKServerActive); UGSDKUtils::RegisterGSDKReadyForPlayersDelegate(OnGSDKReadyForPlayers); } ``` *** Si ya **tenía** una función Init(), compruebe en el archivo `[YourGameInstanceClassName].cpp` si tiene una variable que indique si la instancia es para un servidor dedicado. **Si puede encontrar esta variable**, agregue lo siguiente al final de su función Init(): ###### Modificación de una función Init() existente ```cpp theme={null} if (IsDedicatedServerInstance() == true) { FOnGSDKShutdown_Dyn OnGsdkShutdown; OnGsdkShutdown.BindDynamic(this, &UShooterGameInstance::OnGSDKShutdown); FOnGSDKHealthCheck_Dyn OnGsdkHealthCheck; OnGsdkHealthCheck.BindDynamic(this, &UShooterGameInstance::OnGSDKHealthCheck); FOnGSDKServerActive_Dyn OnGSDKServerActive; OnGSDKServerActive.BindDynamic(this, &UShooterGameInstance::OnGSDKServerActive); FOnGSDKReadyForPlayers_Dyn OnGSDKReadyForPlayers; OnGSDKReadyForPlayers.BindDynamic(this, &UShooterGameInstance::OnGSDKReadyForPlayers); UGSDKUtils::RegisterGSDKShutdownDelegate(OnGsdkShutdown); UGSDKUtils::RegisterGSDKHealthCheckDelegate(OnGsdkHealthCheck); UGSDKUtils::RegisterGSDKServerActiveDelegate(OnGSDKServerActive); UGSDKUtils::RegisterGSDKReadyForPlayers(OnGSDKReadyForPlayers); } ``` **Complete la función Init()** llamando a la siguiente función que configura el puerto predeterminado para MPS. ```cpp theme={null} #if UE_SERVER UGSDKUtils::SetDefaultServerHostPort(); #endif ``` *** Por último, agregue estas implementaciones de métodos al final del archivo `[YourGameInstanceClassName].cpp`: ```cpp theme={null} void UMyGameInstance::OnStart() { UE_LOG(LogPlayFabGSDKGameInstance, Warning, TEXT("Reached onStart!")); UGSDKUtils::ReadyForPlayers(); } void UMyGameInstance::OnGSDKShutdown() { UE_LOG(LogPlayFabGSDKGameInstance, Warning, TEXT("Shutdown!")); FPlatformMisc::RequestExit(false); } bool UMyGameInstance::OnGSDKHealthCheck() { // Uncomment the next line if you want your server to log something at every heartbeat for sanity check. /* UE_LOG(LogPlayFabGSDKGameInstance, Warning, TEXT("Healthy!")); */ return true; } void UThirdPersonGameInstance::OnGSDKServerActive() { /** * Server is transitioning to an active state. * Optional: Add in the implementation any code that is needed for the game server when * this transition occurs. */ UE_LOG(LogPlayFabGSDKGameInstance, Warning, TEXT("Active!")); } void UThirdPersonGameInstance::OnGSDKReadyForPlayers() { /** * Server is transitioning to a StandBy state. Game initialization is complete and the game * is ready to accept players. * Optional: Add in the implementation any code that is needed for the game server before * initialization completes. */ UE_LOG(LogPlayFabGSDKGameInstance, Warning, TEXT("Finished Initialization - Moving to StandBy!")); } ``` #### Implementación con Blueprint Esta parte solo es necesaria si ha decidido continuar con la implementación con Blueprint y no con la implementación puramente en C++. * Observe la ventana Content Browser en el editor de Unreal * Elija o cree una carpeta para contener los nuevos Blueprints * Haga clic con el botón derecho y cree una clase de Blueprint * En el menú desplegable All classes, busque su clase GameInstance * En este ejemplo, el Blueprint se llama "MyGameInstance" * Haga doble clic en el Blueprint * En el lado izquierdo, sitúe el puntero sobre el campo de funciones y seleccione el menú desplegable Override * Seleccione la función Init * Haga clic con el botón derecho en el gráfico y agregue todas las funciones de registro del GSDK * Para GSDK Shutdown y Maintenance Delegate, arrastre una línea desde el cuadrado rojo y seleccione "Add Custom Event" * Para "Register GSDK Health Check Delegate", seleccione "Create Event" en los "Event Dispatchers". * Adición de la comprobación de estado del GSDK de PlayFab * En el menú desplegable del nuevo nodo, "Create matching function". **Esto es importante, ya que el GSDK Health Check Delegate tiene un valor devuelto.** * Registro de la comprobación de estado del GSDK de PlayFab * En la función, asegúrese de que el valor booleano devuelto esté marcado. * Función de comprobación de estado del GSDK de PlayFab * No olvide conectar todos los nodos al nodo Event Init. * Al final, agregue el nodo "ReadyforPlayers" para poder reaccionar a la señal de listo de PlayFab. * Además, no olvide agregar el nodo "SetDefaultServerHostPort" para conectarse al puerto que el GSDK espera. * Para cada función/nodo del GSDK que desee agregar en su Blueprint, puede verificar que existe escribiendo las primeras letras del nombre de la función en su nuevo nodo y viendo que la función del GSDK esperada aparece en las sugerencias. * Al final, su Blueprint debería ser similar al que se presenta en la imagen siguiente. * Gráfico completo del GSDK de PlayFab ## Establecimiento de la clase GameInstance Después de crear una clase GameInstance personalizada que se integra con el gsdk, debe configurar su proyecto para que use realmente esta clase GameInstance recién creada. Hay dos formas de hacerlo: mediante el editor de Unreal Engine o editando DefaultEngine.ini directamente. ### En el editor de Unreal En el editor, la GameInstance predeterminada se puede establecer a través de la interfaz de usuario del editor. En el editor, vaya a **Edit** -> **Project Settings**. En la ventana abierta, vaya a **Maps\&Modes** en el lado izquierdo. Desplácese hasta la parte inferior y podrá establecer la opción `GameInstanceClass` directamente en su nueva clase GameInstance (evite errores tipográficos; debe ser una coincidencia exacta). ### En DefaultEngine.ini O puede actualizar el archivo DefaultEngine.ini y agregar las siguientes líneas: ```ini theme={null} [/Script/EngineSettings.GameMapsSettings] GameInstanceClass=/Script/{ProjectName}.MyGameInstance ``` ## Inclusión de los requisitos previos para el servidor dedicado de Windows Hay dos formas de incluir los requisitos previos locales de la aplicación: mediante el editor de Unreal Engine o editando DefaultGame.ini. ### En el editor de Unreal En el editor, vaya a Edit -> Project Settings. En la ventana abierta, vaya a Packaging en el lado izquierdo. Desplácese hasta la parte inferior de la lista y marque "Include app-local prerequisites". ### En DefaultGame.ini O puede actualizar DefaultGame.ini con el siguiente código: ```ini theme={null} [/Script/UnrealEd.ProjectPackagingSettings] IncludeAppLocalPrerequisites=True ``` Si la categoría ya existe en su DefaultGame.ini, simplemente agréguele la segunda línea. Esta configuración garantiza que todas las dependencias locales de la aplicación también se distribuyan con el proyecto. Si usa integración continua (CI), podría agregarlo a su configuración para activar esta marca solo al compilar un servidor dedicado, de modo que los archivos dll de requisitos previos solo se agreguen si se trata de una compilación de servidor dedicado. ## Pasos siguientes Ya está listo para [compilar su proyecto](/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/building-the-third-person-mp-example-project) en su máquina local. Como alternativa, puede volver a la guía principal del [complemento GSDK de Unreal](/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk#unreal-project-build-configurations). ## Related topics - [Pruebas y depuración del proyecto de GSDK](/es/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-local-deployment-and-debugging.md) - [Implementación en la nube del proyecto con GSDK](/es/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-cloud-deployment.md) - [Creación del proyecto de ejemplo de GSDK](/es/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-setup.md) - [Información general del complemento GSDK de Unreal de PlayFab](/es/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/index.md) - [Configuración del inicio rápido del SDK unificado de PlayFab](/es/services/playfab/sdks/unified-sdk/quickstart-setup.md)