Cette page a été traduite par l'API Cloud Translation.

Wrapper Unity Jeux intégrés YouTube expérimental

Ce wrapper vous permet d'accéder au SDK YouTube Playables dans Unity C#. Le wrapper comporte un plug-in .jslib et un fichier C# pour accélérer votre développement. Il existe également un exemple de projet qui montre comment les utiliser dans votre projet.

Les packages Unity peuvent être téléchargés depuis notre dépôt d'exemples Playables.

Utilisation

Vérifiez que la plate-forme de votre projet Unity est définie sur WebGL. Ce paramètre se trouve dans Build Settings.
Utilisez WebGLTemplate pour créer votre jeu pour le Web ou suivez la section Utiliser votre propre fichier index.html et vérifiez que vous avez configuré et initialisé le SDK Web dans votre fichier index.html.
- WebGLTemplate se trouve dans le package Google-WebGLTemplate-only.unitypackage ou GoogleYTGameWrapper-with-sample.unitypackage. Pour configurer et utiliser ce modèle, suivez les étapes de la section Modèle WebGL.
- Pour utiliser votre propre fichier Web et index.html, vous devez ajouter deux lignes à votre script de création index.html Unity. Pour l'intégration, consultez la section Utiliser votre propre fichier index.html.
Ouvrez votre projet dans Unity, puis ouvrez et importez l'un des packages dans votre projet.
- GoogleYTGameWrapper.unitypackage : contient le plug-in JS pour connecter le SDK Jeux intégrés YouTube et un wrapper C# pour vous aider à le connecter à votre produit.
- GoogleYTGameWrapper-with-sample.unitypackage : contient le même contenu de fichier que celui du package GoogleYTGameWrapper et un exemple montrant comment utiliser le SDK Jeux intégrés YouTube en C#.
IMPORTANT : Dans votre scène principale, créez un objet de jeu et nommez-le YTGameWrapper. Cet objet de jeu est utilisé pour communiquer avec le pont JS.
IMPORTANT : Ajoutez le code YTGameWrapper.cs importé en tant que composant de script à l'objet GameObject YTGameWrapper.
Si votre projet comporte plusieurs scènes, veillez à ajouter DontDestroyOnLoad au script YTGameWrapper.cs (remarque : les nouvelles versions du script disposent d'un bouton DontDestroyOnSceneChange qui est activé par défaut). Cela garantira que le script et le GameObject restent présents tout au long de votre jeu.
```
GameObject.DontDestroyOnLoad(this.gameObject);
```
Le composant YTGameWrapper.cs et l'objet GameObject YTGameWrapper sont utilisés pour se connecter au SDK YouTube Playables. Utilisez-les pour vous connecter à YouTube. Vous pouvez utiliser un script pour trouver l'objet et le composant, ou les ajouter manuellement à votre code de jeu via l'éditeur Unity.
Vérifiez que vous respectez les exigences techniques pour votre projet.

Utiliser votre propre fichier index.html

Si vous n'utilisez pas l'exemple index.html fourni, vous devrez ajouter deux lignes de code à votre script de création Unity index.html.

Tout d'abord, ajoutez cette ligne à l'endroit où votre projet configure les variables pour le conteneur Unity, le canevas, etc.

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

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

    ...

Ensuite, ajoutez cette ligne dans la fonction createUnityInstance.

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

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

    ...

Exemples

Cette section contient quelques exemples d'utilisation du wrapper C#. Il ne s'agit pas de la liste complète des API disponibles. Pour obtenir la liste complète des API disponibles, consultez le SDK YouTube Playables.

`sendScore`

Cet exemple montre une implémentation 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`

Voici un exemple de la façon dont un jeu peut écouter les événements Pause provenant des jeux intégrés YouTube pour mettre en pause son moteur si nécessaire :

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

Voici un exemple d'utilisation de saveData, en l'envoyant au SDK 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`

Voici un exemple d'utilisation de loadData, en l'envoyant au SDK 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`

Voici un exemple d'utilisation de requestInterstitialAd, qui indique que c'est le bon moment pour afficher une annonce interstitielle, si disponible. Pour de meilleurs résultats, effectuez cet appel pendant une pause dans le jeu, par exemple à la fin d'un niveau.

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

Utiliser l'exemple de modèle WebGL de YouTube

Sauf si votre projet Unity est très lourd, vos fichiers .wasm et .data compilés devraient être inférieurs à notre limite de taille de fichier individuelle. Si tel est le cas, vous ne devez pas compresser davantage ces fichiers, car ils seront automatiquement compressés lorsque vous les enverrez. Cette compression automatique permet également de vérifier que votre fichier .wasm respecte la taille requise pour le bundle initial. Par exemple, un fichier .wasm d'environ 25 Mio sera compressé à environ 7 Mio.

Si, pour une raison quelconque, vos fichiers dépassent la taille maximale autorisée, il est préférable d'utiliser la compression ZIP pour vérifier qu'ils respectent cette limite. La compression "playable" ne recompressera pas ces fichiers.

Modèle WebGL

Suivez les instructions ci-dessus concernant le package Unity pour la configuration initiale. Veillez à utiliser Google-WebGLTemplate-only.unitypackage ou GoogleYTGameWrapper-with-sample.unitypackage et à importer tous les fichiers du dossier WebGLTemplates/YTGameWrapperTemplate/.
- Remarque : Si vous n'avez pas encore importé YTGameWrapper.cs et UnityYTGameSDKLib.jslib, vous devez également les importer.
Configurez votre modèle WebGL pour utiliser YTGameWrapperTemplate. Ce paramètre se trouve dans Edit -> Project settings -> Player -> onglet WebGL -> section Resolution and Presentation.
- Remarque : La largeur et la hauteur du canevas par défaut sont définies sur 100 % dans le modèle. Par conséquent, ces paramètres Unity n'ajusteront rien.
Assurez-vous que votre Compression Format est défini sur "Désactivé". Ce paramètre se trouve dans Project settings -> Player -> onglet WebGL -> section Publishing Settings.
Créez pour WebGL dans la fenêtre Build Settings, puis passez à l'étape 7 ou 5 en fonction des besoins de votre projet.
Ne suivez les étapes 5 et 6 que si la compression est utilisée : une fois votre projet créé, accédez à l'emplacement de votre dossier de compilation et ouvrez le dossier Build. Recherchez les fichiers .wasm ou .data de vos projets qui doivent être compressés pour respecter les limites de taille de fichier individuelles, puis compressez-les. Veillez à supprimer les fichiers .wasm/.data d'origine qui ont été compressés, car vous allez envoyer les fichiers *.wasm.zip et *.data.zip à la place.
- Remarque : Si vous utilisez un Mac, vous pouvez effectuer un clic droit sur le fichier et sélectionner "Compresser *". Sur un PC, vous pouvez effectuer un clic droit sur le fichier et sélectionner "Compresser au format ZIP".
À suivre uniquement si vous avez effectué l'étape 5 : Mettez à jour le fichier index.html créé à partir de YTGameWrapperTemplate pour charger les fichiers compressés et les décompresser.
- Vers la fin des fichiers index.html, vous trouverez Path 1. Mettez en commentaire la ligne suivante : InitUnitySection();.
- Vers la fin des fichiers index.html, vous trouverez Path 2. Mettez en commentaire la ligne suivante : loadResources(InitUnitySection);.
Lorsque vous soumettez votre projet à la certification, vous devez envoyer tous les fichiers créés à partir d'Unity à l'emplacement de compilation de l'étape 4. Si vous avez suivi les étapes 5 et 6, incluez également ces fichiers.

Mettre à niveau les exemples fournis pour utiliser le pipeline de rendu universel (URP)

L'une des dernières avancées des nouvelles versions d'Unity est qu'elles utilisent le pipeline de rendu universel (URP). Pour mettre à niveau l'exemple afin que tout s'affiche correctement.

Commencez par importer le package GoogleYTGameWrapper-with-sample.unitypackage dans un projet nouveau ou existant.
Accédez à la fenêtre Render Pipeline Converter : Window > Rendering > Render Pipeline Converter.
Sélectionnez Rendering Settings, Material Upgrade et Readonly Material Converter.
Sélectionnez ensuite Initialize and Convert, attendez la fin de l'opération, et l'échantillon devrait être prêt pour URP.

Fractionner les éléments de votre projet Unity (chargement différé)

L'un des principaux problèmes que les développeurs ont soulignés lors de l'utilisation d'Unity est de respecter les exigences concernant la taille des fichiers individuels et la taille totale du bundle.

Le chargement différé des éléments est une excellente optimisation que vous pouvez effectuer pour votre projet, car vous pouvez charger les éléments, les niveaux et les données au fur et à mesure de vos besoins. Notre équipe de certification peut renoncer aux restrictions générales concernant la taille des fichiers si cela est fait correctement, car votre jeu complet ne sera pas chargé au début, mais au fur et à mesure que l'utilisateur navigue dans votre produit.

Pour faciliter le chargement correct, Unity propose plusieurs façons de diviser vos éléments, en vérifiant que vos groupes d'éléments individuels respectent les limites de taille et que vous chargez le contenu au fil du temps. Nous vous suggérons d'utiliser Addressables ou AssetBundles.

Système Addressables

Les Addressables vous permettent d'identifier différents fichiers qui doivent être chargés ensemble. Unity gère la majeure partie de l'empaquetage pour vous. Unity fournit également des outils pour gérer la taille des fichiers et vous aider à éviter de dupliquer des éléments.

Pour utiliser les Addressables, vous devez importer le package Addressables via le gestionnaire de packages dans Unity, puis taguer vos éléments dans des groupes Addressables. Pour en savoir plus, consultez la documentation Unity.

Bundles de composants

Les bundles d'éléments sont utiles, car ils vous permettent de diviser votre projet et de charger des éléments à la volée. Ils sont utiles pour les contenus téléchargeables, les packs de niveaux, les nouveaux personnages et plus encore. Les bundles d'éléments sont idéaux pour le chargement et le regroupement de contenu autogérés. Pour ce faire, vous pouvez taguer vos assets dans des bundles spécifiques, puis charger les bundles selon vos besoins. Pour en savoir plus, consultez la documentation d'Unity sur les bundles d'éléments.

Consultez la documentation de référence complète de l'API YT Playables.