Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Wrapper de Unity de la Sala de juegos experimental de YouTube

Con este wrapper, puedes acceder al SDK de Sala de juegos de YouTube en Unity C#. El wrapper tiene un complemento .jslib y un archivo C# para ayudarte a acelerar el desarrollo. También hay un proyecto de muestra que muestra cómo puedes usarlos en tu proyecto.

Los paquetes de Unity se pueden descargar desde nuestro repositorio de muestra de Playables sample repo.

Uso

Verifica que la plataforma de tu proyecto de Unity esté configurada como WebGL. Esta configuración se encuentra en Build Settings.
Usa el WebGLTemplate para compilar tu juego para la Web o sigue la sección Usa tu propio archivo index.html y verifica que hayas configurado e inicializado 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 Unity index.html. 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 a tu proyecto.
- GoogleYTGameWrapper.unitypackage: Contiene el complemento JS para conectar el SDK de Sala de juegos de YouTube y un wrapper de C# para ayudar a conectarlo a tu producto.
- GoogleYTGameWrapper-with-sample.unitypackage: Contiene el mismo contenido de archivos que los que se encuentran en el paquete GoogleYTGameWrapper y una muestra que muestra cómo usar el SDK de Sala de juegos de YouTube en C#.
IMPORTANTE: En tu escena principal, crea un objeto de juego nuevo y asígnale el nombre YTGameWrapper. Este objeto de juego se usa para comunicarse con el puente JS.
IMPORTANTE: Agrega el código importado YTGameWrapper.cs como un componente de secuencia de comandos al objeto de juego YTGameWrapper.
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 la secuencia de comandos y el objeto de juego permanezcan en todo el juego.
```
GameObject.DontDestroyOnLoad(this.gameObject);
```
El componente YTGameWrapper.cs y el objeto de juego YTGameWrapper se usan para conectarse al SDK de Sala de juegos de YouTube. Úsalos para conectarte a YouTube. Puedes usar la 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 Unity index.html.

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

    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#, pero no es la lista completa de las APIs disponibles. Para obtener la lista completa de las APIs disponibles, consulta el SDK de Sala de juegos de YouTube.

`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 Pause provenientes de Playables de YT para detener 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 Playables de YT:

...
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 Playables de YT:

...
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.
    }
}

`requestRewardedAd`

Este es un ejemplo de cómo usar requestRewardedAd. Se usa cuando un usuario seleccionó ver un anuncio recompensado a cambio de alguna recompensa en tu juego. Si hay un anuncio disponible, se le mostrará al usuario.

...
using YTGameSDK;
...

public YTGameWrapper ytGameWrapper;

...

public void RequestRewardedAd()
{
    // Register callback for Rewarded Ads. If an Ad is available one will be
    //  shown. Pause Game Callback should be called. Any ID is fine as long as
    //  its identifyable for your game.
    ytGameWrapper.RequestRewardedAd("my-reward-ad-id-123", (rewardEarned) => {
        if (rewardEarned) {
            // Rewarded Ad is earned, reward the user.
        } else {
            // Rewarded Ad not earned, take the appropriate action
        }
    });
}

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

A menos que tengas un proyecto de Unity muy pesado, tus 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 se debe realizar ninguna compresión adicional en tu extremo para estos archivos, ya que se comprimirán automáticamente cuando envíes tus archivos de Playables. 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 máximo de tamaño de archivo individual, es mejor usar la compresión ZIP para verificar que cumplan con este límite. La compresión de Playables no volverá a comprimir estos archivos.

Plantilla de WebGL

Sigue las instrucciones del paquete de Unity que se indican más arriba para la configuración inicial. Asegúrate de usar Google-WebGLTemplate-only.unitypackage o GoogleYTGameWrapper-with-sample.unitypackage y de importar todos los archivos de 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. Esta configuración se encuentra en Edit -> Project settings -> Player -> pestaña WebGL -> sección Resolution and Presentation.
- Nota: El ancho y la altura predeterminados del lienzo se establecen en 100% en la plantilla, por lo que esta configuración de Unity no ajustará nada.
Asegúrate de que tu Compression Format esté configurado como Inhabilitado. Esta configuración se encuentra en Project settings -> Player -> pestaña WebGL -> sección Publishing Settings.
Compila para WebGL en la ventana Build Settings y, luego, ve al paso 7 o 5 según las necesidades de tus proyectos.
Solo sigue los pasos 5 y 6 si se usa la 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 comprime estos archivos. Asegúrate de borrar los archivos .wasm/.data originales que se comprimieron, ya que enviarás los archivos *.wasm.zip y *.data.zip en su lugar.
- Nota: Si usas una Mac, puedes hacer clic con el botón derecho en el archivo y seleccionar "Comprimir *". En una PC, puedes hacer clic con el botón derecho en el archivo y seleccionar "Comprimir en archivo ZIP".
Solo sigue si realizaste el paso 5: Actualiza el archivo index.html compilado desde 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 se siguieron los pasos 5 y 6, incluye también estos archivos.

Actualiza las muestras proporcionadas para usar el canal de renderizado universal (URP)

Uno de los avances más recientes con las versiones más nuevas de Unity es que usan el canal de renderizado universal (URP). Para actualizar la muestra, de modo que todo se renderice correctamente.

Para comenzar, importa el paquete GoogleYTGameWrapper-with-sample.unitypackage a 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.
Luego, 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 mantenerse dentro de los requisitos de tamaño de archivo individuales y los requisitos de tamaño total del paquete.

La carga diferida de recursos es una excelente optimización que puedes realizar para tu proyecto, ya que puedes cargar recursos, niveles y datos según sea necesario. Nuestro equipo de certificación puede eximir las restricciones generales de tamaño de archivo si esto se realiza correctamente, ya que el juego completo no se cargará por adelantado, sino a medida que un usuario navegue por tu 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 que cargues contenido con el tiempo. Te sugerimos que uses Addressables o paquetes de recursos.

Addressables

Addressables te permite 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 los recursos.

Para usar Addressables, deberás importar el paquete Addressables a través del Administrador de paquetes 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 DLC, paquetes de niveles, personajes nuevos y mucho más. Los paquetes de recursos son excelentes para la carga y el empaquetado de contenido autoadministrado. Para usarlos, etiqueta tus recursos en paquetes específicos y, luego, carga los paquetes según los necesites. Puedes encontrar más detalles en la documentación de paquetes de recursos de Unity.

Consulta la referencia completa de la API de Playables de YT.

Wrapper de Unity de la Sala de juegos experimental de YouTube Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Uso