Cherchez Unity

Au-dela de la mobilité

Tirez profit de la popularité de Windows 10 et des nouvelles opportunités de marché dans le Windows Store.

Guides de portage

Introduction

Unity est un outil de plus en plus populaire pour la création de jeux vidéo, notamment parce qu'il permet d'accéder à de multiples plateformes et types d'appareils à partir d'un code unique. Cela est également vrai pour la création de jeux pour Windows 10 avec la Universal Windows Platform (UWP). Ce livre blanc vous explique comment exploiter ce que vous savez déjà de Unity pour créer des jeux pour UWP. Les sujets traités incluent :

  • compiler votre jeu pour UWP
  • comprendre les meilleures pratiques de l'environnement Windows
  • implémenter des fonctionnalités spécifiques aux plateformes
  • comprendre les principaux modules additionnels
  • publier sur le Windows Store

Pour d'illustrer le processus de publication d'un jeu sur UWP, nous utiliserons un jeu existant afin d'analyser les différents aspects les problématiques liés à l'exportation d'un jeu Unity sur UWP et à son déploiement sur le Windows Store.

Remarque : Ce guide part du principe que vous connaissez déjà les bases de Unity3D. Vous pouvez en apprendre plus sur l'utilisation de Unity3D à tout moment en consultant les tutoriels Unity.

Configuration pour concevoir un jeu UWP avec Unity

Pour développer, compiler et soumettre un jeu Unity sur le Windows Store, vous aurez besoin de :

  • Unity 5.3.5. Les versions gratuite et Pro fonctionnent. Les modules additionnels pour la publication sur le Windows Store sont gratuits pour les utilisateurs de ces deux versions.
  • Visual Studio. Vous pouvez utiliser tous les SKU Visual Studio, y compris l'outil gratuit Visual Studio Express. Si vous ciblez la plateforme Universal Windows Platform, vous devrez utiliser Visual Studio 2015 Update 1.
  • Windows 10. Si vous ne possédez pas de licence Windows 10, vous pouvez obtenir une version d'essai de 90 jours. Si vous utilisez Mac OS X ou si vous installez sur du matériel Apple, analysez les différentes options pour installer via Boot Camp, VMWare, ou Parallels.
  • Compte Microsoft. Pour obtenir une licence développeur, vous avez besoin d'un compte Microsoft gratuit.
  • Compte développeur Windows Store. Vous en aurez besoin pour soumettre votre jeu au Windows Store. Pendant le processus, vous devrez vous inscrire et suivre le processus de validation en tant que particulier ou qu'entreprise éligible à la soumission de jeux et d'applications dans la boutique. Cette inscription est partagée avec Windows Phone (une inscription suffit pour soumettre l'application dans les deux boutiques). Des frais d'inscription peuvent s'appliquer aux particuliers, mais les comptes gratuits Dev Center sont souvent disponibles via des programmes sponsorisés par Microsoft (notamment pour les étudiants et les startups).
  • Appareils de test Windows 10. Le simulateur simule la fonctionnalité tactile et différentes résolutions d'affichage, mais nous vous recommandons de tester votre application sur un véritable appareil mobile ARM avec fonction tactile si vous développez une expérience mobile/tactile.

Ce document a été créé avec Unity 5.3.5, Visual Studio 2015 Update 2 et Windows 10 Version 1511. Nous vous conseillons d'utiliser Unity 5.3.2 et Visual Studio Update 1 ou des versions supérieures. L'interface de programmation des versions plus anciennes peut être différente et il peut y avoir des problèmes de compatibilité.

Windows Store

Windows Store propose désormais un espace unique pour soumettre et télécharger vos applications UWP. Vous pouvez toujours cibler des appareils utilisant d'anciens systèmes d'exploitation, mais pour ce document nous nous concentrerons sur la soumission de votre jeu comme application UWP au Windows Store.

NuGet

NuGet est le gestionnaire de packages de la plateforme de développement de Microsoft incluant .NET. Il permet aux développeurs de trouver des bibliothèques tierces et de les ajouter à leurs projets en tant que dépendances. Vous pouvez ainsi utiliser NuGet pour exploiter toute bibliothèque Windows que souhaitez utiliser en natif. NuGet permet également de gérer les DLL appelés par vos scripts dans Unity.

NuGet est indispensable pour porter des jeux Unity sur UWP. Lorsque vous exportez un projet depuis Unity vers une application Visual Studio UWP, Unity dépend de NuGet pour installer toutes les bibliothèques nécessaires pour cibler.NET Core.

Paramétrer Unity pour déployer sur le Windows Store

Dans cette section, nous allons analyser les éléments nécessaires pour faire d'un jeu existant une application prête à être déployée sur le Windows Store en tant que jeu Universal Windows Platform (UWP). Nous étudierons les points suivants :

  • Activez le mode développeur dans Windows 10
  • Saisissez les détails du jeu dans Unity
  • Exportez en UWP sous Windows 10
  • Solution de compilation dans Visual Studio 2015 Update 2 avec le kit de développement Window 10
  • Associez votre jeu au Windows Store
  • Ajoutez des images/contenus (logo, icône, écran) si vous ne l'avez pas déjà fait dans Unity
  • Exécutez le Windows App Certification Kit (WACK)
  • Publiez sur le Windows Store

Activez le mode développeur dans Windows 10

La licence développeur n'est plus nécessaire pour chaque appareil que vous utilisez pour développer, installer ou tester votre application. Vous pouvez désormais activer un appareil une seule fois pour ces tâches via les paramètres de l'appareil.

Activez vos appareils Windows 10

Pour Windows 10, que vous utilisiez un ordinateur, une tablette ou un téléphone, vous devez activer cet appareil pour le développement dans les paramètres système.

Pour ce faire, affichez les paramètres du systèmes et sélectionnez Update & security. Puis sélectionnez For developers. Vous pouvez alors sélectionner et activer Developer mode.

Vous trouverez plus d'informations sur cette opération ici.

Saisissez les détails du jeu dans Unity

L'une des premières étapes consiste à vous assurer que vos paramètres de compilation sont corrects.

Pour compiler des jeux Unity pour les applications Windows Platform (UWP), vous avez besoin des éléments suivants :

Pour configurer vos paramètres dans Unity, cliquez sur File, puis sur Build Settings.

Cliquez ensuite sur le bouton Paramètres du lecteur… .

Dans la fenêtre Player Settings vous pouvez saisir les détails relatifs à votre jeu.

Si vous le souhaitez, vous pouvez également ajouter un logo et des images de présentation dans Player Settings la fenêtre qui s'affichera dans le Windows Store. Et comme pour la plupart des étapes de la création d'applications pour le Windows Store, plusieurs solutions s'offrent à vous. Vous pouvez également reporter l'ajout d'images via l'IDE Unity et le faire plus tard avec Visual Studio.

Vos paramètres de compilation sont désormais corrects dans Unity 3D. Vous pouvez exporter vers UWP.

Exporter vers Universal Windows Platform

Cette section est consacrée au support Unity existant pour les applications Universal Windows Platform (UWP) et à leur exportation de Unity vers UWP.

Unity3D est compatible avec les applications UWP depuis Unity 5.2. Vous pouvez actuellement exporter vers UWP en sélectionnant le kit de développement Universal 10 depuis la plateforme Windows Store dans la fenêtre Build Settings, comme illustré ci-dessous :

Unity 5.3.5 exportera les fichiers de solutions de Visual StudioStudio 2015, qui pourront ensuite être compilés et exécutés sur des appareils Windows 10.

Trois architectures sont prises en charge : ARM, x86 et x64. Vous pouvez également utiliser .NET Core 5.0 dans vos projets de jeux.

Cliquez sur le bouton Build de la fenêtre Build Settings pour ouvrir une fenêtre Build Windows Store qui vous permettra de choisir le dossier pour compiler votre jeu.

Une fois le dossier sélectionné, Unity commencera à compiler votre jeu pour la plateforme ciblée. Cela peut nécessiter plusieurs minutes pour les jeux de grande envergure :

Une fenêtre Windows Explorer s'affiche désormais dans le dossier qui contient tous les fichiers générés par Unity.

Pour plus d'informations sur ce processus, consultez la documentation Unity3D sur Windows.

Solution de compilation dans Visual Studio 2015 Update 2 avec le kit de développement Window 10

Pour commercialiser ou de distribuer votre application Universal Windows PlatformPlatform (UWP), vous devez créer un package appxupload qui simplifiera la vente sur le Windows Store ou la distribution à d'autres utilisateurs. Lorsque vous créez l'appxupload, un autre package appx sera généré pour l'utilisation, et le test. Vous pouvez distribuer votre application directement en téléchargeant le package appx vers un appareil.

Pour Windows 10, vous pouvez générer un package (.appxuploadappxupload) à télécharger sur le Windows Store. Votre application pourra ensuite être installé et exécutée sur tous les appareils Windows 10.

Remarque : Pour créer un package d'application pour une application 8.1, suivez ces instructions.

Vous êtes prêt à compiler votre jeu dans Visual Studio.

Pour commencer, sélectionnez la plateforme x86 ou x64.

Dans le menu, cliquez sur Build -> Build Solution.

Autorisez le Manager de packages NuGet à restaurer des packages.

Cliquez sur Run et assurez-vous que vous avez sélectionné Local Machine.

Vérifiez que la compilation fonctionne.

Vous êtes désormais prêt à vendre votre application dans le Windows Store. Si vous avez conçu une application LOB (destinée uniquement à des utilisateurs internes), vous pouvez la télécharger pour l'installer sur tous les appareils Windows 10.

Pour plus d'informations, consultez Packaging Universal Windows apps for Windows 10

Associez votre application au Windows Store

Dans le Projetmenu, sélectionnez Store -> Associate App with the Store....

La plupart des champs de l'onglet Packaging seront automatiquement mis à jour. Les valeurs suivantes sont téléchargées vers le fichier de l'application pour le projet en cours sur votre machine locale :

  • Package Display Name
  • Package Name
  • Publisher ID
  • Publisher Display Name
  • Version

Si vous écrasez le fichier package.appxmanifest par défaut en créant un fichier .xml personnalisé , vous ne pouvez pas associer votre application à la boutique. Si vous essayez d'associer un fichier personnalisé, un message d'erreur s'affichera. Nus vous déconseillons de créer un package personnalisé.

Pour plus d'informations, consultez Créer des packages d'applications Universal Windows pour Windows 10.

Préparez votre application pour la boutique

Une fois votre application créée en réservant un nom, vous pouvez commencer à travailler sur sa publication. La première étape est de soumettre votre application.

Le moment idéal pour commencer le processus de soumission est lorsque votre application est terminée et prête à être publiée. Vous pouvez toutefois saisir les informations avant même d'avoir écrit une ligne de code. La soumission sera enregistrée sur votre tableau de bord et vous pourrez y travailler dès que vous serez prêt.

Une fois votre application en ligne, vous pouvez publier une version actualisée en créant une nouvelle soumission sur votre tableau de bord. Vous pourrez ainsi effectuer les changements nécessaires et les publier, que vous téléchargiez de nouveaux packages ou que vous changiez simplement des détails comme le prix ou la catégorie.

Pour créer une nouvelle soumission d'application, cliquez sur Update près de la soumission la plus récente affichée sur la page d'aperçu des applications.

Checklist de soumission d'application

Unity vous fournir les ressources minimales requises pour la soumission d'une application. Nous vous recommandons d'utiliser vos propres images et ressources. Voici une capture d'écran de la section Visual Assets du fichier Package.appxmanifest :

Vous avez un aperçu de toutes les ressources fournies par le processus de compilation.

Pour plus d'informations, consultez Soumission d'applications sur MSDN.

Exécutez le Windows App Certification Kit (WACK)

Pour donner à votre application toutes les chances d'être publiée sur le Windows Store, ou d'obtenir la certification Windows, validez-la et testez-la localement avant de la soumettre à la certification. Cette section explique comment installer et exécuter le kit de certification Windows App. WACK exécutera une série de tests sur votre application afin d'évaluer la conformité des performances et de l'API. Pour plus d'informations sur les tests réalisés par ce kit, consultez les sections suivantes :

Prérequis

Si vous développez une application Universal Windows Platform (UWP) vous devez…

Pour installer le kit de certification Windows App version 10 (inclus dans le kit de développement Windows Software pour Windows 10), commencez par créer un package d'application pour procéder au test. Dans le menu Project, sélectionnez Store -> Create App Packages… :

Une fois la création du package terminée, la fenêtre suivante s'affichera et vous pourrez y lancer le kit de certification Windows App (WACK) :

La fenêtre suivante s'ouvre lors du lancement du WACK :

Cliquez sur suivant pour continuer la validation. Ne vous inquiétez pas plusieurs fenêtres s'ouvrent : l'outil exécute votre jeu et effectue des tests qui peuvent nécessiter plusieurs minutes.

Une fois les tests terminés, la fenêtre suivante s'affichera. Si les tests échouent, vous pourrez les analyser et apporter des corrections pour recommencer le processus et réussir les tests.

Cliquez sur le lien Click here to view the results pour afficher les résultats des tests dans un navigateur.

Ici vous pouvez consulter les résultats de tous les tests, identifier les problèmes et les corriger. Une fois les problèmes corrigés et les tests relancés, vous devriez obtenir les résultats suivants :

Pour plus d'informations, consultez Utilisation du kit de certification Windows App sur MSDN.

Publiez sur le Windows Store

Maintenant que votre jeu est compilé et téléchargé, vous devez accéder à votre compte développeur pour le soumettre à la boutique. Suivez ces étapes pour commencer le processus de soumission.

  1. Ouvrez https://dev.windows.com dans un navigateur.
  2. Connectez-vous à votre compte et cliquez sur le lien du tableau de bord.
  3. Sélectionnez le nom du package d'application que vous avez créé dans Visual Studio.
  4. Cliquez sur Start your submission.
  5. Pour cette étape, vous devrez saisir les information relatives à votre jeu pour pouvoir le soumettre. Cliquez sur l'un de ces liens pour ouvrir une nouvelle page qui vous guidera dans le processus de soumission.

La page page is where you upload all of the package files (.xap, .appx, .appxupload, et/ou .appxbundle) for the app that you are submitting. You can upload packages for any operating system that your app targets in this step.

Lorsqu'un utilisateur télécharge votre application, Windows Store analysera les packages de votre application disponibles et fournira automatiquement à chaque client le package le mieux adapté à son appareil.

Pour plus d’informations sur ce qu'inclut un package et comment il doit être structuré, consultez Exigences relatives au package d'application. Vous avez peut-être envie de découvrir…

Téléchargez des packages pour votre soumission

Pour télécharger des packages, faites-les glisser dans le champ de téléchargement ou cliquez pour parcourir vos fichiers. La page page vous permettra de télécharger des .xap, .appx, .appxupload, and/or .appxbundle .

Remarque : Pour Windows 10, vous devez toujours télécharger le fichier .appxupload ici, par le fichier .appx ou .appxbundle. Pour plus d'informations sur la création de packages d'applications Universal Windows Platform (UWP) pour la boutique, consultez Créer des packages d'applications Universal Windows pour Windows 10.

Si des problèmes sont détectés dans vos packages pendant le processus de validation, vous devrez les supprimer, corriger les erreurs puis les télécharger à nouveau. Pour plus d'informations, consultez Corrigez les erreurs de téléchargement du package.

Implémentation du référencement

Dans cette section, nous allons référencer un jeu de basketball en 3D simple écrit par Jb Evain en moins de 20 minutes. Si vous souhaitez créer le jeu depuis le début, vous pouvez suivre le discours de Jb. La seule ressource extérieure dont vous avez besoin pour créer le jeu est le fichier Hoop.3ds.

Si vous préférez télécharger le package du projet fini, Basketball-At-Build.zip, celui-ci est terminé et jouable. Vous pourrez suivre la suite de cette section une fois le fichier compressé extrait.

Voici une scène du jeu terminé :

Basket-ball

Dans les prochaines étapes, nous allons utiliser un jeu pour illustrer les étapes précédentes et le préparer à la soumission sur le Windows Store.

Si vous créez un jeu depuis le début, vous devez suivre ces étapes. Si vous avez téléchargé le projet terminé, passez les étapes 1 à 8.

  1. Ouvrez Unity et créez un nouveau projet. Projet Vous pouvez l'appeler Basket-ball ou Jeu génial !
  2. Créez une scène de jeu.
  3. Faites glisser Hoop.3ds de son emplacement de téléchargement vers l'espace des ressources.
  4. Sélectionnez Assets -> Import Packages -> Characters.
  5. Une fois la ressource téléchargée, cliquez sur Importez Import. La ressource sera alors importée dans votre projet.
  6. Créez une sphère et appliquez des matières pour ajouter couleurs et reliefs.
  7. Placez les composants dans la scène.
  8. Écrivez le script Shooter pour pouvoir lancer les ballons dans le panier de basket.
  9. Dans l'onglet, Projet développez l'arbre des ressources et cliquez sur le dossier des scènes.
  10. Double-cliquez sur Jeu la scène pour la charger. Avant d'aller plus loin, exécutons le jeu pour voir comment il fonctionne.
  11. Maintenant que nous savons que le jeu fonctionne, nous pouvons tester nos compétences !

Créez un projet Visual Studio avec Unity

Maintenant que vous avez importé et testé votre jeu dans Unity, nous pouvons créer une une solution Visual Studio.

Dans le menu, cliquez sur Fichier | Paramètres de compilation… pour ouvrir la fenêtre Build Settings et vous assurer qu'une scène est sélectionnée dans l'aperçu Scenes In Build vue. Assurez-vous que…

  • Plateforme est réglé sur Windows Store (if it is not, click Windows Store -> Switch Platform).
  • Kit de développement est réglé sur Universal 10.
  • Compilation UWP est réglé sur XAML.
  • Projets Unity C# et Compilation de développement sont cochés.

Cliquez ensuite sur Paramètres du lecteur… le bouton et vérifiez que les informations sont correctes. Ce jeu est conçu pour le mode paysage. Vérifiez que l'orientation par défaut a été le mode sélectionnée :

Pour terminer, cliquez sur le bouton Build dans la fenêtre Build Settings Il vous sera demandé de sélectionner un dossier où compiler le projet. Votre projet et solution Visual Studio sera créé à cet emplacement.

Utilisez Visual Studio pour créer un package d'application et WACK

Nous avons créé votre solution Visual Studio,nous pouvons poursuivre avec l'installation.

Double-cliquez sur la solution créée.

Visual Studio 2015 ouvrira trois projets. Ne vous inquiétez pas si vous voyez des erreurs. Visual Studio charge des ressources en asynchrone. Attendez que toutes les ressources soient chargées et compilez le projet en mode Debug en sélectionnant Build | Build Solution dans le menu.

Ensuite, vous devez…

  1. Vérifier que la compilation fonctionne.
  2. Passez du mode mode à Master. Ce point est essentiel, puisque vous devrez soumettre vos applications UWP au Windows Store via le Master mode. (Master mode removes safety checks and disables the profiler in order to provide the best performance.)
  3. Sélectionner Boutique | Créer des packages d'application... dans le Projet menu.

Si vous vous connectez pour la première fois ou si plusieurs jours se sont écoulés, vous devrez vous identifier avec vos identifiants de développeur Windows Store. Vous devrez saisir un code de sécurité pour vérifier vos identifiants.

Si votre compilation est réussie, continuez en cliquant sur le bouton Launch Windows App Certification Kit Ce processus de test peut nécessiter un peu de temps. Il sert à confirmer que votre jeu est prêt à être soumis au Windows Store.

Si le processus se déroule correctement, l'écran suivant s'affiche :

Concevez un jeu Unity pour UWP

Unity vous propose un ensemble d'outils complets qui vous permet de cibler de nombreuses plateformes. Cela comprend le support pour les applications Universal Windows Platform (UWP). Les outils Unity couvrent, entre autres, les éléments suivants :

  • De nombreuses résolutions et redimensionnements d'écran
  • Rapports d'image

De nombreuses résolutions et redimensionnements d'écran

Une fois achevé, votre jeu Unity est capable de gérer de multiples résolutions et redimensionnements d'écran. Le menu et le Heads Up Display (HUD), pris en charge, ne sont pas toujours intuitifs mais sont pourtant essentiels à votre jeu.

Unity vous offre un tout nouveau système d'interface utilisateur, Unity UI, qui élimine le besoin d'utiliser des modules additionnels tiers et qui simplifie les interfaces au sein du jeu. Prenez le temps de configurer correctement le menu et le HUD et de réaliser des tests avec différentes résolutions. Rappelez-vous Windows Forms ou WPF, qui vous permettaient d'ancrer les éléments de l'UI pour qu'ils se redimensionnent automatiquement en fonction de la résolution de l'écran. Unity vous offre la même possibilité. En plus des positions d'ancrage, vous pouvez choisir si vos éléments UI se redimensionnent ou conservent leur taille en cas de changement de résolution.

Rapports d'image

En plus des résolutions et des redimensionnements, Unity prend en charge plusieurs rapports d'image. Il est essentiel de tester les différents rapports d'image que vous souhaitez intégrer à votre jeu. C'est la raison pour laquelle Unity vous permet d'effectuer des tests en toute simplicité.

Pensez à tester votre création sur les émulateurs et sur les appareils cibles auxquels vous avez accès afin de vous assurer que tout est prêt.

Outils Visual Studio 2015 pour Unity

Visual Visual est fourni avec de nombreux outils qui vous permettront de préparer votre jeu Unity à être publié sur le Windows Store. Voici un aperçu de ces outils :

  • Unity Project Explorer
  • Écriture des scripts et debugging dans Visual Studio
  • Graphics Debugger

Visual Studio Tools for Unity

À partir de Unity 5.2, vous n'avez plus besoin d'importer Visual Studio Tools for Unity séparément dans Unity. Dans Visual Studio 2015, allez dans Tools | Extensions and Updates pour installer Visual Studio Tools for Unity.

La section suivante décrit les étapes nécessaires pour obtenir la dernière version de VSTU ou si vous utilisez une version inférieure à Unity 5.2. Si vous utilisez Visual Studio 2015 avec Unity 5.2 ou plus récent, les étapes qui suivent ne sont pas nécessaires.

Visual Studio Tools for Unity vous permet d'écrire et de corriger vos jeux Unity dans Microsoft Visual Studio. En plus des possibilités d'ajouter des breakpoints et d’évaluer des variables et des expressions complexes, vous pouvez parcourir votre projet comme si vous travailliez dans Unity via la fonction Unity Project Explorer. Enfin, vous visualiserez le même résultat sur console que vous auriez obtenu dans Unity.

Vous trouverez ci-après une capture d'écran de l'installation de Visual Studio 2015 Tools for Unity. Acceptez les conditions en cochant la case correspondante :

Une l'installation terminée, une fenêtre s'ouvre :

Maintenant que l'installation est achevée, vous pouvez ouvrir Unity et ajouter cet outil à votre projet.

La fenêtre Unity suivante s'affiche. Laissez tous les éléments cochés et cliquez sur le Importez bouton :

Un nouveau dossier est alors créé dans la structure de votre projet :

Vérifiez que vos paramètres de compilation sont adaptés à l'utilisation de Visual Studio, comme indiqué ci-dessous. Assurez-vous que Unity C# Projects et Development Build sont cochés.

Vous êtes prêt à écrire des scripts et à corriger via Visual Studio. N'oubliez pas que le processus d'installation est uniquement nécessaire pour les versions inférieures à Unity 5.2.

Écriture des scripts et debugging dans Visual Studio

Si vous double-cliquez sur un script dans Unity, Visual Studio s'ouvrira. Par exemple, si vous sélectionnez le script Shooter.cs et que vous l'ouvrez dans Visual Studio, vous obtiendrez ceci

Maintenant, pour corriger la fonction GetButtonDown qui commande le lancer des ballons, nous pouvons ajouter un breakpoint sur la ligne 12 puis cliquer sur Attach to Unity bouton :

Dans Unity, il suffit de cliquer sur Play pour lancer le jeu. Mettre à jour En faisant un clic gauche, nous verrons la pause du jeu sur la ligne 12 dans Visual Studio :

Vitre flux de production pour la correction est le même que pour tout autre projet Visual Studio.

Graphics Debugger

Visual Studio 2015 est fourni avec un puissant outil correcteur graphique qui vous permettra d'optimiser votre jeu.

Pour commencer, assurez-vous que vous avez ajouté Graphics Tools à votre système. Dans Windows, allez dans Settings, sélectionnez System, sélectionnez Apps & Features, sélectionnez Manage optional features. Si Graphics Tools est correctement installé, il doit s'afficher :

Si ce n'est pas le cas, sélectionnez Add a feature et dans la liste cliquez sur Graphic Tools. Consultez la documentations MSDN sur les outils de diagnostic graphique si vous rencontrez des difficultés lors de l'installation.

Vous devez utiliser la compilation Visual Studio depuis Unity puis ouvrir le jeu avec Visual Studio pour pouvoir utiliser Graphics Tools. Dans Visual Studio, vous pouvez choisir cet outil via le menu en cliquant sur Debug | Graphics | Start Graphics Debugging, comme indiqué ci-dessous :

Au lancement du jeu, l'interface suivante s'ouvre :

Cliquez sur l'icône Capture Frame pour capturer le frame actuel du jeu. Vous pouvez capturer différentes parties de votre jeu.

Si vous double-cliquez sur un frame, vous accèderez aux analyses détaillées qui le concernent. Vous pourrez parcourir le traitement des requêtes dans le panneau Graphics Event List mais également sélectionner des pixels individuels et consulter le panneau Graphics Pixel History :

Notez que le fichier de diagnostic peut devenir très lourd. Pour plus d'informations, consultez Diagnostics Visual Studio Graphics

Windows Store Asset Generation

Pour soumettre votre application sur le Windows Store, vous devrez fournir des images de la bonne taille. Une extension Visual Studio a été conçue à cette fin : UWP Tile Generator. Vous pourrez ainsi sélectionner votre image, l'outil créera toutes les tailles dont vous avez besoin dans un fichier zip.

Les différences entre les applications Unity et UWP

Unity emploie un framework appelé Scripting backend pour supporter le script. Ce framework prend actuellement en charge trois infrastructures : Mono, .NET et IL2CPP. Si votre application cible Windows Store, seules .NET et IL2CPP sont disponibles. Vous pouvez sélectionner Scripting Backend en cliquant sur le bouton Player Settings dans la fenêtre Build Settings dans Unity.

In the Unity IDE, scripts using .NET are referencing .NET version 3.5. When your game is exported to Visual Studio, however, all your C# code is compiled against .NET Core, which is a subset of .NET version 4.5. ( Remarque : If you use IL2CPP as the scripting backend, however, your Windows Store app will continue to use .NET 3.5.) To illustrate this, try writing the following line of code into a Unity script:

        
          System.Collections.SortedList lst = new SortedList();
        
      

Lorsque vousF12 sur SortedList dans Visual Studio pour afficher la définition du type d'élément, vous voyez que cette classe est présente dans la bibliothèque mscorlib.

Si vous insérez le même code dans votre projet exporté et F12 pour le type, SortedList vous verrez que cette version de la classe est contenue dans un package NuGet rattaché à .NET Core.

Auparavant, l'absence de types ou de méthodes .NET 3.5 dans .NET Core pouvait créer des problèmes et impliquait l'utilisation de bibliothèques comme .NET Core pour combler les lacunes et pouvoir utiliser des types et des méthodes d'extension.

Conseil : Méfiez-vous des guides relatifs aux types manquants entre Unity et .NET Core. Beaucoup d'entre eux ne sont pas à jour et manquent de précision.

Vous avez donc compris qu'il est essentiel de comprendre les différences entre Unity et UWP, même si les problèmes concernant les méthodes et les types manquant lors du portage de .NET 3.5 vers .NET Core continuent à diminuer au fur et à mesure du développement de .NET Core. Par exemple, System.Threading.Tasks, qui a été créé après .NET 3.5 et intégré à .NET Core. Vous pouvez également rencontrer le problème contraire pour implémenter des fonctionnalités .NET Core absente dans .NET 3.5.

Si vous utilisez IL2CPP comme infrastructure de script, la surface d'API entre l'éditeur Unity et votre application Windows Store deviendra similaire.

Fonctionnalités spécifiques aux plateformes

Unity et Universal Windows Platform (UWP) étant des plateformes différentes, le portage entre ces deux solutions implique à la fois des avantages et des difficultés.

Optimisation des performances

UWP utilise .NET Native, qui génère un code machine optimisé et native pour des temps de chargement plus rapides et une consommation de batterie amoindrie pour vos jeux. L'impact de ces optimisations variera en fonction de la complexité de votre jeu, mais les jeux Unity qui utilisent l'infrastructure .NET sont particulièrement optimisés.Dans un projet de jeu généré, seule une configuration de compilation Master compilera en .NET Native.

Directives

Vous souhaitez invoquer un Toast UWP ou un Tile de votre jeu ? Ces fonctionnalités ne sont pas incluses dans .NET 3.5, l'infrastructure qui vous permet de développer dans Unity. Dans ce cas, votre code fonctionnera probablement correctement une fois exporté dans Visual Studio mais ne fonctionnera pas dans l'IDE Untiy.

Unity fournit une bibliothèque qui vous permet de surmonter de telles difficultés : UnityEngine.WSA, qui contient des sous-classes comme Application, Cursor, Launcher, Tile et Toast. Vous pouvez programmer pour ces types dans vos scripts C# Unity pour pouvoir jongler entre Unity et UWP.

Une deuxième solution pour gérer les fonctionnalités absentes dans .NET 3.5 consiste à utiliser la directive NETFX_CORE dans vos scripts. Cette directive permet d'ignorer des blocs de code que NET 3.5 ne compilera pas mais dont vous avez besoin dans votre jeu pour les compilations .NET Core. L'exemple suivant, disponible dans le dépôt de code source Unity bitbucket, montre comment le code qui ne fonctionnerait pas dans l'IDE Unity peut être ignoré grâce aux directives.

        
          #if NETFX_CORE
          async
          #endif
          void UpdateTile(byte[] png150x150)
          {
          #if NETFX_CORE
              // In order to change tile image, we should change the uri too
              // in this example we store images in applications local storage
              // we must also take care of cleaning it up
              StorageFolder localFolder = ApplicationData.Current.LocalFolder;
              StorageFolder tilesFolder = null;
              try
              {
                  tilesFolder = await localFolder.GetFolderAsync("tiles");
              }
              catch (Exception)
              { }
              if (tilesFolder != null)
                  await tilesFolder.DeleteAsync();
              tilesFolder = await localFolder.CreateFolderAsync("tiles");
              string tileFile = "tile" + counter++ + ".png";
              StorageFile file = await tilesFolder.CreateFileAsync(tileFile, CreationCollisionOption.ReplaceExisting);
              await FileIO.WriteBytesAsync(file, png150x150);

              string txt = textToTile ? text : "";
              Tile.main.Update("ms-appdata:///local/tiles/" + tileFile, "", "", txt);
          #endif
          }
        
      

Vous aurez parfois besoin d'être plus précis et d'utiliser Unity_WSA_10_0 une directive au lieu de vous appuyer sur NETFX_CORE. Cette dernière est une directive pour toutes les applications Windows Store, Unity_WSA_10_0 celle-ci est particulièrement utilisée pour les appareils Windows 10.

Plugins d’écriture

Les plugins peuvent également être affectés par les différences entre .NET 3.5 et .NET Core. Parfois, le code est compatible et vous ne rencontrerez aucune difficulté. Mais si ce n'est pas le cas, Unity vous permet de configurer votre application de manière à utiliser deux versions différentes d'un même plugin, un pour l'IDE Unity (basé sur les API NET 3.5) et l'autre pour le jeu entier (.NET Core).

Pour implémenter plusieurs plugins, vous devez respecter quelques règles. Vos plugins doivent porter le même nom et avoir le même numéro de version. Vous devez les placer dan deux dossiers différents. Par exemple, le plugin compatible avec votre éditeur sera ici : ..\Assets\Plugins\MyPlugin.dll, tandis que le plugin UWP sera ici : ..\Assets\Plugins\WSA\MyPlugin.winmd.

Vous devez également configurer la version de votre plugin écrit pour l'éditeur en tant que cadre pour votre plugin .NET Core, en indiquant à Unity quelle bibliothèque est la version live qui sera déployée sur le Windows Store.

Sélectionnez Assets\Plugins\MyPlugin.dll dans l'explorateur des projets Unity et désignez l'éditeur comme plateforme.

Allez dans Assets\Plugins\WSA\MyPlugin.winmd et sélectionnez Windows Store Apps comme plateforme correcte pour ce plugin.

Pour que ce processus soit plus clair, nous allons créer un ensemble de plugin.

Ouvrez Visual Studio 2015 et créez un nouveau projet appelé MyPlugin. Utilisez le modèle de projet Visual C# | Windows | Universal | Windows Runtime Component. (You could also use a Class Library project template, instead, but the Windows Runtime Component has some interesting features, such as being consumable from any windows runtime language projection, which provide an extra benefit.)

Faites un clic droit sur la solution et sélectionnez Add -> New Project. Cette version de la bibliothèque sera celle utilisée uniquement dans l'éditeur Unity. Et puisqu'elle compilera en utilisant .NET 3.5, elle doit être créée avec le modèle de projet Visual C# | Windows | Classic Desktop | Class Library. Nommez ce projet MyPluginStub. Vous ne pouvez pas utiliser le même nom pour deux projets dans une même solution.

Les deux bibliothèques devant avoir le même nom, vous devez configurer le fichier de sortie MyPluginStub pour qu'il soit nommé MyPlugin, comme votre autre projet. Pour cela, faites un clic droit sur le projet MyPluginStub dans l'explorateur de solutions et sélectionnez Properties. Dans l'onglet Application, inscrivez MyPlugin dans les champs Assembly Name et Default pour que le nom corresponde à l'autre projet. Modifiez également le framework cible en .NET Framework 3.5.

Supprimez les fichiers Class1.cs que Visual Studio a créé pour chacun de vos projets. Créez ensuite une nouvelle classe dans le projet MyPlugin Windows Runtime Component et appelez-la Foo.cs. Au lieu de créer une classe similaire pour le projet de bureau Windows, nous allons partager Foo.cs en l'ajoutant en tant que fichier lié.

Vous pouvez désormais éditer le même fichier physique, Foo.cs, depuis les projets MyPlugin et MyPluginStub. Examinez le fichier dans l'éditeur de code des deux projets. Vous remarquerez que lorsque vous le visualisez depuis MyPluginStub, Visual Studio place des repères rouges pour identifier System.Threading.Tasks Le logiciel procède ainsi car le type existe dans .NET Core mais pas dans .NET Framework 3.5.

Nous pourrions simplement supprimer cette ligne pour résoudre le problème, puisque nous ne prévoyons pas de l'utiliser. Mais nous allons tester une directive pour analyser son fonctionnement. Remplacez l'élément Tasks par les trois lignes de code suivantes.

        
          #if NETFX_CORE
            using System.Threading.Tasks;
          #endif
        
      

Les projets devraient se compiler à nouveau. Nous avons toujours besoin d'une solution pour la classe Foo. Nous allons l'appeler Bar. Cet élément doit envoyer un message différent s'il est appelé depuis l'éditeur Unity ou depuis l'intérieur du composant Windows Runtime. Ajoutez l'implémentation de cette méthode à votre classe Foo (ajoutez également le mot clé sealed à votre déclaration de classe, car les composants Runtime l'exigent).

        
          public sealed class Foo
            {
              public string Bar()
              {
                #if NETFX_CORE
                  return "Windows Store version of the plugin.";
                #endif
                  return "Unity Editor version of the plugin.";
              }
            }
        
      

Créez les deux bibliothèques.

Vous devez ensuite configurer votre projet Unity pour utiliser ces bibliothèques. Ouvrez votre projet dans Unity et créez un nouveau dossier Plugins sous le dossier Assets. Sous Plugins, créez une nouveau répertoire appelé WSA (Windows Store Application). Trouvez le fichier MyPlugins.dll dans votre projet MyPluginsStub et faites-le glisser vers ..\Assets\Plugins. Trouvez ensuite le fichier MyPlugins.winmd que vous avez compilé et fites-le glisser vers ..\Assets\Plugins\WSA.

Cliquez sur Plugins\MyPlugin dans le menu des ressources. Les paramètres d'importation MyPlugin s'afficheront alors dans l'inspecteur. Désélectionnez Any Platform et choisissez Editor à la place. Cela indiquera à l'IDE quelle version de la bibliothèque exécuter lorsque vous travaillez dans l'éditeur Unity.

Descendez d'un niveau et sélectionnez Plugins\WSA\MyPlugin. L'inspecteur a normalement déjà sélectionné WSAPlayer comme plateforme. Unity sait ainsi quelle version de la bibliothèque afficher dans le Windows Store. Dans le champ Placeholder, trouvez votre bibliothèque de test à la racine du dossier Plugins. Cela permet d'expliquer la relation entre les deux bibliothèques. Plugins\MyPlugin.dll est le cadre de votre bibliothèque actuelle, Plugins\WSA\MyPlugin.winmd.

Il est temps de tester les deux bibliothèques, pour nous assurer qu'elles sont correctement configurées dans Unity. Créez un nouveau script C# dans Unity et appelez-le TestFooBar. Créez une instance privée de la classe Foo et écrivez la valeur de retour de Bar dans le Logger.

        
          using UnityEngine;
          using System.Collections;
          using MyPlugin;

          public class TestFooBar : MonoBehaviour {

            private Foo testFoo = new Foo();
             // Use this for initialization
               void Start () {
                  Debug.Log(testFoo.Bar());
                }

            // Update is called once per frame
              void Update () {

              }
            }
        
      

Cet exemple de plugin est la base de la plupart des interactions entre UWP et Unity. Si les messages corrects s'affichent dans vos consoles, alors vous avez appris tout ce que vous devez savoir pour encapsuler du code UWP et y accéder depuis votre jeu Unity.

Allez dans fenêtre et cliquez sur le bouton Build pour exporter votre projet dans Visual Studio.

Exécutez votre jeu dans Visual Studio. Le message suivant devrait s'afficher dans la fenêtre de sortie du logiciel :

Cet exemple de plugin est la base de la plupart des interactions entre la plateforme Universal Windows Platform (UWP) et Unity. Si vous parvenez à afficher les bons messages dans vos consoles, alors vous avez appris tout ce dont vous besoin pour encapsuler du code UWP et y accéder depuis votre jeu Unity.

Publicité

Vous pouvez exécuter Microsoft Ads comme plugin Unity en téléchargeant et en installant Unity Plugins pour Windows Store et Azure Services. Le plugin contient également des API pour les achats dans l'application, des vérifications de licences et la validation de reçu.

La solution la plus simple pour utiliser les plugins Unity pour Windows Store consiste à télécharger le package Unity depuis GitHub et à l'importer dans votre application via Assets | Import Package | Custom Packages dans l'éditeur Unity. Une fois le package importé, les fichiers binaires seront dans les dossiers Unity Plugins et Plugins\WSA folder.

Vous pouvez également utiliser les dernières extensions du kit de développement Microsoft Store Engagement and Monetization depuis votre application UWP exportée afin d'afficher des publicités sous forme de bannière et de vidéos intégrées au jeu. Le kit de développement Microsoft Store Engagement and Monetization intègre les fonctionnalités de publicité du kit de développement Microsoft Universal Ad Client avec des fonctionnalités supplémentaires liées au service Store dans un installateur unique.

Analytics

Vous pouvez collecter des analyses concernant vos utilisateurs via la plateforme Unity ou via la plateforme Universal Windows Platform (UWP). Vous pouvez également utiliser les deux plateformes pour recueillir des données complémentaires.Si vous choisissez d'utiliser Unity, vous devrez lier votre projet à un ID Unity Services puis activer Analytics pour ce projet. Vous trouverez plus d'informations dans le Manuel Unity.

Une fois votre jeu déployé, les données seront automatiquement collectées sur votre tableau de bord Windows Dev Center. Le tableau de bord vous fournira régulièrement des rapports concernant les éléments suivants :

  • Acquisitions
  • Santé
  • Évaluations
  • Avis
  • Avis
  • Utilisation
  • Acquisition IAP
  • Médiation publicités
  • Performances des publicités
  • Publicités menant à une installation
  • Canaux et conversions

Si vous activez cette fonctionnalité, vous pourrez même consulter les télémétriques pour votre jeu.

Enfin, vous pouvez également utiliser les API REST pour consulter ces analyses simplement, sans passer par le Windows Dev Center.

In-App Purchases (IAP)

Les jeux Unity exportés vers Universal Windows Platform (UWP) s'appuient sur deux plateformes, Unity et UWP. Deux options s'offrent donc à vous pour activer In-App Purchases. Vous pouvez utiliser Unity IAP ou Unity Plugins pour Windows Store et Azure Services.

Pour utiliser Unity IAP, vous devez utiliser un ID Unity Services Project via la fenêtre Services dans Unity. Plus d'infos disponibles sur le site Internet Unity. N'oubliez pas l'IAP Unity ne fonctionnera pas avec l'infrastructure de script IL2CPP.

Avec Unity Plugins for Windows Store, vous utilisez l'API Store pour récupérer vos listes d'un fichier script Unity. Pour commencer, vous devez créer des produits à acheter dans votre application via le Windows Store Dev Center. Vous pourrez ensuite mettre votre application à jour et autoriser les achats de vos IAP. La requête principale, effectuée via le plugin, nécessite que vous invoquiez LoadListingInformation la méthode pour récupérer vos IAP, tel qu'indiqué dans l'exemple de code ci-dessous.

        
          Store.LoadListingInformation((response) =>
          {
            if (response.Status == CallbackStatus.Failure)
              {
                prettyPrintErrors("LoadListingInformation", response);
                return;
              }

            prettyPrintSuccess("LoadListingInformation", response);
            text.text = "\nFinished Loading Listing Information" + text.text + "\n";
            Debug.Log(response.Result.Description.ToString());
            foreach (var productListingKey in response.Result.ProductListings.Keys)
              {
                Debug.Log("Key: " + productListingKey + " value: " + response.Result.ProductListings[productListingKey].Name);
              }
          });
        
      

L'exemple complet de l'implémentation qui montre comment utilisation l'API Store est disponible sur GitHub.

Meilleures pratiques

Au fur et à mesure que vous avancez dans le développement de votre jeu, vous pouvez procéder à quelques réglages pour préparer votre application à la famille d'appareils Windows 10. Cette section couvre plusieurs des meilleures pratiques votre développement pour le Windows Store.

Ecran de démarrage et processus de chargement

Au lancement du jeu, il est important de faire apparaître un indicateur de progression pour que les utilisateurs sachent que le processus se déroule correctement.

Partons du principe que vous utilisez un projet XAML. Si ce n’est pas le cas, la plupart des concepts évoqués ici s'appliquent à un projet DirectX, mais les implémentations varient.

Il y a deux étapes majeures dans le chargement d'un jeu sur le Windows Store via Unity

  1. Ecran de démarrage de l'application
  2. Expérience étendue

L'image de l'écran de démarrage initiale sera affichée par le système d'exploitation. Vous pouvez la configurer en mettant à jour le manifeste de vos applications comme indiqué ci-après :

Windows affichera l'écran de démarrage initial pendant le temps de chargement de la page (XAML) qui hébergera vos scènes Unity.

La scène Unity prend généralement plus de temps à charger. Pour créer une expérience étendue, utilisez XAML pour afficher la même image de démarrage à côté d'un indicateur de progression pendant le chargement de votre page. Dans MainPage.xaml, vous ajouterez une barre de progression à côté de l'image de démarrage.

        
          <SwapChainPanel x:Name="DXSwapChainPanel">
            <Grid x:Name="ExtendedSplashGrid" Background="#222C37">
              <Image x:Name="ExtendedSplashImage" Source="Assets/SplashScreen.png" 
                VerticalAlignment="Center" HorizontalAlignment="Center"/>
              <ProgressBar x:Name="SplashProgress" Foreground="#FFFFFFFF" 
                Background="#FF333333" Maximum="10000" Width="320" Height="25"/>
            </Grid>
          </SwapChainPanel>
        
      

Dans MainPage.xaml.cs, le code derrière l'UI XAML, utilisez le constructeur pour lancer un minuteur qui activera la barre de progression tout en fournissant un aperçu visuel à l'utilisateur.

Format de l'appareil

La base de code unique pour plusieurs formats est l'une des principales fonctionnalités de la plateforme Universal Windows Platform (UWP). Cependant, les jeux peuvent nécessiter des réglages et des optimisations spécifiques pour certains formats. Dans la plupart des cas, cela inclut les mécanismes d'entrée (tactile, clavier, souris, pad), le redimensionnement Windows, l'optimisation des ressources et des actifs, ainsi que l'implémentation de l'intégration de la plateforme native avec chaque format spécifique.

Support orientation

Compte tenu de la prédominance des grands écrans sur les appareils récents, l'éditeur Unity exportera les projets au format paysage par défaut. Si votre jeu prend en charge l'orientation portrait, vous devrez modifier le fichier de l'application dans Visual Studio. Vous ne pouvez pas le faire dans l'éditeur Unity.

Pour procéder à la modification, double-cliquez sur Package.appxmanifest le fichier, situé à la racine de votre projet Windows Store Visual Studio. Dans l'éditeur, vérifiez les orientations que vous souhaitez utiliser.

Les API d'orientation (Input.deviceOrientation et Screen.orientation) fonctionnent correctement dans Unity. Vous pouvez les utiliser pour interroger l'orientation de l'appareil et même définir l'orientation de certaines scènes.

Prise en charge des différentes tailles de fenêtres

Les applications Universal Windows Platform (UWP) sont hébergées sous forme de fenêtres redimensionnables au lieu d'être exécutées en plein écran comme dans Windows 8 et 8.1, pour que les fenêtres soient prises en compte pour vos jeux et applications.

La plupart de ces différences sont transparentes pour vous en tant que développeur Unity, car mes propriétés Screen.height et Screen.width reporte encore l'espace disponible en tailles natives (pixels).

Lorsqu'un utilisateur modifie la taille de la fenêtre, il est généralement recommandé de mettre le jeu sur pause, pour que l'utilisateur puisse décider quoi faire ensuite. Et puisque Windows peut perdre le focus en mode bureau, qui permet d'ouvrir de multiples fenêtres simultanément,, pensez à gérer les changements de focus et à mettre en pause lorsque le focus est perdu.

Mettre votre jeu en pause et le reprendre

Dans Windows, le moteur Unity se charge de mettre en pause et de reprendre le jeu automatiquement lorsque le focus est perdu. Si vous souhaitez mettre le jeu en pause en dehors de la suspension automatique de l'application, par exemple pendant la navigation entreles pages XAML, vous pouvez appeler la UnityPause méthode.

Si vous avez besoin d'exécuter une tâche supplémentaire lorsque l'application est sur le point d'être mise en pause, OnApplicationPause effectuez plutôt un rappel dans vos scripts.

Entrée via souris et pad

La famille des appareils Windows prend en charge une vaste gamme de produits de saisie, du clavier à la souris, en passant par les pads. Heureusement, ces éléments sont pris en charge par Unity et par le gestionnaire d'entrée du logiciel.

Concernant le comportement du lanceur de notre jeu de Basket-ball, nous attendons que l'axe d'entrée Fire1 soient lancés avant de lancer un ballon dans le jeu.

        
          void Update()
            {
              if (Input.GetButtonDown("Fire1"))
              {
                var instance = (Rigidbody)Instantiate(this.prefab, transform.position 
                        + (transform.forward * 1.05f), transform.rotation);
                instance.velocity = (transform.forward + transform.up / 2) * this.speed;
              }
            }
        
      

Fire1 est associé par défaut au clic gauche de la série et au bouton de joystick/de gamepad, tel qu'indiqué ci-dessous dans le gestionnaire de saisie. Pour afficher le manager dans l'IDE Unity, sélectionnez Edit -> Project Settings -> Input.

Sur une manette Xbox, « joystick button 0 », associé à Fire1, est le bouton A. Il y a également des entrées déjà associées au FPSController pour les mouvements et les sauts. Les mouvements de la souris, les touches gauche, droite, haut et bas du clavier, ainsi que les touches a, d, s et w et le bouton gauche du joystick sur la manette de la Xbox One déplacent tous les joueur par défaut. Le clic droit de la souris, la barre d'espace et le bouton B de la manette de la Xbox permettent de faire sauter le joueur.

Vous pouvez également personnaliser vos entrées pour l'expérience utilisateur en modifiant ou en ajoutant des axes. Vous pouvez en apprendre plus sur les axes virtuels dans le Manuel Unity.

Conclusion

Ce document vous a appris à configurer et à exporter votre jeu depuis Unity vers un projet Universal Windows Platform (UWP) dans Visual Studio. Il vous a également expliqué comment soumettre votre jeu UWP dans le Windows Store. Nous avons étudié plusieurs des différences entre les plateformes Unity et Universal Windows, ainsi que les fonctionnalités et le code spécifiques aux plateformes que vous devez connaître en tant que développeur. Enfin, nous avons analysé les meilleures pratiques pour préparer votre jeu à être publié.

Références

Retour en haut
Compris

Ce site utilise des cookies dans le but de vous offrir la meilleure expérience possible. Consultez la page de politique des cookies pour en savoir plus.