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 te permite llevar tu juego para dispositivos móviles a PCs con Windows fácilmente. Esto significa que puedes aumentar la participación de los jugadores y el público sin tener que rediseñar tu juego ni tu modelo de negocio. Aún debes realizar algunos cambios para brindar a los nuevos jugadores de PC la mejor experiencia posible.

Qué aprenderás

Este codelab abarca las partes básicas de la lista de tareas de requisitos para poner en marcha tu juego y te ayudará a preparar tu propio juego de Unity para Google Play Juegos para PC. No se abordan las integraciones más detalladas, como el inicio de sesión de Play Juegos y la API de Play Integrity.

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

Requisitos

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

2. Prepárate

Abre o crea un proyecto nuevo

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

2. Desde el proyecto, selecciona File -> Build Settings y verifica que puedas compilar para Android.

3. Prepara el emulador de Google Play Juegos

Comienza por descargar el emulador.

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

Nota: El emulador se muestra como Emulador para desarrolladores de Google Play Juegos en la lista de aplicaciones.

Este es un entorno de Android de alto rendimiento 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 empaquetada con Android Studio funciona, pero es posible que adb que se incluye con Unity no. Con el emulador, se incluye una versión compatible. Puedes encontrarla en C:\Program Files\Google\Play Games Developer Emulator\current\emulator. Para obtener la mejor experiencia como desarrollador, te recomendamos 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 compilar e implementar en el emulador directamente (opcional)

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

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 las pruebas. Ninguna de las versiones probadas de Unity al momento de este lanzamiento de escritura con un adb compatible.

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

Realiza una implementación 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 la versión del SDK de Android que se incluye con Unity probablemente no detecte el emulador, usa Android Studio para instalar un SDK más reciente.

1. Abre Android Studio y selecciona Edit ->. Preferencias -> Herramientas externas.
2. Desmarca 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). Deja la opción Android NDK sola.

Cuando actualices los dispositivos conectados, deberías ver 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 precedencia hasta que lo cambies y vuelvas a conectarte 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 las herramientas de compilación. Para ello, verifica que estás generando un mainTemplate.gradle y una launcherTemplate.gradle.

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

Nota: Los proyectos que usan 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 has usado una plantilla de Gradle personalizada, te recomendamos que también verifiques esta configuración.

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

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

5. Implementarla en una Chromebook (opcional)

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

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

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

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

Luego, habilita la depuración ADB.

3. Selecciona Configuración -> Desarrolladores -> Entorno de desarrollo de Linux -> Desarrolla apps para Android -> Habilita la depuración por ADB.

También te recomendamos que obtengas la dirección IP de tu Chromebook. La forma más fácil de hacerlo

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

5. Selecciona Ventana ->. Análisis -> Android Logcat para abrir la ventana Logcat de Android.

6. Abre la lista de dispositivos. Si no hay nada conectado actualmente, es posible que aparezca No Device.

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

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

Tu Chromebook ahora aparece en la lista de dispositivos de ejecución 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 a una PC.

6. Implementa una compilación de prueba

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

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

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

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

Nota: Cada arquitectura adicional que agregues aumentará el tiempo de compilación. Si bien puedes agrupar de forma segura todos tus objetivos ARM y x86 en un solo paquete, es posible que te convenga elegir solo x86 o x86-64 durante el desarrollo de la función.

La versión de los paquetes de Unity de la biblioteca de Frame Pacing tampoco es compatible con Google Play Juegos, y hace que el juego falle durante el inicio.

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

Ya está todo listo para la compilación.

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

Abrir terminal" destacado" style="width: 624.00px" src="img/9101ce3c95fb1aa2.png" Sizes="{max-width: 840px) 100vw, 856px">

7. Cómo adaptar tu juego para PC

Cuando sea posible, intenta hacer cambios en el 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 un monitor, por lo que 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 tus plataformas compatibles.

Si tiene sentido cambiar la lógica en función de si el jugador está en Google Play Juegos o ChromeOS, esta secuencia de comandos te ayudará a detectarlo mediante la verificación de 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. Siempre que sea posible, te recomendamos que tu HUD no ocupe más del 20% de la pantalla. Como muchos juegos para dispositivos móviles usan "Escalar con el tamaño de la pantalla", se cambia a "Tamaño físico constante". o "Tamaño de píxel constante" puede ser un buen primer paso para alcanzar este objetivo.

Es posible que también quieras establecer la configuración de calidad de forma dinámica 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 desde las emisiones de OpenGL de Unity, por lo que es probable que puedas lograr una fidelidad de gráficos mayor que la disponible en las compilaciones de tus juegos para dispositivos móviles.

8. Control de entradas

El envío de juegos en Google Play Juegos debe basarse en 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 necesario para adquirir el unitypackage del SDK de entrada. Si no ves una descarga en esa página, asegúrate de haber accedido con una cuenta del grupo play-mp-libs.

Para realizar pruebas, muchos juegos compilan controles básicos del mouse y del teclado para el desarrollo en el editor. Cuando sea posible, te recomendamos que los habilites cuando ejecutes la app en un dispositivo ChromeOS o en el emulador de Google Play Juegos.

Nota: Si actualmente usas #if UNITY_EDITOR para detectar si estás ejecutando en el editor, cámbialo a la verificación del 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, el juego seguirá funcionando como se esperaba. Si dependes de la entrada multitáctil, como los controles del pulgar doble o la acción de pellizcar para hacer zoom, debes asignar la acción a las pulsaciones de teclas. También debes asignar acciones en el juego a pulsaciones de teclas, como presionar i para abrir el inventario, escapar para cerrar los cuadros de diálogo e 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 tus vinculaciones de teclas preferidas para el siguiente paso.

9. Integración del SDK de entrada

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

1. Después de importar el SDK a tu proyecto, crea un archivo llamado InputMappingProviderBehaviour.cs y agrega el siguiente 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 el juego. Para el microjuego de plataformas en 2D, las acciones son Izquierda, Derecha y Salto:

private enum ActionIds
{
    Left,
    Right,
    Jump
}

3. En OnProvideInputMap, crea un InputAction para cada acción. Para esto, necesitas el nombre de la acción, la entrada y, luego, los botones del mouse o los códigos de teclas que estarán vinculados 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
        }
    }
};

4. A continuación, agrupa estas acciones de entrada.

Para el microjuego, solo hay 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 a la asignación de entrada. Modifica la sentencia return en OnProvideInputMap para que lea lo siguiente:

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 al juego:

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

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

10. Quitar vistas web incorporadas

Para brindar una excelente experiencia a los reproductores, debes quitar las vistas web incorporadas. Es común usar vistas web incorporadas para mostrar elementos como la Política de Privacidad o las Condiciones del Servicio. Aunque funcionan en Google Play Juegos, se muestran en un dispositivo móvil incorporado en lugar del navegador de escritorio preferido del reproductor, y puede causar cierta confusión para los reproductores de PC. Por lo tanto, en Unity, si usas alguna extensión para mostrar un navegador incorporado, recurre a Application.OpenURL(url).

11. Permisos y funciones

Hay algunas funciones y permisos de Android que no son compatibles con Google Play Juegos. Como regla general, la compilación para PC nunca debe mostrar un diálogo de permisos. Ahora que tienes la compilación lista, una buena opción es pasar por una instalación nueva típica y anotar todos los diálogos que veas para agregar a tu lista de tareas pendientes. lista para enviar tu juego.

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

12. Optimizaciones para computadoras de escritorio

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

Cambia a DXT para comprimir texturas. 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 de un reproductor. ASTC te brinda la mejor compatibilidad de escritorio, aunque debes usar una herramienta de generación de perfiles de GPU para computadoras de escritorio a fin de verificar el comportamiento esperado para tu juego.

Como ahora estás ejecutando en una GPU de escritorio, te recomendamos que aumentes la calidad de los gráficos. Puedes ajustarla directamente en la Configuración del proyecto, en Calidad.

13. Felicitaciones

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

¿Qué sigue?

Aún queda 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 de Acceso a los Servicios de juego de Play para que un jugador acceda automáticamente en el lanzamiento y ayude a cumplir con los requisitos de continuidad.
• Implementa la API de Play Integrity para asegurarte de que tu experiencia para PC sea tan segura como la de dispositivos móviles.

Por último, gran parte del trabajo que hiciste hasta este punto para brindar compatibilidad con Google Play Juegos también te ayuda a ofrecer apps en ChromeOS,por lo que deberías considerar admitir esa plataforma junto con tu PC.