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

1. Introdução

Ú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

• Instalação do LTS do Unity 2020 (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 Microgame 2D Platformer ou abra seu próprio projeto.

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

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 [e-mail].

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

Observação:o emulador aparece como HPE_Dev na lista de apps.

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.

Cuidado:lembre-se de usar o 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 do Unity testadas até o momento desta versão foi enviada com um adb compatível.

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.

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

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

3. Abra a janela Project Settings para Player Settings e localize a seção Publishing Settings.
4. 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\.

Observação: Projetos que usamEDM4U- eAndroidX bibliotecas, comoFirebase;, você também precisa gerar umCustom Gradle Properties Template para executar corretamente a resolução de dependência. Se você nunca usou um modelo personalizado do Gradle, verifique essa configuração.

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.

Você também precisa configurar o Chromebook para o desenvolvimento em Android. Para começar, ative 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 -> Ativar depuração do adb.

Você também precisa consultar o endereço IP do 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 -> Analysis -> Android Logcat para abrir a janela do Android Logcat.

Análise aberta no Unity com "Android Logcat" selecionado." class="l10n-absolute-url-src" l10n-attrs-original-order="alt,style,src,class" l10n-encrypted-style="7ek2XYbAbHCf3eKVqUfzlU8zz2uYoEmRhrQeP6/mnhY=" src="https://codelabs.developers.google.com/android-google-play-games-unity-quickstart/img/a1a76bed69791616.png" style="width: 446.00px" />

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

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

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

Seu Chromebook agora aparece na lista "Executar dispositivo" 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 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.

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

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.

Observação:cada arquitetura extra que você adiciona aumenta o tempo de compilação. Mesmo que você possa agrupar todos os destinos ARM e x86 com segurança em um pacote, é recomendável escolher somente 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 causa falhas no lançamento.

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

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.

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.

Abrir terminal" em destaque" class="l10n-absolute-url-src" l10n-attrs-original-order="alt,style,src,class" l10n-encrypted-style="Bfmtwp4MR0V5uTC1s3uklU8zz2uYoEmRhrQeP6/mnhY=" src="https://codelabs.developers.google.com/android-google-play-games-unity-quickstart/img/9101ce3c95fb1aa2.png" style="width: 624.00px" />

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.

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.

Observação:se você estiver usando #if UNITY_EDITOR para detectar se está executando no editor, mude para a verificação de ambiente de execução if (Application.isEditor) para que você também verifique 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 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
    {
    }
}

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

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 isso ao OnProvideInputMap:

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

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

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 no jogo.

8. Clique em Controles para ver os controles configurados.

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

Há 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.

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

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:

• Consulte o Guia de início rápido para ver as informações mais recentes.
• Faça login no Login dos serviços relacionados a jogos do Google Play v2 para fazer login automático dos jogadores no lançamento e ajudar a atender aos requisitos de continuidade.
• Implemente a API Play Integrity para garantir que sua experiência com o PC seja tão segura quanto a experiência com dispositivos móveis.

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.