Primeiros passos com o Unity e o Google Play Games para PC

1. Introdução

Logotipo do Google Play Games

Última atualização:25/04/2022

Como você prepara seu jogo para o Google Play Games on PC?

O Google Play Games facilita levar seu jogo para dispositivos móveis para PCs Windows. Isso significa que você pode aumentar o engajamento dos jogadores e o público-alvo sem precisar reestruturar o jogo ou reformular o modelo de negócios. Ainda há algumas mudanças a serem feitas para que os novos PCs tenham a melhor experiência possível.

O que você aprenderá

Este codelab aborda as partes básicas da lista de verificação de requisitos para colocar seu jogo em prática e ajuda você a preparar seu próprio jogo do Unity para o Google Play Games on PC. As integrações mais detalhadas, como o login do Play Games e a API Play Integrity, não são abordadas.

  • Como criar para a arquitetura x86 do Unity.
  • Como testar e implantar no emulador do Google Play Games.
  • Como modificar a interface do usuário para que ela tenha uma ótima aparência em um PC.
  • Como detectar se você está executando no emulador do Google Play Games e adaptar o jogo.

Pré-requisitos

2. Começar a configuração

Abrir ou criar um novo projeto

  1. Crie um novo projeto usando o Microgame 2D Platformer ou abra seu próprio projeto.

Tela "Novo projeto" do Unity. O "microgame do Platformer 2D" está selecionado como modelo a ser criado.

  1. No projeto, selecione File -> Build Settings e verifique se a criação para o Android é feita.

Uma captura de tela da janela "Build Settings" do Unity. A plataforma "Android" está ativa.

3. Preparar o emulador do Google Play Games

Para começar, faça o download do emulador nesta página. Se o link para download não aparecer, verifique se você fez login com uma conta que foi adicionada ao grupo play-mp-emu. Os membros desse grupo serão notificados quando houver atualizações para o emulador disponíveis. Portanto, verifique se você pode receber e-mails de play-mp-emu@googlegroups.com.

Depois de instalá-lo, você verá uma área de trabalho do Android em uma janela:

Captura de tela da janela do emulador do Google Play Games. A tela inicial do Android está visível.

Esse é um ambiente Android de alto desempenho com todos os recursos e adequado para desenvolvimento de jogos. Ele aparecerá no Android Debug Bridge (adb) como um dispositivo no localhost:

❯ adb devices
List of devices attached
localhost:6520  device

Você precisa de uma versão recente do adb para detectar o emulador. A versão incluída no Android Studio funciona, mas o adb enviado com o Unity pode não funcionar. Uma versão compatível é empacotada no emulador e pode ser encontrada em C:\Program Files\Google\HPE_Dev\emulator. Para ter a melhor experiência do desenvolvedor, instale o Android Studio e use-o para gerenciar seu SDK do Android.

Se o emulador for desconectado do adb, reconecte-o pela linha de comando desta forma:

adb connect localhost:6520

4. Configurar o Unity para criar e implantar diretamente no emulador (opcional)

A versão do adb enviada com o Unity pode não ser compatível com o emulador. Para garantir, selecione File -> Build Settings e verifique a caixa de diálogo Run Device para ver se ele está listado.

Executar dispositivo na janela "Build Settings": "Run Device" é selecionado. Os únicos elementos visíveis são "Default device" e "All supported devices".

Dependendo do projeto, do processo de compilação e do nível de conforto, é possível configurar o Unity para implantar diretamente no emulador do Google Play Games ou criar um APK e implantá-lo manualmente com adb install. Para implantá-la manualmente, são necessárias menos mudanças, mas o processo de iteração pode ser mais lento.

Implante diretamente no emulador com estas duas etapas:

  1. Configure o Unity para usar outro SDK do Unity, de preferência o do Android Studio.
  2. Atualize a versão do Build Tools para contornar um bug no Unity.

Como a versão do SDK do Android fornecida com o Unity provavelmente não detectará o emulador, use o Android Studio para instalar um SDK mais recente.

  1. Abra o Android Studio e selecione Edit -> Preferences -> External Tools.
  2. Desmarque Android SDK Tools Installed with Unity e informe o caminho da instalação do Android Studio (geralmente AppData/Local/Android/sdk). Não mude a opção Android NDK.

Captura de tela de "Ferramentas externas" na janela "Preferências"

Ao atualizar os dispositivos conectados, você verá Google HPE device (localhost:6520) aparecendo na janela de compilação:

Captura de tela da janela "Build Settings". O ícone "Run Device" "Google HPE" está visível.

Dependendo do estado deste bug e da sua versão do Unity, talvez seja necessário alterar a versão das ferramentas de compilação. Para fazer isso, verifique se você está gerando um mainTemplate.gradle e um launcherTemplate.gradle.

  1. Abra a janela Project Settings para Player Settings e localize a seção Publishing Settings.
  2. Role para baixo até as opções Build e marque a opção "Custom Main Gradle Template" e "Custom Launcher Gradle Template", que gerará os dois arquivos do Gradle em Assets\Plugins\Android\.

Captura de tela da seção "Player" na janela "Project Settings".  As caixas de seleção "Modelo principal personalizado do Gradle" e "Modelo personalizado do acesso rápido do Gradle" são marcadas.

  1. Substitua qualquer instância da string **BUILDTOOLS** por 30.0.0. Em ambos os arquivos, a seção do código agora será lida:
android {
    compileSdkVersion **APIVERSION**
    buildToolsVersion '30.0.0'

5. Implantar em um Chromebook (opcional)

Você pode começar a desenvolver jogos para o Google Play Games sem acesso ao emulador do Google Play Games usando um dispositivo ChromeOS. Assim como o Google Play Games no PC, os Chromebooks têm teclados e mouses, têm telas grandes e estão disponíveis em configurações x86. Usaremos o plug-in do Unity para Android Logcat com o Chromebook.

  1. Abra o Gerenciador de pacotes e pesquise Android Logcat em Unity Registry.

Janela do gerenciador de pacotes com a opção "Android Logcat" selecionada para ser instalada.

Você também precisa configurar o Chromebook para o desenvolvimento em Android. Para começar, ative o Linux.

  1. Selecione Configurações -> Desenvolvedor -> Linux.

Imagem animada mostrando como ativar o suporte para Linux.  O desenvolvedor está selecionado na janela "Configurações". Em seguida, a opção "Ativar" é clicada em "Ambiente de desenvolvimento do Linux".

Em seguida, ative a depuração do adb.

  1. Selecione Configurações -> Desenvolvedores -> Ambiente de desenvolvimento do Linux -> Desenvolver apps Android -> Ativar depuração do adb.

A depuração do adb é ativada no menu "Developer".

Você também precisa consultar o endereço IP do Chromebook. A maneira mais fácil de fazer isso é

  1. Clique no ícone Informações da rede para ver o endereço IP do seu Chromebook.

Captura de tela da janela de rede aberta em um Chromebook.

Clique no botão de informações da rede, que mostra o endereço IP.

  1. Selecione Window -> Analysis -> Android Logcat para abrir a janela do Android Logcat.

Janela> Análise aberta no Unity com "Android Logcat" selecionado.

  1. Abrir a lista de dispositivos É possível que o app seja No Device se nada estiver conectado no momento.

Janela do Android Logcat exibida, menu suspenso do dispositivo selecionado.

  1. Clique em Outras opções de conexão e digite o endereço IP do Chromebook.

A janela "Outras conexões" é aberta. Um endereço IP é inserido.

  1. Clique em Connect. Você verá uma janela Success:

Uma caixa de diálogo com a mensagem "Sucesso" está aberta.

Seu Chromebook agora aparece na lista "Executar dispositivo" do Unity. Talvez seja necessário atualizar a tela primeiro:

A janela "Build Settings" do Unity é aberta. O dispositivo ChromeOS é exibido no menu suspenso "Executar dispositivo".

Agora você pode implantar jogos no Chromebook e começar a testar e desenvolver em hardware semelhante ao PC.

6. Implantar um build de teste

O Google Play Games exige a implantação de uma versão x86 do jogo, que faz parte de como ela alcança os comparativos de mercado de desempenho em computadores desktop. Todas as variantes LTS do Unity podem gerar builds Android compatíveis com x86 e x86-64 (identificadas como "Chrome OS"), e a versão 2018 e anteriores do Unity podem gerar builds x86. Para desbloquear essas arquiteturas, primeiro é necessário alternar para o back-end de script IL2CPP, que você provavelmente já faz na produção para suporte a arm64.

  1. Selecione File -> Build Settings para abrir a janela "Build Settings" e clique em Player Settings.

Captura de tela da janela "Build Settings" focada no botão "Player Settings".

  1. Navegue até a seção Outras configurações e alterne do Scripting Backend para o IL2CPP.

Captura de tela da seção "Outras configurações" de "Configurações do jogador"

Você também deve ativar a compatibilidade com x86 ou x86-64. Para enviar na plataforma Google Play Games, você só precisa oferecer compatibilidade com x86, mas recomendamos x86-64.

Captura de tela da seção "Configuração" do back-end de scripts "IL2CPP" em "Configurações de player" com a opção "x86 (Chrome OS)" selecionada e "x86-64 (Chrome OS)" destacado.

A versão dos pacotes Unity da biblioteca Frame Pacing também é incompatível com o Google Play Games e causa falhas no lançamento.

  1. Para desativar o Frame Pacing na janela Player Settings, abra a seção Resolution and Presentation e desmarque a opção Optimized Frame Pacing.

Captura de tela "Resolução e apresentação" com "Ritmo de frame otimizado" desmarcada

Agora você está pronto para criar.

  1. Abra a janela Build Settings novamente e clique em Build And Run. Seu jogo será exibido na janela do emulador.

Captura de tela do emulador do Google Play Games com o "2D Platformer Microgame" em execução

Se não for possível implantar seu jogo, verifique se "Dispositivo Google HPE (localhost:6520)" aparece na lista "Executar dispositivo". Se não houver, verifique se o HPE_Dev está em execução e você pode ver a tela inicial do Android. Se ele ainda não aparecer na lista de dispositivos, execute adb connect localhost:6520 com o adb.exe exato que você está usando. Se você usa o plug-in do Unity para Android Logcat, selecione Tools -> Open Terminal para abrir um terminal para o diretório com o mesmo adb.exe do Unity.

Captura de tela da janela do Unity do "Android Logcat" com "Ferramentas> Abrir terminal" em destaque

7. Adapte seu jogo para PC

Sempre que possível, tente fazer alterações no jogo com base em métricas independentes de plataforma ou na presença de determinados recursos. Por exemplo, um jogador no Android pode conectar um mouse e um teclado ou um plugue a um monitor. Portanto, mudar o esquema de controle ou os elementos HUD em reação à configuração do dispositivo permite que você aproveite o Google Play Games on PC funciona em todas as plataformas compatíveis.

Se faz sentido mudar a lógica com base no fato de o jogador estar ou não no Google Play Games ou no ChromeOS, este script ajuda a detectá-lo verificando o recurso do sistema HPE_EXPERIENCE:

using UnityEngine;

public class GoogleDeviceUtilities
{
#if UNITY_ANDROID && !UNITY_EDITOR
    private static AndroidJavaObject PackageManager
    {
        get
        {
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            return currentActivity.Call<AndroidJavaObject>("getPackageManager");
        }
    }

    public static bool IsChromeOS => PackageManager.Call<bool>("hasSystemFeature", "org.chromium.arc");

    public static bool IsGooglePlayGames =>
        PackageManager.Call<bool>("hasSystemFeature", "com.google.android.play.feature.HPE_EXPERIENCE");

    public static bool HasKeyboard
    {
        get
        {
            var unityPlayerClass = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            var currentActivity = unityPlayerClass.GetStatic<AndroidJavaObject>("currentActivity");
            var resources = currentActivity.Call<AndroidJavaObject>("getResources");
            var configuration = resources.Call<AndroidJavaObject>("getConfiguration");
            var keyboard = configuration.Get<int>("keyboard");
            return keyboard == 2; // Configuration.KEYBOARD_QWERTY
        }
    }
#else
    public static bool IsChromeOS => false;
    public static bool IsGooglePlayGames => false;
    public static bool HasKeyboard => true;
#endif
}

Os computadores têm uma tela maior que o smartphone Android típico. Quando possível, recomendamos que sua HUD não ocupe mais de 20% da tela. Como muitos jogos para dispositivos móveis usam "Dimensionar com tamanho da tela", alterar para "Tamanho físico constante" ou "Tamanho constante do Pixel" pode ser um bom primeiro passo para alcançar essa meta.

A captura de tela do inspetor &quot;Canvas Scaler&quot; com os &quot;UI Scale Modes&quot; listados são os modos de &quot;Constant Pixel Size&quot;, &quot;Scale With Screen Size&quot; e &quot;Constant Physical Size&quot;. A opção &quot;Tamanho constante de pixel&quot; está selecionada.

Também é possível definir dinamicamente as configurações de qualidade usando o comando QualitySettings.SetQualityLevel no momento da execução se você detectar que está executando no Google Play Games. O emulador do Google Play Games usa o ANGLE para emitir comandos nativos DirectX ou Vulkan da emissão do OpenGL para que você possa atingir uma fidelidade gráfica maior do que a disponível nas versões de jogos para dispositivos móveis.

8. Gerenciar a entrada (Input handling)

O frete de jogos no Google Play Games precisa ser criado usando a entrada de mouse e teclado. Você precisará planejar como interagir com seu jogo usando um mouse e um teclado. Portanto, reserve o tempo para conseguir o unitypackage do SDK de entrada. Caso não veja um download nessa página, verifique se você fez login com uma conta no grupo play-mp-libs.

Para fins de teste, muitos jogos criam controles básicos do mouse e do teclado para desenvolvimento no editor. Quando possível, ative-os quando em execução em um dispositivo ChromeOS ou no emulador do Google Play Games.

Por padrão, o Google Play Games e o ChromeOS convertem a entrada do mouse em um toque simulado. Se você usa o Input.GetTouch e o Input.touchCount, o jogo continua funcionando como esperado. Se você depende de entradas multitoque, como controles duplos de polegar ou fazer gesto de pinça para aplicar zoom, mapeie a ação para pressionar teclas. Você também precisa mapear as ações no jogo para pressionar teclas, como pressionar i para abrir o inventário, escape para fechar as caixas de diálogo e Enter para enviar mensagens no jogo.

O Microgame 2D Platformer usa as setas para se mover e o espaço para pular. Se você estiver usando seu próprio jogo, verifique se tem as teclas de atalho preferidas para a próxima etapa.

9. Integração do SDK de entrada

Agora que os controles do mouse e do teclado estão configurados, adicione o suporte ao SDK de entrada . Isso ajuda os jogadores a descobrir suas entradas para PC com um pop-up útil:

  1. Depois de importar o SDK para o projeto, crie um arquivo chamado InputMappingProviderBehaviour.cs e adicione o seguinte conteúdo:
using System.Collections.Generic;
using Google.Play.InputMapping;
using UnityEngine;
using Input = Google.Play.InputMapping.Input;

public class InputMappingProviderBehaviour : MonoBehaviour
{
    private void Start()
    {
        Input.GetInputMappingClient().RegisterInputMappingProvider(new MyInputMappingProvider());
    }

    private class MyInputMappingProvider : InputMappingProvider
    {
        public InputMap OnProvideInputMap()
        {
            return new InputMap
            {
                InputGroups = new List<InputGroup> { },
                MouseSettings = new MouseSettings
                {
                    InvertMouseMovement = false,
                    AllowMouseSensitivityAdjustment = false
                }
            };
        }
    }

    private enum ActionIds
    {
    }
}
  1. Agora, preencha ActionIds com a lista de ações que você está usando no jogo. No microjogo de plataforma 2D, as ações são "esquerda", "direita" e "pular":
private enum ActionIds
{
    Left,
    Right,
    Jump
}
  1. No OnProvideInputMap, crie um InputAction para cada ação. Para isso, você precisará do nome da ação, da entrada e, em seguida, dos botões do mouse ou códigos de tecla que serão vinculados a ela. Para o jogo de amostra:
var leftAction = new InputAction
{
    ActionLabel = "Walk Left",
    UniqueId = (int)ActionIds.Left,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_DPAD_LEFT
        }
    }
};

var rightAction = new InputAction
{
    ActionLabel = "Walk Right",
    UniqueId = (int)ActionIds.Right,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_DPAD_RIGHT
        }
    }
};

var jumpAction = new InputAction
{
    ActionLabel = "Jump",
    UniqueId = (int)ActionIds.Jump,
    InputControls = new InputControls
    {
        AndroidKeycodes = new[]
        {
            AndroidKeyCode.KEYCODE_SPACE
        }
    }
};
  1. Em seguida, coloque essas ações de entrada em grupos.

Para o microjogo, temos apenas um grupo, mas você pode criar quantos precisar para ajudar os jogadores a encontrar as ações necessárias. Adicione isso ao OnProvideInputMap:

var movementInputGroup = new InputGroup
{
    GroupLabel = "Movement",
    InputActions = new List<InputAction>
    {
        leftAction, rightAction, jumpAction
    }
};
  1. Adicione todos os grupos de entrada criados no mapa. Modifique a instrução de retorno em OnProvideInputMap para ler o seguinte:
return new InputMap
{
    InputGroups = new List<InputGroup> { movementInputGroup },
    MouseSettings = new MouseSettings
    {
        InvertMouseMovement = false,
        AllowMouseSensitivityAdjustment = false
    }
};
  1. Por fim, adicione o script que você criou ao jogo:

Captura de tela de um nó chamado &quot;InputSdk&quot; com &quot;Input Mapping Provider Behaviour&quot; anexado

  1. Ao implantar o jogo novamente, pressione Shift+Tab para abrir a sobreposição no jogo.

Captura de tela da sobreposição &quot;Opções do jogo&quot; no emulador do Google Play Games

  1. Clique em Controles para ver os controles configurados.

Captura de tela da sobreposição &quot;Controles&quot; no emulador do Google Play Games

10. Remover anúncios e visualizações da Web incorporadas

Não vamos abordar toda a lógica que precisa ser atualizada. No entanto, há dois itens que podem ser abordados imediatamente para passar pela aprovação de apps e oferecer uma ótima experiência aos jogadores.

Primeiro, é comum usar visualizações da Web incorporadas para exibir itens como a Política de Privacidade ou os Termos de Serviço. Embora esses recursos funcionem no Google Play Games, eles aparecem em um navegador para dispositivos móveis incorporado, e não no navegador preferido do jogador. Isso pode confundir os jogadores de PC. Portanto, no Unity, se você estiver usando extensões para mostrar um navegador incorporado, volte para Application.OpenURL(url).

Em segundo lugar, os anúncios não são permitidos no Google Play Games, mas é possível deixar os SDKs de anúncios para os players de dispositivos móveis e Chrome OS. Use GoogleDeviceUtilities.IsGooglePlayGames para determinar se você precisa ou não incluir anúncios no jogo. Outras APIs relacionadas a pagamentos, como o Google Pay, funcionarão normalmente.

11. Permissões e recursos

vários recursos e permissões do Android que não são compatíveis com o Google Play Games. Como regra geral, o build para PC nunca exibe uma caixa de diálogo de permissões. Uma boa coisa a fazer, agora que seu build está pronto, é instalar uma nova instalação típica e anotar as caixas de diálogo que você quer adicionar à lista de tarefas para enviar o jogo.

Alguns jogos do Unity solicitam permissões usando a API Android.Permission. Encapsule-os em verificações if (GoogleDeviceUtilities.IsGooglePlayGames) e vá diretamente para a lógica de falha, se aplicável.

12. Otimizações para computador

O Google Play Games tem algumas diferenças em comparação a um smartphone Android comum. Recomendamos que você configure seu jogo adequadamente.

Alterne para DXT para compactação de textura. Formatos comuns de textura do Android, como o ETC, são decodificados na memória durante a execução se não puderem ser transmitidos diretamente para a GPU do jogador. O ASTC oferece a melhor compatibilidade com computadores, embora você precise usar uma ferramenta de criação de perfil de GPU para computador a fim de verificar o comportamento esperado para seu jogo.

Janela &quot;Build Settings&quot; do Unity aberta com &quot;Compactação de textura&quot; expandida. &quot;DXT (Tegra)&quot; é a modificação de compactação de textura destacada.

Como você está executando uma GPU para computador agora, também é possível aumentar a qualidade dos gráficos. Você pode ajustar isso diretamente nas Configurações do projeto em Qualidade

Captura de tela da seção &quot;Qualidade&quot; em &quot;Configurações do projeto&quot;

13. Parabéns

Você tem tudo pronto para começar a trabalhar no Google Play Games. Você pode começar a testar e iterar no jogo. Lembre-se de que, embora seja possível manter a mesma base de código, é preciso adaptar o jogo para que ele pareça um jogo para PC nativo.

Qual é a próxima etapa?

Há mais trabalho a ser feito para lançar um jogo no Google Play Games:

Por fim, grande parte do trabalho feito até aqui para oferecer compatibilidade com o Google Play Games também ajuda você a enviar no ChromeOS. Considere oferecer compatibilidade com essa plataforma e com o PC.