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?

Com o Google Play Games, é fácil levar seu jogo para dispositivos móveis aos PCs Windows. Isso significa que você pode aumentar o engajamento dos jogadores e seu público-alvo sem precisar reestruturar o jogo ou redesenhar seu modelo de negócios. Ainda há algumas mudanças que você precisa fazer para oferecer a melhor experiência possível aos novos jogadores de PC.

O que você vai aprender

Este codelab aborda as partes básicas da lista de verificação de requisitos para você começar a desenvolver seu jogo e preparar seu próprio jogo do Unity para o Google Play Games no PC. 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 no Unity.
• Como testar e implantar no emulador do Google Play Games.
• Como modificar sua interface do usuário para ter uma ótima aparência em um PC.
• Como detectar se você está executando no emulador do Google Play Games e adaptar o jogo de acordo.

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 projeto

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

2. No projeto, selecione File -> Build Settings e verifique se você está configurado para criar para Android.

3. Preparar o emulador do Google Play Games

Comece baixando o emulador.

Depois de instalar, você vai ver uma área de trabalho do Android em uma janela:

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

É um ambiente Android de alto desempenho e com todos os recursos adequados para o desenvolvimento de jogos. Ele vai aparecer no Android Debug Bridge (adb) como um dispositivo em 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 é incluída com o emulador e pode ser encontrada em C:\Program Files\Google\Play Games Developer Emulator\current\emulator. Para ter a melhor experiência de desenvolvimento, 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 assim:

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 verificar, selecione File -> Build Settings e confira se o dispositivo aparece na caixa de diálogo Run Device.

Atenção:use adb connect localhost:6520 com a versão do adb que vem com o Unity se você já executou o adb antes do teste. Nenhuma das versões testadas do Unity no momento da redação deste artigo vem com um adb compatível.

Dependendo do seu projeto, processo de build e nível de conforto, você pode configurar o Unity para fazer a implantação diretamente no emulador do Google Play Games ou criar um APK e implantá-lo manualmente com adb install. A implantação manual exige o mínimo de mudanças, mas pode diminuir o 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 das ferramentas de build para contornar um bug no Unity.

Como a versão do SDK do Android enviada com o Unity provavelmente não vai 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 forneça o caminho para a instalação do Android Studio (geralmente AppData/Local/Android/sdk). Não mexa na opção Android NDK.

Ao atualizar os dispositivos conectados, Google HPE device (localhost:6520) vai 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 mude 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 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 para Player Settings e localize a seção Publishing Settings.
4. Role a tela para baixo até as opções de Build e marque "Custom Main Gradle Template" e "Custom Launcher Gradle Template", que vão gerar os dois arquivos do Gradle em Assets\Plugins\Android\.

Observação:projetos que usam bibliotecas EDM4U e androidx, como o Firebase, também exigem a geração de um Custom Gradle Properties Template para realizar a resolução de dependências corretamente. 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. Nos dois arquivos, a seção de código agora precisa estar assim:

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 Android Logcat com o Chromebook.

1. Abra o Package Manager e procure Android Logcat em Unity Registry.

Você também precisa configurar o Chromebook para desenvolvimento 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 -> Ativar a depuração ADB.

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

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

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

6. Abra a lista de dispositivos. Ela pode mostrar 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 Conectar. Uma janela Sucesso vai aparecer:

O 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 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 da maneira como ele atinge os comparativos de desempenho em PCs desktop. Todas as variantes LTS do Unity podem gerar builds do Android compatíveis com x86 e x86-64 (rotulados como "Chrome OS"), e a versão 2018 e anteriores do Unity podem gerar builds x86. Para desbloquear essas arquiteturas, primeiro é necessário mudar para o back-end de script IL2CPP, o que provavelmente já é feito em produção para oferecer suporte ao arm64.

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

2. Acesse a seção Outras configurações e mude seu Scripting Backend para IL2CPP.

Também é necessário ativar o suporte a x86 ou x86-64. Para lançar na plataforma Google Play Games, você só precisa oferecer suporte a x86, embora recomendemos x86-64.

Observação:cada arquitetura adicional aumenta o tempo de build. Embora seja possível agrupar com segurança todas as suas metas ARM e x86 em um pacote, talvez você queira escolher apenas x86 ou x86-64 durante o desenvolvimento de recursos.

A versão da biblioteca Frame Pacing que o Unity agrupa também é incompatível com o Google Play Games e faz com que o jogo falhe ao iniciar.

3. Para desativar o ritmo de frame na janela Configurações do jogador, abra a seção Resolução e apresentação e desmarque Ritmo de frame otimizado.

Agora 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, verifique se "Dispositivo HPE do Google (localhost:6520)" aparece na lista "Executar dispositivo". Se ele estiver faltando, verifique se o HPE_Dev está em execução e se a tela inicial do Android aparece. 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 Android Logcat Unity, selecione Tools -> Open Terminal para abrir um terminal no diretório com o mesmo adb.exe que o Unity está usando.

Abrir terminal" highlighted" style="width: 624.00px" src="img/9101ce3c95fb1aa2.png" srcset="img/9101ce3c95fb1aa2_36.png 36w, img/9101ce3c95fb1aa2_48.png 48w, img/9101ce3c95fb1aa2_72.png 72w, img/9101ce3c95fb1aa2_96.png 96w, img/9101ce3c95fb1aa2_480.png 480w, img/9101ce3c95fb1aa2_720.png 720w, img/9101ce3c95fb1aa2_856.png 856w, img/9101ce3c95fb1aa2_960.png 960w, img/9101ce3c95fb1aa2_1440.png 1440w, img/9101ce3c95fb1aa2_1920.png 1920w, img/9101ce3c95fb1aa2_2880.png 2880w" sizes="(max-width: 840px) 100vw, 856px">

7. Adaptar o jogo para PC

Sempre que possível, faça mudanças 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 monitor. Assim, mudar o esquema de controle ou os elementos do HUD em reação à configuração do dispositivo permite aproveitar o Google Play Games no PC em todas as plataformas compatíveis.

Se for útil mudar a lógica com base em se o jogador está no Google Play Games ou no ChromeOS, esse script ajuda a detectar isso 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 típico. Quando possível, recomendamos que o HUD não ocupe mais de 20% da tela. Como muitos jogos para dispositivos móveis usam "Escalar com o tamanho da tela", mudar isso para "Tamanho físico constante" ou "Tamanho constante de pixel" pode ser uma boa primeira etapa para atingir essa meta.

Também é possível definir dinamicamente as configurações de qualidade usando o comando QualitySettings.SetQualityLevel durante a 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 do DirectX ou do Vulkan do OpenGL Unity, assim você pode alcançar uma fidelidade gráfica maior do que estava disponível nas versões do jogo para dispositivos móveis.

8. Gerenciamento de entradas

Os jogos lançados no Google Play Games precisam ser criados com base na entrada de mouse e teclado. Você precisa planejar como interagir com o jogo usando um mouse e um teclado. Por isso, reserve um tempo agora para adquirir o unitypackage do SDK de entrada. Se você não encontrar um download nessa página, confira se fez login com uma conta no grupo play-mp-libs.

Para fins de teste, muitos jogos criam controles básicos de mouse e teclado para desenvolvimento no editor. Se possível, ative essas opções quando estiver usando um dispositivo ChromeOS ou o 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 tempo de execução if (Application.isEditor) para também verificar 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 conforme o esperado. Se você usa entrada multitoque, como controles duplos com o polegar ou gesto de pinça para aumentar o zoom, precisa mapear a ação para pressionamentos de tecla. Você também precisa mapear ações no jogo para pressionamentos de teclas, como pressionar i para abrir o inventário, escape para fechar caixas de diálogo e enter para enviar mensagens no jogo.

O microgame de plataforma 2D usa as setas para mover e a barra de espaço para pular. Se você estiver usando seu próprio jogo, confira se tem as vinculações de teclas preferidas para a próxima etapa.

9. Integração do SDK de entrada

Agora que você configurou os controles de mouse e teclado, adicione suporte ao SDK de entrada . Isso ajuda os jogadores a descobrir os comandos do PC com um popover prático:

1. Depois de importar o SDK para o projeto, crie um arquivo chamado InputMappingProviderBehaviour.cs e adicione este 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 microgame de plataforma 2D, as ações são "Esquerda", "Direita" e "Pular":

private enum ActionIds
{
    Left,
    Right,
    Jump
}

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

No microgame, temos apenas um grupo, mas você pode criar quantos forem necessários para ajudar os jogadores a encontrar as ações de que precisam. 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 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 criado 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 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 Termos de Serviço. Embora funcionem no Google Play Games, eles aparecem em um navegador "móvel" incorporado, em vez do navegador de computador preferido do jogador, e podem causar confusão para jogadores de PC. Portanto, no Unity, se você estiver usando extensões para mostrar um navegador incorporado, volte para Application.OpenURL(url).

11. Permissões e recursos

Há vários recursos e permissões do Android que não têm suporte no Google Play Games. Como regra geral, o build do PC nunca deve mostrar uma caixa de diálogo de permissões. Agora que você tem o build pronto, é recomendável passar por uma nova instalação típica e anotar todas as caixas de diálogo que aparecem para adicionar à sua lista de tarefas pendentes 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á direto 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 com um smartphone Android típico, e talvez seja necessário configurar o jogo de acordo com isso.

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

Como você está usando uma GPU de computador, talvez queira 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 seu jogo para o Google Play Games. Você pode começar a testar e iterar o jogo. Lembre-se de que, mesmo que você possa manter a mesma base de código, é recomendável adaptar o jogo para que ele pareça um jogo nativo de PC.

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 as informações mais recentes.
• Faça upgrade para o Login dos Serviços do Google Play Games v2 para fazer login automaticamente de um jogador no lançamento e ajudar a atender aos requisitos de continuidade.
• Implemente a API Play Integrity para garantir que a experiência no PC seja tão segura quanto a em dispositivos móveis.

Por fim, grande parte do trabalho que você fez até agora para oferecer suporte ao Google Play Games também ajuda a enviar conteúdo no ChromeOS. Considere oferecer suporte a essa plataforma junto com o PC.