Pular para o conteúdo principal
O exemplo Wrapper, também conhecido como wrappingGsdk, encapsula um jogo existente para que ele possa ser usado na implantação de builds de servidores de jogo que usam o sistema operacional Windows e o sistema operacional Linux. Usando o aplicativo wrapper, você também poderá usar o build do seu servidor de jogo no PlayFab Multiplayer Servers.
Um wrapper é uma solução alternativa que processa os fluxos de saída e de erro padrão para chamar os métodos do GSDK e não se destina ao uso em produção.

Conteúdo do exemplo

Este exemplo consiste em dois aplicativos de console .NET Core.
  • Wrapper: integra o pacote NuGet mais recente do PlayFab Game Server SDK (GSDK) ao seu servidor de jogo. Este aplicativo wrapper não se destina ao uso em produção
  • Fakegame: um servidor de jogo básico que não tem conhecimento do GSDK. É como um servidor de jogo típico que você teria antes de usar o PlayFab Multiplayer Servers. Ele inicia o servidor Web Kestrel do ASP.NET Core, que escuta na porta TCP 80. Ele se destina a simular um servidor de jogo que não tem absolutamente nenhum conhecimento do GSDK. Você pode usá-lo se não tiver um servidor de jogo próprio. Ele tem duas rotas GET que podemos usar: /hello, para obter uma resposta simples, e /hello/terminate, que pode encerrar o servidor.

Requisitos

Para usar e ver o PlayFab Multiplayer Servers, você precisa habilitar o recurso no Game Manager. Para obter instruções, consulte Habilitar o recurso PlayFab Server.

Passo a passo

Para um passo a passo ao vivo da criação deste exemplo, confira nossa apresentação do Microsoft Game Dev 2021 (começa em aproximadamente 2:52):

Obter e criar o executável do Wrapper

  • Obtenha o exemplo do wrapper do GSDK usando os métodos padrão do Git ou baixando-o como um arquivo zip
  • Abra o Prompt de Comando e use o comando cd para alterar o caminho do diretório para o local do arquivo wrapper.csproj. Exemplo: cd C:/ReplaceWithYourFilePath/wrappingGsdk/wrapper
  • Em seguida, execute o seguinte comando da CLI do .NET Core:
Quando o build do wrapper for bem-sucedido, o executável será publicado na pasta ..\wrappingGsdk\wrapper\bin\Debug\netcoreapp3.1\win-x64\publish, conforme mostrado na imagem abaixo. Local de publicação do executável do wrapper

Criar um ativo de servidor de jogo

Há duas maneiras de criar um ativo de servidor de jogo.

Usar o servidor de jogo Fakegame com o wrapper

Use o build.ps1 para criar e empacotar os dois projetos (wrapper e fakegame). Esse script cria uma pasta de saída com um arquivo .zip que contém os arquivos necessários.
  • Abra o PowerShell
  • Use o comando cd para alterar o caminho do diretório para o local do script build.ps1. Exemplo: cd C:/ReplaceWithYourFilePath/wrappingGsdk/
  • Execute \build.ps1
  • Depois que o script for executado com êxito, vá para a pasta ..\wrappingGsdk\drop. Você encontrará um arquivo gameassets.zip criado, que contém o build do servidor de jogo falso, o executável do wrapper (criado na etapa anterior) e outros arquivos necessários.

Usar os arquivos do seu próprio servidor de jogo com o wrapper

Para usar o projeto do seu jogo na avaliação, coloque o wrapper e o executável do seu servidor de jogo na mesma pasta.
  • Siga as instruções em Criar o executável do wrapper
  • Vá para o local de publicação do wrapper em ..\wrappingGsdk\wrapper\bin\Debug\netcoreapp3.1\win-x64\publish
  • Em outra janela, vá para o build do seu servidor de jogo e para os arquivos necessários para executá-lo. Se não tiver certeza de quais arquivos são necessários, consulte Determinando os arquivos DLL necessários
  • Copie o build do servidor de jogo e todos os arquivos necessários para o local de publicação do wrapper
  • Selecione todos os arquivos no local de publicação do wrapper
  • Com todos os arquivos selecionados, clique com o botão direito do mouse e selecione Enviar para > Pasta compactada. Não selecione a pasta de publicação do wrapper para adicioná-la ao zip. Isso causaria um mapeamento incorreto.
Para conferir, siga as instruções em Usar o servidor de jogo Fakegame com o wrapper para criar o gameassets.zip e usá-lo como referência.

Criar e carregar uma imagem de contêiner Linux (somente para servidores Linux)

Para criar uma imagem de contêiner Linux, você precisaria de um Dockerfile. Um Dockerfile é um arquivo de texto sem extensão que contém todos os comandos necessários para criar uma determinada imagem de contêiner. Neste exemplo, esse arquivo já foi criado para você. Basta criar a imagem de contêiner e executá-la. Se quiser usar seu dispositivo de desenvolvimento Windows, você precisará instalar o Subsistema do Windows para Linux (WSL). As instruções são fornecidas abaixo. Para obter mais informações, consulte Diferenças entre imagens de contêiner Windows e Linux.
  1. Configurar seu dispositivo de desenvolvimento Windows (opcional)
  2. Obter as credenciais de entrada do registro de contêiner do PlayFab
  3. Usar o Dockerfile existente/criar o seu próprio Esta etapa é diferente dependendo de você estar usando o FakeGame ou o seu próprio servidor de jogo.
    • Se estiver usando o FakeGame, verifique se você tem o Dockerfile
    • Se estiver usando o seu jogo ou precisar criar um Dockerfile, consulte Criar seu Dockerfile. Você pode usar o Dockerfile do FakeGame como ponto de partida.
  4. Abra seu terminal Linux com o Docker instalado, como o Ubuntu. Substitua os valores das variáveis TAG e ACR pelos seus valores. Em seguida, execute os comandos abaixo.
Para verificar se as variáveis ACR e TAG estão definidas corretamente, execute echo ACR__ e __echo TAG.
  1. Insira o nome de usuário e a senha obtidos na etapa anterior.
  2. Crie e carregue a imagem de contêiner Linux.
Execute os comandos abaixo para criar e carregar o Dockerfile. Há um ”.” no final do comando docker build. Você precisa estar na mesma pasta/diretório do Dockerfile. Para obter detalhes, consulte Criar e carregar a imagem de contêiner Linux.

Implantar um build usando o Game Manager ou a API

O processo de implantação do build é semelhante para servidores de jogo Windows e Linux.

Implantar servidores de jogo Windows

As etapas são semelhantes às do exemplo C# Windows Runner. Siga estas etapas, com as diferenças listadas abaixo. Se preferir testar isso localmente, consulte Depurando servidores de jogo localmente e integração com o PlayFab. Configurações específicas deste exemplo
  • Comando de início:
    • Use C:\Assets\wrapper.exe -g C:\Assets\fakegame.exe arg1 arg2
    • Substitua fakegame.exe pelo nome do executável do seu servidor de jogo, se estiver usando o build do seu servidor de jogo
  • Configuração de rede: Nome: gameport, Porta: 80, Protocolo: TCP
  • Ativos: ao usar o FakeGame, carregue gameassets.zip como ativo.

Implantar servidores de jogo Linux

Siga as etapas gerais abaixo para implantar. Configurações específicas deste exemplo
  • Selecione o contêiner que você carregou
  • Configuração de rede: Nome: gameport, Porta: 80, Protocolo: TCP
  • Não é necessário carregar ativos nem definir o Start Command
Durante a alocação com a API RequestMultiplayerServer, a porta à qual você se conecta será diferente de 80. Isso ocorre porque o serviço PlayFab Multiplayer Server criará um mapeamento entre o Azure Load Balancer (que expõe suas portas à Internet pública) e os servidores de jogo em execução nas máquinas virtuais do Azure.

Executando o wrapper usando o LocalMultiplayerAgent

O uso do LocalMultiplayerAgent é altamente recomendado se você quiser testar a integração do GSDK nos seus servidores de jogo personalizados. Se você estiver usando o LocalMultiplayerAgent com contêineres Windows, precisará configurar corretamente o arquivo MultiplayerSettings.json. Você pode encontrar um exemplo abaixo; preste atenção especial aos valores de LocalFilePath e StartGameCommand. Não se esqueça de substituir fakegame.exe pelo nome do executável do seu servidor de jogo.
Agora você está pronto para testar com o LocalMultiplayerAgent. Se você o configurou corretamente, assim que o LocalMultiplayerAgent iniciar seu servidor de jogo, você poderá se conectar a ele via curl em http://localhost:56100/Hello.

Como se conectar a um servidor de jogo no MPS

Para estabelecer uma conexão com um servidor de jogo no MPS, é essencial determinar o número de porta apropriado. Esse requisito decorre da configuração em que várias máquinas virtuais, cada uma possivelmente executando várias instâncias de servidor de jogo, são gerenciadas por trás de um balanceador de carga. Nessa configuração, uma única porta de IP público pode corresponder a portas diferentes nessas máquinas virtuais, cada uma associada a uma instância distinta de servidor de jogo.

Usar o Game Manager

Você pode usar a interface do usuário do Game Manager para alocar um servidor de jogo e estabelecer uma conexão com ele.
  1. Faça logon no Game Manager
  2. Vá para a página Multiplayer => Servers e selecione seu build
  3. Vá para a página Servers e clique no botão “Request server”.
  4. Na próxima página, anote o endereço IPv4 público e a Porta.
  5. Use o curl para se conectar em http://[IPV4Address]:[Ports->Num]/Hello.”

Usar o exemplo MPS Allocator

Veja como você pode usar o exemplo MPS Allocator para alocar um servidor de jogo e estabelecer uma conexão com ele.
  1. Compile e execute o exemplo MPS Allocator.
  2. Use o comando “ListBuildSummaries” para ver os builds disponíveis e suas IDs de build correspondentes.
  3. Invoque “RequestMultiplayerServer” para iniciar uma solicitação de uma instância de servidor de jogo.
  4. Insira a ID de build selecionada no comando “ListMultiplayerServers” para gerar uma lista dos servidores disponíveis.
  5. Escolha uma instância de servidor de jogo ativa e, em seguida, use “GetMultiplayerServerDetails” com as IDs de build e de sessão obtidas nas etapas anteriores.
  6. Anote o IPV4Address e o Ports->Num exibidos na resposta.
  7. Use o curl para se conectar em http://[IPV4Address]:[Ports->Num]/Hello.

Confira também

Última modificação em 8 de outubro de 2026