> ## 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. # Configuração do GSDK no projeto > Adicione e configure o plug-in PlayFab GSDK em um projeto ThirdPersonMP do Unreal Engine para que o build do servidor dedicado possa ser hospedado no PlayFab Multiplayer Servers. # Adicionar o GSDK ao projeto Este artigo descreve como atualizar um projeto existente para que ele possa ser hospedado no PlayFab Multiplayer Servers (MPS). O processo envolve adicionar e configurar o PlayFab GSDK em um projeto do Unreal. As instruções aqui foram escritas usando o projeto modelo ThirdPersonMP do Unreal. Observe que seu projeto do Unreal deve ter os seguintes recursos: * Rede * Multijogador * Servidor de jogo dedicado Caso contrário, você precisará retornar ao guia [Configuração do projeto de exemplo](/pt-BR/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-setup) para configurar seu projeto como um jogo multijogador habilitado para rede, com recursos de servidor dedicado. ## Objetivos Adicionaremos e configuraremos o PlayFab Unreal GSDK no seu projeto e o testaremos localmente para verificar se ele funciona conforme o esperado no PlayFab Multiplayer Services. ## Requisitos * Baixe o Visual Studio. A [versão Community](https://visualstudio.microsoft.com/vs/community/) é gratuita. * Cargas de trabalho necessárias: Desenvolvimento para desktop com .NET e Desenvolvimento para desktop com C++ * Baixe o código-fonte do Unreal Engine. Para obter instruções, consulte [Baixando o código-fonte do Unreal Engine (externo)](https://docs.unrealengine.com/ProgrammingAndScripting/ProgrammingWithCPP/DownloadingSourceCode/). * Um [projeto de exemplo ThirdPersonMP](/pt-BR/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-setup) concluído ou um projeto com recursos semelhantes * [Plug-in PlayFab Unreal GSDK](https://github.com/PlayFab/gsdk/tree/master/UnrealPlugin) * \[Opcional] [Plug-in do PlayFab no Marketplace](https://www.unrealengine.com/marketplace/product/playfab-sdk) ou a [versão de código-fonte no GitHub](https://github.com/PlayFab/UnrealMarketplacePlugin). Esse plug-in não é necessário para o GSDK, mas é necessário para muitos serviços do PlayFab, incluindo o logon. ## Implementação em C++ ### Adicionar o plug-in ao projeto Siga estas etapas para adicionar o Unreal GSDK ao seu projeto: * Vá para o seu projeto do Unreal * Abra o Explorador de Arquivos e crie uma pasta **Plugins** no diretório raiz do seu jogo. Na pasta Plugins, crie uma pasta chamada **PlayFabGSDK.** * Vá para **\{depot}\GSDK\gsdk\UnrealPlugin**. Arraste todos os arquivos da pasta **UnrealPlugin** para a pasta **Plugins/PlayFabGSDK**. * Por fim, abra o arquivo `{ProjectName}.uproject` em um editor de texto de sua escolha. Na matriz de plug-ins, adicione o plug-in "PlayFabGSDK". Veja o exemplo abaixo: ```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 } ``` ### Incluir o plug-in nos seus módulos * Atualize o arquivo \{ProjectName}.Build.cs para adicionar "PlayFabGSDK" à lista PublicDependencyModuleNames.AddRange(); da seguinte forma: ```csharp theme={null} PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "PlayFabGSDK" }); ``` * Clique com o botão direito do mouse no arquivo `{ProjectName}.uproject` e selecione a opção **Switch Unreal Engine version**, que é como você pode verificar rapidamente qual versão do Unreal Engine está usando no momento. O pop-up mostrado abaixo deverá aparecer. Se você já vir que a versão do Unreal Engine é o build a partir do código-fonte, não precisa alterar nada; então, clique em Cancel. Se a versão do Unreal não for o build a partir do código-fonte, selecione-o na lista suspensa e clique em OK. imagem mostrando uma janela que diz "Select Unreal Engine Version" * Clique com o botão direito do mouse no arquivo `{ProjectName}.uproject` novamente e selecione "Generate Visual Studio Project Files". * Por fim, crie o projeto no Visual Studio e inicie o Editor selecionando a configuração Development Editor. imagem mostrando o Visual Studio com a opção de criar no modo Development Editor ### Configuração do projeto Depois que seu projeto tiver o modo de servidor habilitado, você terá um arquivo \{ProjectName}Server.Target.cs. O resultado deve ser semelhante 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 builds Windows, talvez seja necessário adicionar estas configurações opcionais: ```csharp theme={null} DisablePlugins.Add("WMFMediaPlayer"); DisablePlugins.Add("AsyncLoadingScreen"); //if you are using this plugin DisablePlugins.Add("WindowsMoviePlayer"); DisablePlugins.Add("MediaFoundationMediaPlayer"); ``` OBSERVAÇÃO: essas configurações são inválidas para um build de servidor Linux. ### Criar/atualizar a classe GameInstance #### Criar uma classe GameInstance Se você estiver criando um projeto do zero e ainda não tiver uma classe GameInstance, siga primeiro estas instruções de exemplo para criar uma classe GameInstance. Se estiver usando um projeto que já tem uma classe GameInstance (por exemplo, ShooterGame da biblioteca de exemplos do Unreal), passe para a seção intitulada ***Modificar a classe GameInstance***. *** No Unreal Editor: * Selecione **Files** * Selecione **Create a new C++ class** * Selecione **Show all classes** * Digite `GameInstance` no campo de pesquisa * Ao selecioná-la diretamente, conforme descrito, tudo deverá ser gerado corretamente e, em seguida, você poderá adicionar as funções detalhadas abaixo * Feche o Unreal e execute **Generate project files** novamente no modo de build a partir do código-fonte * Usando o Visual Studio, abra esses arquivos recém-criados e siga as instruções para modificar a classe GameInstance. #### Modificar a classe GameInstance Dependendo da configuração do seu projeto, você pode modificar a classe GameInstance usando C++ ou Blueprints. As duas formas são apresentadas abaixo; selecione a que atende às suas necessidades. #### Implementação em C++ Localize sua classe GameInstance, que provavelmente tem um nome semelhante a \{ProjectName}GameInstance ou MyGameInstance. De agora em diante, sua classe GameInstance será indicada como \[YourGameInstanceClassName]. ##### Modificar o arquivo de cabeçalho da GameInstance Primeiro, verifique as instruções include e garanta que os seguintes itens estejam incluídos no arquivo de cabeçalho da sua classe GameInstance (\[YourGameInstanceClassName].h): ```cpp theme={null} #include "CoreMinimal.h" #include "Engine/GameInstance.h" #include "MyGameInstance.generated.h" ``` \[Opcional] Com o código a seguir, o usuário pode introduzir um canal de log específico para a GameInstance. Como alternativa, registrar logs com LogTemp é suficiente. ```cpp theme={null} DECLARE_LOG_CATEGORY_EXTERN(LogPlayFabGSDKGameInstance, Log, All); ``` Em seguida, adicione as seguintes declarações à seção public: (se você já tiver uma função Init(), não é necessário incluir outra declaração) ```cpp theme={null} public: virtual void Init() override; virtual void OnStart() override; ``` Em seguida, adicione as seguintes declarações à seção protected de métodos: ```cpp theme={null} protected: UFUNCTION() void OnGSDKShutdown(); UFUNCTION() bool OnGSDKHealthCheck(); UFUNCTION() void OnGSDKServerActive(); UFUNCTION() void OnGSDKReadyForPlayers(); }; ``` ##### Modificar o arquivo CPP da GameInstance Em seguida, localize o arquivo \[YourGameInstanceClassName].cpp. Verifique se os seguintes itens estão incluídos: ```cpp theme={null} #include "[YourGameInstanceClassName].h" #include "PlayfabGSDK.h" #include "GSDKUtils.h" ``` Se o canal de log personalizado tiver sido introduzido no arquivo de cabeçalho, o código a seguir será necessário: ```cpp theme={null} DEFINE_LOG_CATEGORY(LogPlayFabGSDKGameInstance); ``` Em seguida, localize sua função Init(). Se você ***não*** tiver uma função Init() ainda, adicione a função da seguinte forma: ###### Criar a função 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); } ``` *** Se você **já tinha** uma função Init(), verifique no arquivo `[YourGameInstanceClassName].cpp` se há uma variável que indica se a instância é de um servidor dedicado. **Se você encontrar essa variável**, adicione o seguinte ao final da sua função Init(): ###### Modificar a função 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); } ``` **Conclua a função Init()** chamando a função a seguir, que configura a porta padrão para o MPS. ```cpp theme={null} #if UE_SERVER UGSDKUtils::SetDefaultServerHostPort(); #endif ``` *** Por fim, adicione estas implementações de método ao final do arquivo `[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!")); } ``` #### Implementação em Blueprint Esta parte só é necessária se você decidiu prosseguir com a implementação em Blueprint, e não com a implementação pura em C++. * Observe a janela Content Browser no Unreal Editor * Escolha ou crie uma pasta para conter os novos Blueprints * Clique com o botão direito do mouse e crie uma classe Blueprint * No menu suspenso All classes, encontre sua classe GameInstance * Neste exemplo, o blueprint se chama "MyGameInstance" * Clique duas vezes no blueprint * No lado esquerdo, passe o mouse sobre o campo de funções e selecione o menu suspenso Override * Selecione a função Init * Clique com o botão direito do mouse no gráfico e adicione todas as funções de registro do GSDK * Para GSDK Shutdown e Maintenance Delegate, arraste uma linha a partir do quadrado vermelho e selecione "Add Custom Event" * Para "Register GSDK Health Check Delegate", selecione "Create Event" em "Event Dispatchers". * Adicionar o Health Check do PlayFab GSDK * No menu suspenso do novo nó, selecione "Create matching function". **Isso é importante, pois o GSDK Health Check Delegate tem um valor de retorno.** * Registrar o Health Check do PlayFab GSDK * Na função, verifique se o valor booliano de retorno está marcado. * Função de Health Check do PlayFab GSDK * Não se esqueça de conectar todos os nós ao nó Event Init. * Ao final, adicione o nó "ReadyforPlayers" para poder reagir ao sinal de prontidão do PlayFab. * Além disso, não se esqueça de adicionar o nó "SetDefaultServerHostPort" para se conectar à porta que o GSDK espera. * Para cada função/nó do GSDK que você quiser adicionar ao seu Blueprint, você pode verificar se ele existe digitando as primeiras letras do nome da função no novo nó e vendo a função do GSDK esperada aparecer nas sugestões. * No final, seu Blueprint deverá ser semelhante ao apresentado na imagem abaixo. * Gráfico completo do PlayFab GSDK ## Definir a classe GameInstance Depois de criar uma classe GameInstance personalizada que se integra ao gsdk, você precisa configurar seu projeto para realmente usar essa classe GameInstance recém-criada. Há duas maneiras de fazer isso: pelo editor do Unreal Engine ou editando diretamente o DefaultEngine.ini. ### No Unreal Editor No editor, a GameInstance padrão pode ser definida pela interface do usuário. No editor, vá para **Edit** -> **Project Settings**. Na janela aberta, navegue até **Maps\&Modes** no lado esquerdo. Role até o final e, em seguida, você poderá definir a opção `GameInstanceClass` diretamente como sua nova classe GameInstance (evite erros de digitação; ela deve corresponder exatamente). ### No DefaultEngine.ini Ou você pode atualizar o arquivo DefaultEngine.ini e adicionar as seguintes linhas: ```ini theme={null} [/Script/EngineSettings.GameMapsSettings] GameInstanceClass=/Script/{ProjectName}.MyGameInstance ``` ## Incluir os pré-requisitos para o servidor dedicado Windows Há duas maneiras de incluir os pré-requisitos locais do aplicativo: pelo editor do Unreal Engine ou editando o DefaultGame.ini. ### No Unreal Editor No editor, vá para Edit -> Project Settings. Na janela aberta, navegue até Packaging no lado esquerdo. Role até o final da lista e marque "Include app-local prerequisites". ### No DefaultGame.ini Ou você pode atualizar o DefaultGame.ini com o seguinte código: ```ini theme={null} [/Script/UnrealEd.ProjectPackagingSettings] IncludeAppLocalPrerequisites=True ``` Se a categoria já existir no seu DefaultGame.ini, basta adicionar a segunda linha a ela. Essa configuração garante que todas as dependências locais do aplicativo também sejam distribuídas com o projeto. Se você estiver usando Integração Contínua (CI), poderá adicioná-la à sua configuração para ativar esse sinalizador somente ao criar um servidor dedicado, de modo que as DLLs de pré-requisitos só sejam adicionadas se for um build de servidor dedicado. ## Próximas etapas Agora você está pronto para [criar seu projeto](/pt-BR/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/building-the-third-person-mp-example-project) no seu computador local. Como alternativa, você pode retornar ao guia principal do [plug-in Unreal GSDK](/pt-BR/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk#unreal-project-build-configurations). ## Related topics - [Visão geral do plug-in PlayFab Unreal GSDK](/pt-BR/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/index.md) - [Teste e depuração do projeto GSDK](/pt-BR/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-local-deployment-and-debugging.md) - [Implantação do projeto GSDK na nuvem](/pt-BR/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-cloud-deployment.md) - [Criação do projeto de exemplo do GSDK](/pt-BR/services/playfab/multiplayer/servers/server-sdks/unreal-gsdk/third-person-mp-example-project-setup.md) - [Configuração do início rápido do SDK unificado do PlayFab](/pt-BR/services/playfab/sdks/unified-sdk/quickstart-setup.md)