Se usó la API de Cloud Translation para traducir esta página.

Wrapper de Unity de la Sala de juegos experimental de YouTube

Con este wrapper, puedes acceder al SDK de Playables de YouTube en C# de Unity. El wrapper tiene un complemento .jslib y un archivo C# para acelerar tu desarrollo. También hay un proyecto de ejemplo que muestra cómo puedes usar estos elementos en tu proyecto.

Los paquetes de Unity se pueden descargar desde nuestro repositorio de muestras de Playables.

Uso

Verifica que la plataforma de tu proyecto de Unity esté configurada como WebGL. Este parámetro de configuración se encuentra en Build Settings.
Usa WebGLTemplate para compilar tu juego para la Web o sigue la sección Usa tu propio archivo index.html y verifica que configuraste e inicializaste el SDK web en tu archivo index.html.
- WebGLTemplate se puede encontrar en el paquete Google-WebGLTemplate-only.unitypackage o GoogleYTGameWrapper-with-sample.unitypackage. Para configurar y usar esta plantilla, sigue los pasos de la sección Plantilla de WebGL.
- Para usar tu propio archivo web y index.html, deberás agregar dos líneas a tu secuencia de comandos de creación de index.html Unity. Consulta la sección Usa tu propio archivo index.html para la integración.
Abre tu proyecto en Unity y, luego, abre e importa cualquiera de los paquetes en tu proyecto.
- GoogleYTGameWrapper.unitypackage: Contiene el complemento de JS para conectar el SDK de Sala de juegos de YouTube y un wrapper de C# para ayudar a conectar esto a tu producto.
- GoogleYTGameWrapper-with-sample.unitypackage: Contiene el mismo contenido de archivos que los que se encuentran en el paquete GoogleYTGameWrapper y un ejemplo que muestra cómo usar el SDK de Sala de juegos de YouTube en C#.
IMPORTANTE: En tu escena principal, crea un nuevo objeto de juego y asígnale el nombre YTGameWrapper. Este objeto de juego se usa para comunicarse con el puente de JS.
IMPORTANTE: Agrega el código YTGameWrapper.cs importado como un componente de secuencia de comandos al objeto YTGameWrapper GameObject.
Si tu proyecto tiene varias escenas, asegúrate de agregar DontDestroyOnLoad a la secuencia de comandos YTGameWrapper.cs (nota: Las versiones nuevas de la secuencia de comandos tienen un botón de activación DontDestroyOnSceneChange que está activado de forma predeterminada). Esto garantizará que el script y el GameObject permanezcan en todo el juego.
```
GameObject.DontDestroyOnLoad(this.gameObject);
```
El componente YTGameWrapper.cs y el objeto GameObject YTGameWrapper se usan para conectarse al SDK de YouTube Playables. Úsalos para conectarte a YouTube. Puedes usar una secuencia de comandos para encontrar el objeto y el componente, o bien agregarlos manualmente al código del juego a través del editor de Unity.
Verifica que cumplas con los requisitos técnicos de tu proyecto.

Usa tu propio archivo index.html

Si no usas el ejemplo de index.html proporcionado, deberás agregar dos líneas de código a tu secuencia de comandos de creación de index.html Unity.

Primero, agrega esta línea en el mismo lugar en el que tu proyecto configura variables para el contenedor de Unity, el lienzo, etcétera.

    var container = document.querySelector("#unity-container");
    var canvas = document.querySelector("#unity-canvas");

    var unityGameInstance = null; // <-- Add this line >

    ...

En segundo lugar, dentro de la función createUnityInstance, agrega esta línea.

    createUnityInstance(canvas, config, (progress) => {
        progressBarFull.style.width = 100 * progress + "%";
    }).then((unityInstance) => {

        unityGameInstance = unityInstance; // <-- Add this line >

    ...

Ejemplos

En esta sección, se incluyen algunos ejemplos de cómo usar el wrapper de C#. No se trata de la lista completa de APIs disponibles. Para obtener la lista completa de las APIs disponibles, consulta el SDK de YouTube Playables.

`sendScore`

En este ejemplo, se muestra una implementación de sendScore(int points) en C#:

...
using YTGameSDK;
...

public YTGameWrapper ytGameWrapper;
public int battleScore = 0;

...

// Update the total score and send this to the YouTube Game Wrapper.
public void UpdateScores(int scoreAmt)
{
    battleScore += scoreAmt;
    // ytGameWrapper should be a reference to your YTGameWrapper component.
    ytGameWrapper.SendGameScore(battleScore);
}

`onPause`

Este es un ejemplo de cómo un juego puede detectar eventos de Pause provenientes de YT Playables para pausar su motor cuando sea necesario:

...
using YTGameSDK;
...

public YTGameWrapper ytGameWrapper;
public bool gameIsPaused = false;

...
void Start()
{
    // Sets the OnPause callback with the YT Playables SDK
    ytGameWrapper.SetOnPauseCallback(PauseTheGameCallback);
}

// Pause game callback, will pause the game when called.
public void PauseTheGameCallback()
{
    gameIsPaused = true;
}

`saveData`

Este es un ejemplo de cómo usar saveData y enviarlo al SDK de YT Playables:

...
using YTGameSDK;
...

public YTGameWrapper ytGameWrapper;

...

// Saves the current score of the game and converts it to a JSON format.
public void SaveScore(int scoreAmt)
{
    SaveGameData("{\"BestScore\": \"" + scoreAmt.ToString() + "\"}");
}

public void SaveGameData(string saveString)
{
    if (string.IsNullOrEmpty(saveString)) return;

    // Sends save data to the YT Playables SDK
    ytGameWrapper.SendGameSaveData(saveString);
}

`loadData`

Este es un ejemplo de cómo usar loadData y enviarlo al SDK de YT Playables:

...
using UnityEngine;
using YTGameSDK;
...

[Serializable]
public class LoadedScores
{
    public int BestScore;
    public float BestTime;
}

public YTGameWrapper ytGameWrapper;

...

void Start()
{
    ytGameWrapper.LoadGameSaveData(LoadSaveGameDataReturned);
}

public void LoadSaveGameDataReturned(string data)
{
    if (!string.IsNullOrEmpty(data))
    {
        LoadedScores loadedScores = JsonUtility.FromJson<LoadedScores>(data);
        Debug.Log("LoadSaveGameDataReturned > Score <" + loadedScores.BestScore.ToString()
                  +   "> Time <" + loadedScores.BestTime.ToString("0.00"));
    }
}

`requestInterstitialAd`

Este es un ejemplo de cómo usar requestInterstitialAd, que indica que es un buen momento para mostrar un anuncio intersticial, si está disponible. Para obtener los mejores resultados, realiza esta llamada durante un descanso en el juego, por ejemplo, al final de un nivel.

...
using YTGameSDK;
...

public YTGameWrapper ytGameWrapper;

...

// At the end of a round send a request to show an interstitial Ad, if one is
//  available an Ad will be shown and Pause Game Callback should be called.

// EXAMPLE: send and forget
public void RequestInterstitialAd()
{
    ytGameWrapper.RequestInterstitialAd();
}

// EXAMPLE: send and react to if an Ad was shown
public void RequestInterstitialAd()
{
    int status = ytGameWrapper.RequestInterstitialAd();
    if (status == 0)
    {
        // Ad request was successful, do some action.
    }
}

Cómo usar la plantilla de ejemplo de WebGL de YouTube

A menos que tengas un proyecto de Unity muy pesado, los archivos .wasm y .data compilados deberían estar dentro de nuestro límite de tamaño de archivo individual. Si este es el caso, no debes realizar ninguna compresión adicional en estos archivos, ya que se comprimirán automáticamente cuando envíes tus archivos de Playable. Esta compresión automática también verificará que tu archivo .wasm cumpla con el requisito de tamaño del paquete inicial. Por ejemplo, un archivo .wasm de ~25 MiB se comprimirá a ~7 MiB.

Si, por algún motivo, tus archivos superan el límite de tamaño máximo de archivo individual, lo mejor es usar la compresión ZIP para verificar que se ajusten a este límite. La compresión reproducible no volverá a comprimir estos archivos.

Plantilla de WebGL

Sigue las instrucciones anteriores para el paquete de Unity para la configuración inicial. Asegúrate de usar Google-WebGLTemplate-only.unitypackage o GoogleYTGameWrapper-with-sample.unitypackage y de importar todos los archivos en la carpeta WebGLTemplates/YTGameWrapperTemplate/.
- Nota: Si aún no importaste YTGameWrapper.cs y UnityYTGameSDKLib.jslib, también deberías importarlos.
Configura tu plantilla de WebGL para usar YTGameWrapperTemplate. Este parámetro de configuración se encuentra en la pestaña Edit -> Project settings -> Player -> WebGL -> sección Resolution and Presentation.
- Nota: El ancho y la altura predeterminados del lienzo se establecen en el 100% en la plantilla, por lo que estos parámetros de configuración de Unity no ajustarán nada.
Asegúrate de que tu Compression Format esté configurado como Inhabilitado. Este parámetro de configuración se encuentra en la sección Project settings -> Player -> pestaña WebGL -> Publishing Settings.
Compila para WebGL en la ventana Build Settings y, luego, ve al paso 7 o 5 según las necesidades de tu proyecto.
Solo sigue los pasos 5 y 6 si se usa compresión: Después de compilar tu proyecto, navega a la ubicación de la carpeta de compilación y abre la carpeta Build. Busca los archivos .wasm o .data de tus proyectos que necesiten compresión para ajustarse a los límites de tamaño de archivo individuales y comprímelos. Asegúrate de borrar los archivos originales .wasm/.data que se comprimieron, ya que enviarás los archivos *.wasm.zip y *.data.zip.
- Nota: Si usas una Mac, puedes hacer clic con el botón derecho en el archivo y seleccionar "Comprimir *". En PC, puedes hacer clic con el botón derecho en el archivo y seleccionar "Comprimir en archivo ZIP".
Solo sigue este paso si completaste el paso 5: Actualiza el archivo index.html compilado a partir de YTGameWrapperTemplate para cargar archivos comprimidos y descomprimirlos.
- Cerca del final de los archivos index.html, encontrarás Path 1 y comentarás la siguiente línea InitUnitySection();.
- Cerca del final de los archivos index.html, encontrarás Path 2 y comentarás la siguiente línea loadResources(InitUnitySection);.
Cuando envíes tu proyecto para la certificación, deberás enviar todos los archivos compilados desde Unity a la ubicación de compilación del paso 4. Si seguiste los pasos 5 y 6, incluye también estos archivos.

Actualiza las muestras proporcionadas para usar la canalización universal de renderizaciones (URP)

Uno de los avances más recientes de las versiones más nuevas de Unity es que usan la canalización universal de renderizaciones (URP). Actualizar la muestra para que todo se renderice correctamente

Para comenzar, importa el paquete GoogleYTGameWrapper-with-sample.unitypackage en un proyecto nuevo o existente.
Navega a la ventana Render Pipeline Converter: Window -> Rendering -> Render Pipeline Converter.
Selecciona Rendering Settings, Material Upgrade y Readonly Material Converter.
A continuación, selecciona Initialize and Convert, espera a que finalice y la muestra debería estar lista para URP.

Cómo dividir los recursos en tu proyecto de Unity (carga diferida)

Uno de los principales problemas que destacaron los desarrolladores cuando usan Unity es cumplir con los requisitos de tamaño de archivo individual y los requisitos de tamaño total del paquete.

La carga diferida de recursos es una excelente optimización que puedes realizar en tu proyecto, ya que puedes cargar recursos, niveles y datos a medida que se necesiten. Nuestro equipo de certificación puede renunciar a las restricciones generales de tamaño de archivo si esto se hace correctamente, ya que el juego completo no se cargará por adelantado, sino a medida que el usuario navegue por el producto.

Para ayudar con la carga adecuada, Unity tiene varias formas de dividir tus recursos, verificar que tus grupos de recursos individuales estén dentro de los límites de tamaño y cargar contenido con el tiempo. Te sugerimos que uses Addressables o Asset Bundles.

Addressables

Los Addressables te permiten identificar diferentes archivos que se deben cargar juntos, y Unity se encargará de la mayor parte del empaquetado por ti. Unity también proporciona algunas herramientas para administrar los tamaños de los archivos y ayudarte a asegurarte de que no dupliques activos.

Para usar Addressables, deberás importar el paquete de Addressables a través de Package Manager en Unity y, luego, etiquetar tus recursos en grupos de Addressables. Puedes encontrar más detalles en la documentación de Unity.

Paquetes de recursos

Los paquetes de recursos son útiles, ya que puedes dividir tu proyecto y cargar elementos sobre la marcha. Son útiles para el contenido descargable, los paquetes de niveles, los personajes nuevos y mucho más. Los paquetes de recursos son ideales para la carga y el empaquetado de contenido autoadministrado. Puedes usar estos recursos etiquetándolos en paquetes específicos y, luego, cargando los paquetes cuando los necesites. Puedes encontrar más detalles en la documentación de los paquetes de recursos de Unity.

Consulta la referencia completa de la API de YT Playables.