Começar a usar o Unity e o Google Play Games para PC

1. Introdução

Última atualização:18/10/2022

Como preparar seu jogo para o Google Play Games no PC?

O Google Play Games facilita o lançamento do seu jogo para dispositivos móveis em PCs Windows. Isso significa que você pode aumentar o engajamento dos jogadores e o público sem precisar mudar a arquitetura do jogo ou o modelo de negócios. Ainda precisamos fazer algumas mudanças para que os novos jogadores de PC tenham a melhor experiência possível.

O que você vai aprender

Este codelab abrange as partes básicas da lista de verificação de requisitos para começar a criar seu jogo e ajudar você a preparar seu próprio jogo Unity para o Google Play Games no PC. Integrações mais detalhadas, como o Logon do Play Games e a API Play Integrity, não são cobertas.

• Como criar para a arquitetura x86 no 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 seu jogo adequadamente.

O que é necessário

• Instalação do Unity 2020 LTS (este codelab foi criado com a versão 2020.3.30f1).
• O emulador do Google Play Games.

2. Começar a configuração

Abrir ou criar um novo projeto

1. Crie um novo projeto usando o microjogo de plataforma 2D ou abra seu próprio projeto.

2. No projeto, selecione File -> Configurações do build e verifique se está tudo pronto para ser criado para Android.

3. Preparar o emulador do Google Play Games

Comece fazendo o download do emulador.

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

Observação:o emulador aparece como emulador de desenvolvedor do Google Play Games na lista de apps.

Esse é um ambiente Android de alto desempenho e repleto de recursos, adequado para o desenvolvimento de jogos. Ele vai 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 empacotada com o Android Studio funciona, mas o adb, fornecido com o Unity, talvez não funcione. Uma versão compatível acompanha o emulador, e você pode encontrá-la em C:\Program Files\Google\Play Games Developer Emulator\current\emulator. Para ter a melhor experiência de desenvolvedor, instale o Android Studio e use-o para gerenciar o SDK do Android.

Se o emulador se desconectar do adb, reconecte-o pela linha de comando da seguinte forma:

adb connect localhost:6520

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

A versão do adb fornecida com o Unity pode não ser compatível com o emulador. Para ter certeza, selecione Arquivo -> Build Settings e confira a caixa de diálogo Run Device para conferir se ele está listado.

Cuidado:lembre-se de usar adb connect localhost:6520 com a versão do adb que acompanha o Unity se você tiver executado o adb antes do teste. Nenhuma das versões testadas do Unity até o momento desta publicação tem um adb compatível.

Dependendo do seu projeto, processo de build e nível de conforto, você pode configurar o Unity para implantar diretamente no emulador do Google Play Games ou criar um APK e implantá-lo manualmente com adb install. Implantá-lo manualmente requer o menor número de alterações, mas pode atrasar seu ciclo de iteração.

Implante diretamente no emulador com estas duas etapas:

1. Configure o Unity para usar outro SDK do Unity, de preferência o instalado pelo 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 -> Preferências -> Ferramentas externas.
2. Desmarque Android SDK Tools Installed with Unity e forneça o caminho para a instalação do Android Studio (geralmente AppData/Local/Android/sdk). Não mexa na opção Android NDK.

Quando você atualizar os dispositivos conectados, a Google HPE device (localhost:6520) aparecerá na janela de build:

Observação:se o emulador não aparecer, talvez seja necessário executar adb connect localhost:6520. Isso ocorre porque o adb integrado do Unity tem precedência até que você o altere e se reconecte manualmente à nova instância do adb.

Dependendo do estado desse bug e da sua versão do Unity, talvez também seja necessário mudar a versão das ferramentas de build. Para fazer isso, verifique se você está gerando um mainTemplate.gradle e um launcherTemplate.gradle.

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

Observação:projetos que usam bibliotecas EDM4U e androidx, como Firebase, também exigem que você gere um Custom Gradle Properties Template para executar corretamente a resolução de dependências. Se você nunca usou um modelo personalizado do Gradle, verifique essa configuração também.

1. Substitua qualquer instância da string **BUILDTOOLS** por 30.0.0. Em ambos os arquivos, a seção do código agora terá a seguinte mensagem:

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, telas grandes e estão disponíveis em configurações x86. Vamos usar o plug-in do Unity para o Android Logcat com o Chromebook.

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

Também é necessário configurar o Chromebook para desenvolvimento em Android. Comece ativando o Linux.

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

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

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

Também é recomendável saber o endereço IP do seu Chromebook. A maneira mais fácil de fazer isso é

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

5. Selecione Window -> Análise -> Android Logcat para abrir a janela do Android Logcat.

6. Abra a lista de dispositivos. Se não houver nada conectado, o texto No Device poderá aparecer.

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

8. Clique em Conectar. Você verá uma janela Success:

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

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

6. Implantar um build de teste

O Google Play Games exige que você implante uma versão x86 do jogo, o que faz parte de como ele atinge os comparativos de mercado de desempenho em PCs. Todas as variantes de LTS do Unity podem gerar builds do Android compatíveis com x86 e x86-64 (identificados como "Chrome OS"), e o Unity versão 2018 e anteriores podem gerar builds x86. Para desbloquear essas arquiteturas, primeiro você precisa mudar para o back-end de script IL2CPP, que provavelmente você já faz em produção para suporte ao arm64.

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

2. Navegue até a seção Other Settings e mude o Scripting Backend para IL2CPP.

Você também precisa ativar o suporte x86 ou x86-64. Para enviar na plataforma do Google Play Games, você só precisa oferecer suporte a x86, embora recomendemos x86-64.

Observação:cada arquitetura extra adicionada aumenta o tempo de build. Mesmo que você possa agrupar com segurança todos os seus destinos ARM e x86 em um pacote, convém escolher apenas x86 ou x86-64 durante o desenvolvimento do recurso.

A versão dos pacotes Unity da biblioteca Frame Pacing também é incompatível com o Google Play Games e faz com que seu jogo falhe na inicialização.

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

Você já pode criar!

1. Abra a janela Build Settings novamente e clique em Build And Run. O jogo vai aparecer na janela do emulador.

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

Abrir terminal" destacada" style="width: 624.00px" src="img/9101ce3c95fb1aa2.png" 36w, img/91010101ce3c3c95fb1aa2_48.png 48w, 910101ce3c3c95fb1aa2_36. tamanhos](/max-width: 840px) 100vw, 856px">

7. Adapte seu jogo para PC

Sempre que possível, tente fazer mudanças no jogo com base em métricas que não dependem da plataforma ou na presença de determinados recursos. Por exemplo, um jogador no Android pode conectar um mouse e um teclado ou um monitor. Assim, mudar o esquema de controle ou os elementos HUD de acordo com a configuração do dispositivo permite que você aproveite o trabalho do Google Play Games no PC 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 PCs têm uma tela maior do que o smartphone Android comum. Quando possível, recomendamos que o HUD não ocupe mais que 20% da tela. Como muitos jogos para dispositivos móveis usam "Dimensionar com tamanho da tela", mudar essa opção para "Tamanho físico constante" ou "Tamanho constante de pixels" pode ser um bom primeiro passo para atingir essa meta.

Também recomendamos que você defina dinamicamente as configurações de qualidade usando o comando QualitySettings.SetQualityLevel durante a execução se detectar que o app está sendo executado no Google Play Games. O emulador do Google Play Games usa o ANGLE para emitir comandos nativos do DirectX ou Vulkan pelo Unity do OpenGL. Assim, você provavelmente pode alcançar uma fidelidade gráfica maior do que a disponível em builds de jogos para dispositivos móveis.

8. Gerenciamento de entradas

O envio de jogos no Google Play Games precisa ser criado com base na entrada do mouse e do teclado. Você vai precisar planejar como interagir com o jogo usando mouse e teclado, então adquira o unitypackage do SDK de entrada. Se você não encontrar um download nessa página, verifique se fez login com uma conta do grupo play-mp-libs.

Para fins de teste, muitos jogos criam controles básicos de mouse e teclado para desenvolvimento no editor. Ative-os sempre que possível em um dispositivo ChromeOS ou no emulador do Google Play Games.

Observação:se você está usando #if UNITY_EDITOR para detectar se está executando no editor, mude isso para a verificação de tempo de execução if (Application.isEditor). Assim, você também vai conferir GoogleDeviceUtilities.IsGooglePlayGames ou GoogleDeviceUtilities.HasKeyboard.

Por padrão, o Google Play Games e o ChromeOS convertem a entrada do mouse em um toque simulado. Se você usa Input.GetTouch e Input.touchCount, o jogo continua funcionando normalmente. Se você depende da entrada multitoque, como controles de dois dedos ou de movimento de pinça para aplicar zoom, é necessário mapear a ação para pressionamentos de tecla. Também é preciso mapear as ações no jogo para pressionamentos de tecla, como pressionar i para abrir seu inventário, escapar para fechar caixas de diálogo e Enter para enviar mensagens no jogo.

O microjogo de plataforma 2D 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 preferenciais para a próxima etapa.

9. Integração do SDK de entrada

Agora que os controles do mouse e do teclado estão configurados, é preciso adicionar o suporte ao SDK de entrada . Isso ajuda os jogadores a descobrir as entradas do seu 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
    {
    }
}

2. 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
}

3. No OnProvideInputMap, crie um InputAction para cada ação. Para isso, você precisa do nome da ação, da entrada e dos botões do mouse ou códigos de tecla que serão vinculados a ela. Para o jogo de exemplo:

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

4. 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 isto ao OnProvideInputMap:

var movementInputGroup = new InputGroup
{
    GroupLabel = "Movement",
    InputActions = new List<InputAction>
    {
        leftAction, rightAction, jumpAction
    }
};

5. Adicione todos os grupos de entrada que você criou ao mapa de entrada. Modifique a instrução de retorno em OnProvideInputMap para ler:

return new InputMap
{
    InputGroups = new List<InputGroup> { movementInputGroup },
    MouseSettings = new MouseSettings
    {
        InvertMouseMovement = false,
        AllowMouseSensitivityAdjustment = false
    }
};

6. Por fim, adicione o script que você criou ao jogo:

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

8. Clique em Controles para conferir os que você configurou.

10. Remover visualizações da Web incorporadas

Para oferecer uma ótima experiência aos jogadores, remova as visualizações da Web incorporadas. É comum usar visualizações da Web incorporadas para mostrar itens como sua Política de Privacidade ou seus Termos de Serviço. Embora funcionem no Google Play Games, eles aparecem em um "dispositivo móvel" incorporado em vez do navegador de desktop preferido do player, o que pode causar confusão para os jogadores de PC. Portanto, no Unity, se você estiver usando extensões para mostrar um navegador incorporado, use Application.OpenURL(url).

11. Permissões e recursos

Há vários recursos e permissões do Android que não são compatíveis com o Google Play Games. Como regra geral, a versão para PC nunca deve exibir uma caixa de diálogo de permissões (link em inglês). Uma boa coisa a fazer, agora que seu build está pronto, é passar por uma nova instalação típica e anotar as caixas de diálogo exibidas para adicionar à sua "tarefa" para enviar seu jogo.

Alguns jogos do Unity solicitam permissões usando a API Android.Permission. É necessário encapsulá-los em verificações de if (GoogleDeviceUtilities.IsGooglePlayGames) e acessar diretamente 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, e recomendamos que você configure seu jogo de acordo com essas informações.

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

Como você está executando em uma GPU de computador agora, talvez seja melhor aumentar a qualidade gráfica. É possível ajustá-la diretamente nas Configurações do projeto em Qualidade.

13. Parabéns

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

Qual é a próxima etapa?

Ainda há muito trabalho a ser feito para lançar um jogo no Google Play Games:

• Consulte o Guia de início rápido para ver as informações mais recentes.
• Faça upgrade para o Login dos serviços relacionados a jogos do Google Play v2 para que o jogador faça login automaticamente após o lançamento e atenda aos requisitos de continuidade.
• Implemente a API Play Integrity para garantir que sua experiência no PC seja tão segura quanto a no dispositivo móvel.

Por fim, muito do trabalho que você fez até aqui para oferecer suporte ao Google Play Games também ajuda a enviar para o ChromeOS,e você deve considerar a compatibilidade com essa plataforma junto com o PC.