Cómo comenzar a usar Unity y Google Play Juegos para PC

1. Introducción

Última actualización: 18/10/2022

¿Cómo preparas tu juego para Google Play Juegos para PC?

Google Play Juegos facilita la tarea de llevar tu juego para dispositivos móviles a las PCs con Windows, lo que significa que puedes aumentar la participación de los jugadores y tu público sin tener que rediseñar tu juego ni tu modelo de negocio. Aún hay algunos cambios que debes realizar para brindarles a los nuevos jugadores de PC la mejor experiencia posible.

Qué aprenderás

En este codelab, se abordan las partes básicas de la lista de tareas de requisitos para que tu juego despegue y te ayudemos a preparar tu propio juego de Unity para Google Play Juegos en PC. No se abordan las integraciones más detalladas, como el acceso con Play Juegos y la API de Play Integrity.

• Cómo compilar para la arquitectura x86 desde Unity
• Cómo realizar pruebas y la implementación en el emulador de Google Play Juegos
• Cómo modificar tu interfaz de usuario para que se vea excelente en una PC
• Cómo detectar si estás ejecutando el emulador de Google Play Juegos y adaptar tu juego en consecuencia

Requisitos

• Instalación de Unity 2020 LTS (este codelab se compiló con la versión 2020.3.30f1).
• El emulador de Google Play Juegos

2. Prepárate

Cómo abrir o crear un proyecto nuevo

1. Crea un proyecto nuevo con el microjuego de plataformas en 2D o abre tu propio proyecto.

2. En el proyecto, selecciona File -> Build Settings y verifica que tengas todo configurado para compilar para Android.

3. Prepara el emulador de Google Play Juegos

Para comenzar, descarga el emulador.

Después de instalarlo, deberías ver un escritorio de Android en una ventana:

Nota: El emulador aparece como Google Play Games Developer Emulator en la lista de aplicaciones.

Este es un entorno de Android de alto rendimiento y con todas las funciones, adecuado para el desarrollo de juegos. Debería aparecer en Android Debug Bridge (adb) como un dispositivo en localhost:

❯ adb devices
List of devices attached
localhost:6520  device

Necesitas una versión reciente de adb para detectar el emulador. La versión incluida en Android Studio funciona, pero es posible que el adb que se incluye con Unity no lo haga. Se incluye una versión compatible con el emulador, y puedes encontrarla en C:\Program Files\Google\Play Games Developer Emulator\current\emulator. Para obtener la mejor experiencia del desarrollador, te recomendamos que instales Android Studio y lo uses para administrar tu SDK de Android.

Si el emulador se desconecta de adb, vuelve a conectarlo desde la línea de comandos de la siguiente manera:

adb connect localhost:6520

4. Configura Unity para compilar e implementar directamente en el emulador (opcional)

Es posible que la versión de adb que se incluye con Unity no sea compatible con el emulador. Para asegurarte, selecciona File -> Build Settings y verifica el diálogo Run Device para ver si aparece en la lista.

Precaución: Recuerda usar adb connect localhost:6520 con la versión de adb que se incluye en Unity si ejecutaste adb antes de realizar la prueba. Al momento de escribir este artículo, ninguna de las versiones de Unity probadas se envía con un adb compatible.

Según tu proyecto, el proceso de compilación y tu nivel de comodidad, puedes optar por configurar Unity para que se implemente directamente en el emulador de Google Play Juegos o compilar un APK y, luego, implementarlo de forma manual con adb install. Implementarla de forma manual requiere la menor cantidad de cambios, pero puede ralentizar tu ciclo de iteración.

Sigue estos dos pasos para realizar la implementación directamente en el emulador:

1. Configura Unity para que use otro SDK de Unity, idealmente el que instaló Android Studio.
2. Se actualizó la versión de Build Tools para solucionar un error en Unity.

Como es probable que la versión del SDK de Android que se incluye con Unity no detecte el emulador, usarás Android Studio para instalar un SDK más reciente.

1. Abre Android Studio y selecciona Edit -> Preferences -> External Tools.
2. Anula la selección de Android SDK Tools Installed with Unity y proporciona la ruta de acceso a la instalación de Android Studio (por lo general, AppData/Local/Android/sdk). No modifiques la opción Android NDK.

Cuando actualices los dispositivos conectados, deberías ver que aparece Google HPE device (localhost:6520) en la ventana de compilación:

Nota: Si no aparece el emulador, es posible que debas ejecutar adb connect localhost:6520. Esto se debe a que el adb integrado de Unity tiene prioridad hasta que lo cambies y te vuelvas a conectar manualmente a la nueva instancia de adb.

Según el estado de este error y tu versión de Unity, es posible que también debas cambiar la versión de tus herramientas de compilación. Para ello, verifica que estés generando un mainTemplate.gradle y un launcherTemplate.gradle.

3. Abre la ventana Project Settings en Player Settings y busca la sección Publishing Settings.
4. Desplázate hacia abajo hasta las opciones de Build y marca "Custom Main Gradle Template" y "Custom Launcher Gradle Template", que generarán ambos archivos de Gradle en Assets\Plugins\Android\.

Nota: Los proyectos que usan las bibliotecas EDM4U y androidx, como Firebase, también requieren que generes un Custom Gradle Properties Template para realizar correctamente la resolución de dependencias. Si no usaste una plantilla de Gradle personalizada en el pasado, también te recomendamos que revises este parámetro de configuración.

1. Reemplaza cualquier instancia de la cadena **BUILDTOOLS** por 30.0.0. En ambos archivos, la sección de código ahora debería decir lo siguiente:

android {
    compileSdkVersion **APIVERSION**
    buildToolsVersion '30.0.0'

5. Realiza la implementación en una Chromebook (opcional)

Puedes comenzar a desarrollar juegos para Google Play Juegos sin acceso al emulador de Google Play Juegos usando un dispositivo ChromeOS. Al igual que Google Play Juegos para PC, los Chromebooks tienen teclados y mouses, pantallas grandes y están disponibles en configuraciones x86. Usaremos el complemento de Unity Android Logcat con la Chromebook.

1. Abre el Administrador de paquetes y busca Android Logcat en Unity Registry.

También debes configurar tu Chromebook para el desarrollo de Android. Primero, habilita Linux.

2. Selecciona Configuración -> Desarrollador -> Linux.

Luego, habilita la depuración por ADB.

3. Selecciona Configuración -> Desarrolladores -> Entorno de desarrollo de Linux -> Desarrollar apps para Android -> Habilitar la depuración de ADB.

También deberás obtener la dirección IP de tu Chromebook. La forma más fácil de hacerlo es

4. Haz clic en el ícono de Información de la red para obtener la dirección IP de tu Chromebook.

5. Selecciona Window -> Analysis -> Android Logcat para abrir la ventana de Android Logcat.

6. Abre la lista de dispositivos. Es posible que diga No Device si no hay nada conectado.

7. Haz clic en Otras opciones de conexión y, luego, ingresa la dirección IP de la Chromebook.

8. Haz clic en Conectar. Deberías ver una ventana de Éxito:

Ahora, tu Chromebook aparecerá en la lista Run Device de Unity (es posible que primero debas actualizar la pantalla):

Ahora puedes implementar juegos en tu Chromebook y comenzar a realizar pruebas y desarrollos en hardware similar al de una PC.

6. Implementa una compilación de prueba

Google Play Juegos requiere que implementes una versión x86 de tu juego, que es parte de cómo alcanza sus comparativas de rendimiento en PCs de escritorio. Todas las variantes de LTS de Unity pueden generar compilaciones de Android compatibles con x86 y x86-64 (etiquetadas como "ChromeOS"), y Unity 2018 y versiones anteriores pueden generar compilaciones de x86. Para desbloquear estas arquitecturas, primero debes cambiar al backend de scripting de IL2CPP, lo que probablemente ya haces en producción para la compatibilidad con arm64.

1. Selecciona File -> Build Settings para abrir la ventana Build Settings y, luego, haz clic en Player Settings.

2. Navega a la sección Otros parámetros de configuración y cambia tu Scripting Backend a IL2CPP.

También debes habilitar la compatibilidad con x86 o x86-64. Para lanzar tu juego en la plataforma de Google Play Juegos, solo necesitas admitir x86, aunque recomendamos x86-64.

Nota: Cada arquitectura adicional que agregues aumentará el tiempo de compilación. Aunque puedes incluir de forma segura todos tus objetivos de ARM y x86 en un solo paquete, es posible que desees elegir solo x86 o x86-64 durante el desarrollo de funciones.

La versión de la biblioteca de Frame Pacing que incluye Unity también es incompatible con Google Play Juegos y hace que el juego falle durante el lanzamiento.

3. Para inhabilitar Frame Pacing desde la ventana Player Settings, abre la sección Resolution and Presentation y desmarca Optimized Frame Pacing.

Ya puedes comenzar a compilar.

1. Vuelve a abrir la ventana Build Settings y haz clic en Build And Run. Tu juego aparecerá en la ventana del emulador.

Si no puedes implementar tu juego, verifica si aparece "Google HPE device (localhost:6520)" en la lista de "Run Device". Si falta, asegúrate de que HPE_Dev se esté ejecutando y de que puedas ver la pantalla principal de Android. Si aún no aparece en la lista de dispositivos, ejecuta adb connect localhost:6520 con el adb.exe exacto que estás usando. Si usas el complemento de Android Logcat para Unity, selecciona Tools -> Open Terminal para abrir una terminal en el directorio con el mismo adb.exe que usa Unity.

Abrir Terminal" resaltado" 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. Adapta tu juego para PC

Cuando sea posible, intenta realizar cambios en tu juego en función de métricas independientes de la plataforma o de la presencia de ciertas funciones. Por ejemplo, un jugador en Android puede conectar un mouse y un teclado, o bien enchufar un monitor. Por lo tanto, cambiar el esquema de control o los elementos del HUD en respuesta a la configuración del dispositivo te permite aprovechar el trabajo de Google Play Juegos para PC en todas las plataformas compatibles.

Si tiene sentido cambiar la lógica según si el jugador está en Google Play Juegos o ChromeOS, este script te ayuda a detectarlo verificando la función del 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
}

Las PCs tienen una pantalla más grande que la de un teléfono Android típico. Cuando sea posible, recomendamos que el HUD no ocupe más del 20% de la pantalla. Dado que muchos juegos para dispositivos móviles usan "Ajustar con el tamaño de la pantalla", cambiar este parámetro a "Tamaño físico constante" o "Tamaño de píxel constante" puede ser un buen primer paso para lograr este objetivo.

También puedes establecer de forma dinámica la configuración de calidad con el comando QualitySettings.SetQualityLevel en el tiempo de ejecución si detectas que se está ejecutando en Google Play Juegos. El emulador de Google Play Juegos usa ANGLE para emitir comandos nativos de DirectX o Vulkan desde el OpenGL que emite Unity, por lo que es probable que logres una mayor fidelidad gráfica que la disponible en tus compilaciones de juegos para dispositivos móviles.

8. Control de entradas

Los juegos que se lancen en Google Play Juegos deben diseñarse en torno a la entrada del mouse y el teclado. Deberás planificar cómo interactuar con tu juego con un mouse y un teclado, así que dedica tiempo ahora a adquirir el unitypackage del SDK de entrada. Si no ves una descarga en esa página, asegúrate de haber accedido con una cuenta que pertenezca al grupo play-mp-libs.

Para fines de prueba, muchos juegos compilan controles básicos de mouse y teclado para el desarrollo en el editor. Cuando sea posible, te recomendamos que habilites estas opciones cuando ejecutes el juego en un dispositivo ChromeOS o en el emulador de Google Play Juegos.

Nota: Si actualmente usas #if UNITY_EDITOR para detectar si se está ejecutando en el editor, cambia esto a la verificación de tiempo de ejecución if (Application.isEditor) para que también verifiques GoogleDeviceUtilities.IsGooglePlayGames o GoogleDeviceUtilities.HasKeyboard.

De forma predeterminada, Google Play Juegos y ChromeOS convierten la entrada del mouse en un toque simulado. Si usas Input.GetTouch y Input.touchCount, tu juego seguirá funcionando como se espera. Si dependes de la entrada multitáctil, como los controles de doble pulgar o el gesto de pellizcar para hacer zoom, debes asignar la acción a las pulsaciones de teclas. También debes asignar acciones del juego a las pulsaciones de teclas, como presionar I para abrir el inventario, Escape para cerrar los cuadros de diálogo y Intro para enviar mensajes en el juego.

El microjuego de plataformas en 2D usa las flechas para moverse y la barra espaciadora para saltar. Si usas tu propio juego, asegúrate de tener las vinculaciones de teclas que prefieras para el próximo paso.

9. Integración del SDK de entrada

Ahora que configuraste los controles del mouse y el teclado, debes agregar compatibilidad con el SDK de entrada . Esto ayuda a los jugadores a descubrir tus entradas de PC con una ventana emergente práctica:

1. Después de importar el SDK a tu proyecto, crea un archivo llamado InputMappingProviderBehaviour.cs y agrega este contenido:

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. Ahora, completa ActionIds con la lista de acciones que usas en tu juego. En el microjuego de plataformas en 2D, las acciones son Izquierda, Derecha y Saltar:

private enum ActionIds
{
    Left,
    Right,
    Jump
}

3. En OnProvideInputMap, crea un InputAction para cada acción. Para ello, necesitas el nombre de la acción, la entrada y, luego, los botones del mouse o los códigos de teclas que se vincularán a ella. Para el juego de muestra, haz lo siguiente:

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. A continuación, agrupa estas acciones de entrada.

En el microjuego, solo tenemos un grupo, pero puedes crear todos los que necesites para ayudar a los jugadores a encontrar las acciones que necesitan. Agrega lo siguiente a OnProvideInputMap:

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

5. Agrega todos los grupos de entrada que creaste al mapa de entrada. Modifica la sentencia return en OnProvideInputMap para que se lea de la siguiente manera:

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

6. Por último, agrega la secuencia de comandos que creaste a tu juego:

7. Cuando vuelvas a implementar tu juego, presiona Shift+Tab para abrir la superposición en el juego.

8. Haz clic en Controles para ver los controles que configuraste.

10. Cómo quitar vistas web integradas

Para brindarles a los jugadores una experiencia excelente, debes quitar las vistas web incorporadas. Es común usar vistas web integradas para mostrar elementos como tu Política de Privacidad o Condiciones del Servicio. Si bien funcionan en Google Play Juegos, aparecen en un navegador "móvil" incorporado, en lugar del navegador de escritorio preferido del jugador, y pueden causar cierta confusión a los jugadores de PC. Por lo tanto, en Unity, si usas extensiones para mostrar un navegador integrado, recurre a Application.OpenURL(url).

11. Permisos y funciones

Hay una serie de funciones y permisos de Android que no son compatibles con Google Play Juegos. Una regla general es que la compilación de tu PC nunca debe mostrar un diálogo de permisos. Ahora que tienes lista la compilación, es recomendable que realices una instalación nueva típica y anotes los diálogos que veas para agregarlos a tu lista de tareas pendientes antes de enviar el juego.

Algunos juegos de Unity solicitan permisos con la API de Android.Permission. Debes incluir estas verificaciones en if (GoogleDeviceUtilities.IsGooglePlayGames) y dirigirte directamente a la lógica de fallas si corresponde.

12. Optimizaciones para computadoras

Google Play Juegos tiene algunas diferencias en comparación con un teléfono Android típico, por lo que es posible que desees configurar tu juego en consecuencia.

Cambia a DXT para la compresión de texturas. Los formatos de texturas comunes de Android, como ETC, se decodifican en la memoria durante el tiempo de ejecución si no se pueden pasar directamente a la GPU de un reproductor. ASTC te brinda la mejor compatibilidad con computadoras, aunque debes usar una herramienta de generación de perfiles de GPU para computadoras y verificar el comportamiento esperado de tu juego.

Como ahora ejecutas el juego en una GPU de escritorio, es posible que también quieras aumentar la calidad de los gráficos. Puedes ajustarlo directamente en la Configuración del proyecto en Calidad.

13. Felicitaciones

Ya tienes todo listo para comenzar a trabajar en tu juego para Google Play Juegos. Puedes comenzar a probar tu juego y realizar iteraciones en él. Recuerda que, aunque puedes conservar la misma base de código, deberás adaptar tu juego para que se sienta como un juego nativo para PC.

¿Qué sigue?

Hay más trabajo por hacer para lanzar un juego en Google Play Juegos:

• Consulta la Guía de inicio rápido para obtener la información más reciente.
• Actualiza a la versión 2 del acceso con los Servicios de juego de Play para que los jugadores accedan automáticamente al iniciar el juego y cumplir con los requisitos de continuidad.
• Implementa la API de Play Integrity para garantizar que la experiencia en PC sea tan segura como la experiencia en dispositivos móviles.

Por último, gran parte del trabajo que realizaste hasta este punto para admitir Google Play Juegos también te ayuda a realizar envíos en ChromeOS,y deberías considerar admitir esa plataforma junto con la PC.