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

1. Introducción

Logotipo de Google Play Juegos

Última actualización: 25/04/2022

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

Con Google Play Juegos, es más fácil llevar tu juego para dispositivos móviles a las PC con Windows. Esto significa que puedes aumentar la participación de los jugadores y tu público sin tener que rediseñar tu juego ni rediseñar tu modelo de negocios. Aún debes realizar algunos cambios para que tus nuevos jugadores de PC tengan la mejor experiencia posible.

Qué aprenderá

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

  • Cómo compilar para la arquitectura x86 de Unity.
  • Cómo probar e implementar en el emulador de Google Play Juegos
  • Cómo modificar tu interfaz de usuario para que se vea genial en una PC
  • Cómo detectar si estás ejecutando el emulador de Google Play Juegos y adaptar tu juego según corresponda.

Requisitos

2. Prepárate

Cómo abrir o crear un proyecto nuevo

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

Pantalla de "Proyecto nuevo" de Unity. Se selecciona el "Microjuego de plataformas en 2D" como plantilla para crear.

  1. En el proyecto, selecciona File -> Build Settings y comprueba que estés listo para realizar compilaciones para Android.

Captura de pantalla de la ventana "Build Settings" de Unity. La plataforma "Android" está activa.

3. Prepara el emulador de Google Play Juegos

Primero, descarga el emulador en esta página. Si no ves el vínculo de descarga, asegúrate de haber accedido con una cuenta que se haya agregado al grupo play-mp-emu. Los miembros de este grupo reciben una notificación cuando hay actualizaciones disponibles para el emulador, así que asegúrate de recibir correos electrónicos de play-mp-emu@googlegroups.com.

Después de instalarla, deberías ver el escritorio de Android en una ventana:

Captura de pantalla de la ventana del emulador de Google Play Juegos. Se puede ver la pantalla principal de Android.

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 con Android Studio funciona, pero adb no se envía con Unity. El emulador incluye una versión compatible, y puedes encontrarla en C:\Program Files\Google\HPE_Dev\emulator. Si quieres obtener la mejor experiencia para desarrolladores, puedes instalar Android Studio y usarlo para administrar el 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 realizar compilaciones e implementar directamente en el emulador (opcional)

Es posible que la versión de adb enviada con Unity no sea compatible con el emulador. Para asegurarte de que aparezca, selecciona File -> Build Settings y revisa el diálogo Run Device.

Ejecuta el dispositivo en la ventana "Build Settings". Se seleccionó "Run Device"; los únicos elementos visibles son "Default device" y "All compatible devices".

En función de tu proyecto, el proceso de compilación y el 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. Para implementarlo manualmente, se requieren la menor cantidad de cambios, pero es posible que se ralentice el ciclo de iteración.

Implementa en el emulador directamente con estos dos pasos:

  1. Configura Unity para usar otro SDK de Unity, idealmente el que instaló Android Studio.
  2. Actualiza la versión de las herramientas de compilación para solucionar un error en Unity.

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

  1. Abre Android Studio y selecciona Editar -> Preferencias -> Herramientas externas.
  2. Desmarca Android SDK Tools Installed with Unity y proporciona la ruta de acceso para la instalación de Android Studio (generalmente, AppData/Local/Android/sdk). Deja la opción Android NDK sola.

Captura de pantalla de "External Tools" de la ventana "Preferences"

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

Captura de pantalla de la ventana "Build Settings" (Configuración de compilación). Se muestra "Run Device" "Google HPE".

Según el estado del error y de 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.

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

Captura de pantalla de la sección "Reproductor" de la ventana "Configuración del proyecto".  Las casillas de verificación "Custom Main Gradle Template" y "Custom Launcher Gradle Template" están marcadas.

  1. Reemplaza cualquier instancia de la string **BUILDTOOLS** por 30.0.0. En ambos archivos, la sección del código debería leer:
android {
    compileSdkVersion **APIVERSION**
    buildToolsVersion '30.0.0'

5. Implementa en una Chromebook (opcional)

Puedes comenzar a desarrollar juegos para Google Play Juegos sin acceso al emulador de Google Play Juegos mediante un dispositivo con Chrome OS. Al igual que Google Play Juegos para PC, las Chromebooks tienen teclados y mouse, tienen 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.

Ventana de Package Manager con la opción "Logcat de Android" seleccionada para instalar.

Además, debes configurar la Chromebook para el desarrollo de Android. Para comenzar, habilita Linux.

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

Imagen animada que muestra cómo habilitar la compatibilidad con Linux.  Se selecciona al desarrollador en la ventana Configuración. Luego, se hace clic en "Activar" en "Entorno de desarrollo de Linux".

Luego, habilita la depuración de adb.

  1. Selecciona Configuración -> Desarrolladores -> Entorno de desarrollo de Linux -> Desarrollar apps para Android -> Habilita la depuración de adb.

La depuración de ADB está habilitada en el menú para desarrolladores.

Además, deberás obtener la dirección IP de tu Chromebook. La manera más fácil de hacerlo es

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

Captura de pantalla de la ventana de red abierta en una Chromebook.

Se hace clic en el botón de información de red, que muestra la dirección IP.

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

Ventana > Análisis abierto en Unity con la opción “Android Logcat” seleccionada.

  1. Abre la lista de dispositivos. Si no hay ningún dispositivo conectado actualmente, es posible que lea No Device.

Se muestra la ventana Logcat de Android, con el menú desplegable del dispositivo seleccionado.

  1. Haz clic en Otras opciones de conexión e ingresa la dirección IP de tu Chromebook.

Se abre la ventana Otras conexiones. Se ingresa una dirección IP.

  1. Haga clic en Conectar. Debería ver una ventana Success:

Se abrirá un cuadro de diálogo que indica "Listo".

Tu Chromebook ahora aparece en la lista Ejecutar dispositivo de Unity (es posible que primero debas actualizar la pantalla):

La ventana “Build Settings” de Unity está abierta. El dispositivo con Chrome OS aparece en el menú desplegable "Ejecutar dispositivo".

Ahora puedes implementar juegos en tu Chromebook y comenzar a realizar pruebas y desarrollo en hardware tipo PC.

6. Implementa una compilación de prueba

Google Play Juegos requiere que implementes una versión x86 del juego, que es parte de su capacidad de alcanzar comparativas de rendimiento en computadoras de escritorio. Todas las variantes de Unity pueden generar compilaciones de Android compatibles con x86 y x86-64 (etiquetadas como "Sistema operativo Chrome"), y Unity 2018 y las versiones anteriores pueden generar compilaciones de x86. Para desbloquear estas arquitecturas, primero necesitas cambiar al backend de secuencias de comandos IL2CPP, que es probable que ya realices en producción para ofrecer compatibilidad con arm64.

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

Captura de pantalla de la ventana "Build Settings" (Configuración de compilación) enfocada en el botón "Player Settings" (Configuración del jugador).

  1. Ve a la sección Other Settings y cambia tu Scripting Backend a IL2CPP.

Captura de pantalla de la sección "Other Settings" de "Player Settings"

También debes habilitar la compatibilidad con x86 o x86-64. Para hacer envíos en la plataforma de Google Play Juegos, solo debes admitir x86, aunque recomendamos x86-64.

Captura de pantalla de la sección Configuración de la configuración del jugador “Backend de secuencias de comandos” está configurada como “IL2CPP” Arquitecturas de destino con la opción “x86 (Chrome OS)” seleccionada y “x86-64 (Chrome OS)” destacado.

La versión de los paquetes de la biblioteca de Frame Pacing de Unity también es incompatible con Google Play Juegos y hace que falle tu juego cuando se inicie.

  1. Para inhabilitar el ritmo de fotogramas en la ventana Player Settings, abre la sección Resolution and Presentation y desmarca Optimized Frame Pacing.

Captura de pantalla "Resolution and Presentation" con la opción "Optimized Frame Pacing" desmarcada

Ya está listo para compilar.

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

Captura de pantalla del emulador de Google Play Juegos con el "Microjuego en 2D plataformas" en ejecución

Si no puedes implementar tu juego, comprueba si aparece "Dispositivo Google HPE (localhost:6520)" en la lista "Dispositivo de ejecución". Si falta, asegúrate de que HPE_Dev esté en ejecución y puedas ver la pantalla principal de Android. Si aún no aparece en la lista de dispositivos, ejecuta adb connect localhost:6520 con los adb.exe exactos que estás usando. Si usas el complemento de Android Logcat Unity, selecciona Tools -> Abrir terminal para abrir una terminal en el directorio con el mismo adb.exe Unity que usa.

Captura de pantalla de la ventana de Unity “Android Logcat” con “Tools>Open Terminal” destacado

7. Adapta tu juego para PC

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

Si tiene sentido cambiar la lógica según si el jugador está en Google Play Juegos o Chrome OS, esta secuencia de comandos te ayuda a detectarlo verificando la función HPE_EXPERIENCE del sistema:

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

Captura de pantalla del inspector de &quot;Escalador de lienzo&quot; con los modos de escala de la IU visibles, como &quot;Tamaño de píxel constante&quot;, &quot;Escala con tamaño de pantalla&quot; y &quot;Tamaño físico constante&quot;. Se seleccionó &quot;Constant Pixel Size&quot;.

También puedes establecer de forma dinámica la configuración de calidad con el comando QualitySettings.SetQualityLevel durante 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 a partir de las emisiones de OpenGL de Unity, por lo que es probable que logres una mayor fidelidad de los gráficos que en las versiones para juegos de dispositivos móviles.

8. Control de entradas

Los juegos que se envían a través de Google Play Juegos deben compilarse en función de la entrada del mouse y del teclado. Deberás planificar cómo interactuar con el juego con un mouse y un teclado, así que tómate el tiempo para adquirir el SDK de entrada unitypackage. Si no ves una descarga en esa página, asegúrate de haber accedido con una cuenta en el grupo play-mp-libs.

Con fines de prueba, muchos juegos crean controles básicos de mouse y de teclado para el desarrollo en el editor. Cuando sea posible, deberías habilitarlos cuando ejecutes una app en el dispositivo con Chrome OS o en el emulador de Google Play Juegos.

De forma predeterminada, Google Play Juegos y Chrome OS convierten la entrada del mouse en un toque simulado. Si usas Input.GetTouch y Input.touchCount, el juego seguirá funcionando según lo esperado. Si confías en la entrada multitáctil, como controles de pulgar doble o pellizcar para hacer zoom, debes asignar la acción a las pulsaciones de las teclas. También debes asignar acciones en el juego a pulsaciones de teclas, como presionar i para abrir tu inventario, escape para cerrar cuadros de diálogo e Intro para enviar mensajes en el juego.

El microjuego de plataforma 2D usa las flechas para moverte y la barra espaciadora para saltar. Si usas tu propio juego, asegúrate de tener las vinculaciones de teclas preferidas para el siguiente paso.

9. Integración del SDK de entrada

Ahora que configuraste los controles del mouse y del teclado, debes agregar compatibilidad con el SDK de entrada . Esto ayuda a los jugadores a descubrir las entradas de tu 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
    {
    }
}
  1. Ahora, completa ActionIds con la lista de acciones que usas en tu juego. En el microjuego de plataformas 2D, las acciones son izquierda, derecha y salto:
private enum ActionIds
{
    Left,
    Right,
    Jump
}
  1. 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 códigos de teclas que se vincularán a ella. Para el juego de muestra:
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. A continuación, coloca estas acciones de entrada en grupos.

Para el microjuego, tenemos solo 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
    }
};
  1. Agrega todos los grupos de entrada que creaste al mapa de entrada. Modifica la declaración de devolución en OnProvideInputMap de la siguiente manera:
return new InputMap
{
    InputGroups = new List<InputGroup> { movementInputGroup },
    MouseSettings = new MouseSettings
    {
        InvertMouseMovement = false,
        AllowMouseSensitivityAdjustment = false
    }
};
  1. Por último, agrega a tu juego la secuencia de comandos que creaste:

Captura de pantalla de un nodo llamado “InputSdk” con el “comportamiento del proveedor de la asignación de entradas” adjunto

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

Captura de pantalla de la superposición de &quot;Opciones de juego&quot; en el emulador de Google Play Juegos

  1. Haga clic en Controles para ver los que configuró.

Captura de pantalla de la superposición &quot;Controles&quot; en el emulador de Google Play Juegos

10. Quita los anuncios y las vistas web incorporadas

Si bien no abarcaremos toda la lógica que debe actualizarse, hay dos elementos que puedes abordar de inmediato para aprobar la app y brindar a los jugadores una gran experiencia.

En primer lugar, es común usar vistas web incorporadas para mostrar elementos como tu Política de Privacidad o Condiciones del Servicio. Aunque estos funcionan en Google Play Juegos, se muestran en un navegador incorporado para "dispositivos móviles", en lugar del navegador de escritorio preferido del jugador, y pueden causar confusión para los jugadores de PC. Por lo tanto, en Unity, si usas alguna extensión para mostrar un navegador incorporado, recurre a Application.OpenURL(url).

En segundo lugar, no se permiten anuncios actualmente en Google Play Juegos, aunque puedes dejar los SDK de anuncios para los reproductores de Chrome OS y dispositivos móviles. Usa GoogleDeviceUtilities.IsGooglePlayGames para determinar si debes incluir anuncios en el juego. Otras API relacionadas con los pagos, como Google Pay, funcionarán según lo esperado.

11. Permisos y funciones

Hay varias funciones y permisos de Android que no se admiten en Google Play Juegos. Una regla general es que la compilación de tu PC nunca debe aparecer un diálogo emergente de permisos. Una vez que tienes algo bueno que hacer, ahora que tienes tu compilación lista, es probar una nueva instalación típica y escribir los diálogos que veas para agregarlos a tu lista de tareas pendientes para enviar el juego.

Algunos juegos de Unity solicitan permisos mediante la API de Android.Permission. Debes unirlos en las verificaciones de if (GoogleDeviceUtilities.IsGooglePlayGames) y, si corresponde, debes ir directamente a la lógica de tu falla.

12. Optimizaciones para computadoras de escritorio

Google Play Juegos tiene algunas diferencias en comparación con un teléfono Android típico. Te recomendamos configurar tu juego como corresponda.

Cambia a DXT para comprimir la textura. Los formatos de textura 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 del jugador. ASTC te ofrece la mejor compatibilidad para computadoras de escritorio, aunque necesitas usar una herramienta de generación de perfiles de GPU para computadoras a fin de verificar el comportamiento esperado para tu juego.

Ventana “Build Settings” de Unity abierta con la opción “Compresión de texturas” expandida. &quot;DXT (Tegra)&quot; es la anulación de compresión de texturas destacada.

Dado que estás ejecutando una GPU de escritorio, es posible que también quieras aumentar la calidad de los gráficos. Puedes ajustarlo directamente en Calidad, en Configuración del proyecto.

Captura de pantalla de la sección &quot;Calidad&quot; de &quot;Configuración del proyecto&quot;

13. Felicitaciones

Tienes todo listo para comenzar a trabajar en tu juego en Google Play Juegos. Puedes comenzar a probar y, luego, iterar en el juego. Recuerda que, si bien puedes mantener la misma base de código, deberás adaptar el juego para que se sienta como un juego de PC nativo.

¿Qué sigue?

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

Por último, gran parte del trabajo que hiciste hasta ahora para admitir Google Play Juegos también te ayuda a realizar envíos en Chrome OS. Deberías considerar admitir esa plataforma junto con la PC.