Téléchargez l'application Unity 3D pour Android. Utiliser Unity pour développer des applications. Comment créer des jeux dans Unity
Le développement de jeux pour les appareils Android OS nécessite une approche similaire au développement pour iOS. D'autre part, le matériel des appareils Android n'est pas soumis à des normes claires, ce qui oblige à résoudre des problèmes qui sont absents lorsque l'on travaille avec iOS. Il existe également des différences entre les versions Android et iOS de Unity.
Préparation de l'environnement de développement Android
Avant de pouvoir tester vos jeux sur l'appareil, vous devrez préparer votre environnement de développement. En particulier, téléchargez et installez le SDK Android de la plate-forme souhaitée et ajoutez votre appareil au système (ce processus est différent pour Windows et Mac). Ceci est écrit en détail sur le site Web des développeurs Android, et des informations supplémentaires peuvent être fournies par le fabricant de votre appareil. Comme il s'agit d'un processus assez compliqué, nous avons préparé une petite instruction qui vous aidera à préparer tout ce dont vous avez besoin pour le développement. Si vous avez besoin de plus d'informations, vous pouvez les obtenir sur le portail des développeurs Android.
Accès aux fonctionnalités Android
Unity fournit une API pour accéder aux entrées et aux paramètres Android. Les classes disponibles sont documentées sur la page Code for Android Assemblys.
Lier du code C, C++ ou Java à des scripts
Unity vous permet d'appeler des fonctions écrites en C/C++ directement à partir de scripts (les fonctions Java peuvent être appelées indirectement). Pour savoir comment accéder aux fonctions à partir du code natif de Unity, visitez la page de création de plug-ins Android.
Occlusion Culling (écrêtage de la géométrie invisible)
Unity prend en charge l'occlusion culling, ce qui est très utile lors de l'optimisation pour les plates-formes mobiles. Plus d'informations peuvent être trouvées sur la page Occlusion culling.
Personnalisation de l'écran de démarrage
L'écran de démarrage affiché au démarrage du jeu peut être personnalisé - consultez cette page pour plus d'informations.
Dépannage et rapport d'erreurs
Il existe de nombreuses raisons pour lesquelles votre application plante ou ne fonctionne pas correctement. Notre guide de résolution des problèmes spécifiques à Android vous aidera à traiter les causes des erreurs dans les plus brefs délais. Si, après avoir lu le manuel, vous supposez que le problème est dans Unity, vous devez déposer un rapport de bogue. Reportez-vous à cette page pour les instructions.
En quoi Unity pour Android diffère de la version de bureau
JavaScript avec un typage fort
Pour améliorer les performances dans la version Android de Unity, la saisie dynamique en JavaScript est toujours désactivée (comme si #pragma strict était automatiquement appliqué à chaque script). Il est important de s'en souvenir si vous portez un projet sur Android à partir d'anciennes plates-formes, et si vous rencontrez des erreurs de compilation, le problème doit être recherché en premier lieu lors de la saisie. De telles erreurs sont généralement faciles à gérer en s'assurant que les types de toutes les variables sont explicitement spécifiés ou convertis lors de l'initialisation.
Alors qu'Unity Android prend en charge les textures DXT/PVRTC/ATC, Unity décompressera les textures au format RVB(A) lors de l'exécution si ces méthodes de compression ne sont pas prises en charge sur l'appareil spécifique. Cela peut sérieusement affecter les performances de rendu du GPU, il est donc recommandé d'utiliser le format ETC. Il s'agit de la norme de facto pour Android et devrait être pris en charge par tous les appareils modernes. D'autre part, ETC ne prend pas en charge un canal alpha, et parfois les textures RGBA 16 bits seront le meilleur choix en termes de qualité, de taille et de vitesse de rendu lorsqu'un canal alpha est nécessaire.
Vues des publications : 19 374
Nous avons parlé de la façon dont vous pouvez créer votre propre jeu sur Android en utilisant l'Unreal Engine. Dans cet article, nous examinerons un autre moteur de développement de jeux tout aussi populaire - unité.
Unity est un moteur très célèbre parmi les développeurs indépendants. En fait, il s'agit d'un moteur multiplateforme qui vous permet de développer 3D- et 2D-Jeux. La caractéristique qui distingue Unity des autres moteurs est le seuil d'entrée bas pour les débutants, tout en ayant une boîte à outils riche pour les professionnels. La multiplateforme vous permet de développer des applications pour n'importe quelle plate-forme, des jeux de bureau aux jeux mobiles.
Séparément, il convient de mentionner le système d'abonnement, car Unity n'est pas un produit entièrement gratuit. Il existe plusieurs types d'abonnements :
- Personnel. Version gratuite qui contient toutes les fonctionnalités principales du moteur. Il a la limitation suivante : le revenu par an ou le montant des fonds collectés ne doit pas dépasser 100000$ .
- Plus. Par 35 $ par mois divers rapports et analyses sont fournis, ainsi que la possibilité de changer l'écran de démarrage, 20% -ième remise sur les achats en Magasin d'actifs et divers avantages mineurs. Elle a la limitation suivante : les revenus de l'année ou le montant des fonds récoltés ne doivent pas dépasser 200000$ .
- Pro. Par 125 $ par mois comprend tous les avantages de la version Plus et en plus un service professionnel et un support premium. Aucune restriction sur le chiffre d'affaires ou le montant des fonds.
- Versions distinctes pour les entreprises (utilisées par les grandes entreprises).
Ainsi, les développeurs indépendants aux petits budgets devraient se contenter de la version Personnel ou Plus sinon il faudra s'inscrire Pro. Dans cet article, nous utiliserons version gratuite pour la première manche.
Étape 1Installer Unity
Pour commencer à installer Unity, vous devez vous rendre sur le site Web Unity Store, où vous serez invité à sélectionner le type d'abonnement. Comme mentionné ci-dessus, nous choisissons Personnel.
Vous serez ensuite invité à accepter les conditions d'utilisation et à télécharger le programme d'installation. Vous pouvez également consulter Configuration requise travailler avec Unity.
Après avoir lancé le programme d'installation, vous serez invité à sélectionner les composants à installer. Puisque nous devons créer une application Android, nous allons cocher la case pour Prise en charge de la construction Android. De plus, si vous le souhaitez, au lieu d'utiliser Unity, vous pouvez installer Communauté Visual Studio 2017 pour la programmation sur C#.
Après cela, il ne reste plus qu'à choisir le chemin d'installation et à commencer à installer Unity.
Étape 2 : Enregistrement et configuration de Unity
Après avoir terminé l'installation et exécuté Unity, nous sommes invités à nous connecter avec notre compte.
Là encore, il vous sera demandé de sélectionner un abonnement, nous nous concentrerons également sur Personnel. Dans ce cas, vous devrez confirmer que le revenu annuel de l'entreprise est inférieur à 100 000 $ ou que Unity est utilisé à des fins de formation.
A la fin, il vous est proposé de répondre à un petit sondage dans lequel vous devrez répondre à ce que vous faites et dans quel but vous installez Unity.
Étape 3. Créer un nouveau projet
Après avoir configuré Unity, nous arrivons à l'écran de sélection / création d'un projet. Cliquez ici Nouveau pour créer votre nouveau projet.
Après cela, dans la fenêtre qui apparaît, il vous est demandé d'entrer le nom du projet et le répertoire où il se trouvera. N'oubliez pas non plus de cocher la case 3D pour utiliser l'éditeur en mode 3D.
Lorsque vous avez terminé, cliquez sur Créer un projet pour créer un projet. Après cela, une fenêtre d'édition s'ouvrira avec une scène pré-générée.
Nous n'aborderons pas encore les subtilités de la programmation et prenons par exemple jeu terminé. Pour cela il y a Magasin d'actifs, qui contient un grand nombre de modèles prêts à l'emploi, d'animations, de sons (et même de jeux), payants et gratuits.
Pour ouvrir l'Asset Store, il faut dans le menu Fenêtre choisir Magasin d'actifs(combinaison de touches ctrl-9).
La vitrine du magasin s'ouvrira. Entrez dans la barre de recherche " jeu d'exemple de style oiseau flappy" et ouvrez un exemple gratuit que nous utiliserons dans notre projet.
En cliquant Télécharger et donc après l'avoir téléchargé, vous pouvez ensuite l'importer dans votre projet. Pour ce faire, cliquez Importer, après quoi un avertissement apparaîtra indiquant que les paramètres du projet seront modifiés après l'importation.
Après avoir accepté l'importation, vous verrez une fenêtre dans laquelle vous devrez choisir les composants à importer. Sélectionnez tout et cliquez Importer.
Une fois l'importation terminée, vous verrez les nouveaux fichiers dans l'Explorateur de projets. Ce sont les fichiers du jeu. Pour ouvrir la scène dans l'éditeur, développez Style d'oiseau Flappy - scènes et double-cliquez sur Principal.
En conséquence, la scène du jeu apparaîtra dans la fenêtre de l'éditeur 3D.
Vous pouvez vérifier le fonctionnement du jeu directement dans Unity en cliquant sur le bouton jouer au-dessus de la fenêtre de l'éditeur.
Étape 4Configurer les outils Android
Noter: si vous utilisez studio androïde, alors vous avez déjà tout installé composants nécessaires et ainsi vous pouvez passer à l'étape suivante en toute sécurité.
Afin d'assembler le jeu résultant sur Android, vous devez installer les outils suivants :
- Kit de développement Java (JDK). Vous pouvez le télécharger à partir du site Web de Java. En cliquant sur le lien, vous verrez tout en haut Plate-forme Java (JDK), cliquer sur Téléchargerà côté de l'inscription, puis sélectionnez votre système d'exploitation et lancez le téléchargement. Après cela, suivez simplement les instructions de l'installateur.
- SDK Android. par le plus d'une manière simple installer la dernière version consiste à télécharger Android Studio avec lequel ce SDK est fourni. Pour ce faire, rendez-vous sur le site Web d'Android Studio et cliquez sur Télécharger AndroidStudio. Le programme d'installation d'Android Studio installe les principaux composants du SDK Android requis pour le développement d'Android.
Étape 5. Préparer le projet pour le lancement
Tout d'abord, vous devez changer la plate-forme de développement pour Android. Pour ce faire, dans Unity, ouvrez le menu Fichier et sélectionnez Build Settings.
Dans la fenêtre qui s'affiche, sélectionnez Android puis appuyez sur plate-forme de commutation.
Le commutateur de plate-forme nous indique que nous allons créer une application Android. Cela signifie que lorsque nous construisons l'application, Unity créera Fichier APK. Le changement de plate-forme oblige également Unity à réimporter tous les actifs du projet. Cela ne prendra pas longtemps sur un petit projet, mais gardez à l'esprit que cette opération peut prendre beaucoup de temps sur de grands projets.
Nous devons maintenant fournir un nom de package pour l'application.
Noter: Le nom du package est un identifiant unique pour l'application et est écrit dans le style DNS inverse au format com.CompanyName.ProductName. Une fois l'application publiée sur Google Play, le nom du package ne peut plus être modifié.
Pour cela, rendez-vous dans le menu Éditer et choisissez Paramètres du projet - Lecteur.
Sur le côté droit de Unity, une fenêtre s'ouvrira avec de nombreux paramètres différents, tels que la version de l'application, le SDK cible et minimum, la sélection d'icônes, etc. Ici, nous avons besoin dans le bloc Autres réglages trouver Identification et définissez le nom du package dans le champ nom du paquet. Vous pouvez également modifier d'autres paramètres si vous le souhaitez.
Il ne reste plus qu'à spécifier le chemin d'accès au SDK Android et au JDK. Pour cela, allez dans le menu et sélectionnez Modifier les préférences.
Dans la fenêtre qui s'affiche, allez dans Outils externes et dans les champs SDK et JDK spécifiez les chemins appropriés, puis fermez la fenêtre.
Étape 6 : Création et exécution de l'application
Il est temps de créer votre première application Unity. Pour cela, sélectionnez dans le menu Fichier - Paramètres de construction. Une fenêtre s'ouvrira, dans laquelle vous devrez ajouter la scène que vous souhaitez assembler. Puisque nous avons déjà cette scène ouverte dans l'éditeur, cliquez simplement sur Ajouter des scènes ouvertes pour l'ajouter à l'assemblage, après l'avoir ajouté, vous le verrez dans la liste des scènes.
Il ne reste plus qu'à appuyer Construire, après quoi Unity commencera à créer l'application. Avant cela, il peut vous être demandé de sélectionner un dossier dans lequel les fichiers d'application collectés seront enregistrés, ainsi que le nom du fichier APK.
Noter: pour le moment, si la version alpha est installée dans le SDK Android Outils de construction(version 28.0.0-rc1), lors de la construction de Gradle, une erreur se produira. Pour résoudre ce problème, supprimez simplement cette version du SDK Android.
En conséquence, le fichier APK construit apparaîtra dans le dossier que vous avez spécifié, prêt à être installé sur l'émulateur ou sur un appareil réel.
Voyons ce qu'il y a dans l'APK intégré. Pour ce faire, nous utilisons l'utilitaire Analyseur d'APK, qui est inclus avec Android Studio,
La taille du fichier APK non compressé est 21,1 Mo, dans un comprimé 20,9 Mo. Comme vous pouvez le voir sur le graphique, la majeure partie du volume est occupée par des bibliothèques tierces ajoutées par Unity. Puis dans des atouts toutes les ressources qui sont utilisées dans la scène assemblée sont localisées. Dossier classes.dex ne contient que 89 cours et 479 méthodes.
De plus, si vous regardez AndroidManifest.xml, l'application se compose d'une activité.
Conclusion
C'est tout. Dans cet article, nous avons appris à installer et à configurer Unity, et avons également créé notre première application Android.
Unity est le moteur sur lequel la plupart des jeux modernes sur différentes plateformes. Grâce au moteur, il est vraiment possible de créer des jeux orientés pour fonctionner sur des ordinateurs (Windows, Linux, MacOS), téléphones portables, tablettes (Android, iOS) et même consoles de jeux Playstation, Xbox, Nintendo.
Comment créer des jeux dans Unity ?
Unity est basé sur un concept orienté composants. En fait, tout jeu consiste en une masse d'objets dilués avec des composants supplémentaires. Par exemple, lors de la création d'un jeu de plateforme, nous créons un GameObject, y attachons en plus un composant graphique, qui est responsable de l'affichage du personnage, et un composant de contrôle, il permet de contrôler le personnage à l'aide d'une souris, d'un clavier, d'un joystick ou écran tactile. Le moteur n'impose pas de restrictions sur le nombre de ces modules. Nous pouvons ajouter autant de composants au GameObject que nécessaire. Tous les travaux sur le moteur sont basés sur la création même de GameObject et l'application de composants appropriés à ceux-ci.
Les débutants peuvent être induits en erreur par l'apparente simplicité du processus, bien que ce ne soit pas le cas. Pour créer un jeu unique et populaire, vous devez écrire de nombreux composants à partir de zéro. Plus précisément, dans l'environnement Unity, cela s'appelle un script. Le langage de script natif est C#, mais JavaScript et Boo (une version raccourcie de Python) sont également partiellement utilisés. Créer ses propres composants n'est pas simple, on pourrait même dire que c'est une procédure complexe, directement liée à la programmation classique. Sans un niveau de connaissance suffisant en programmation, ce sera difficile.
Plates-formes prises en charge
De nombreux grands projets préfèrent Unity en raison de l'énorme liste de plates-formes compatibles avec le moteur. L'application finie peut être lancée sur n'importe quel système d'exploitation informatique, plates-formes mobiles populaires et SmartTV. Que pouvons-nous dire, même les jeux par navigateur et les applications pour des plates-formes spécifiques ( comme Tizen OS) sont principalement développés dans Unity.
Cependant, tout n'est pas si lisse ici. Si nécessaire, vous pouvez écrire des algorithmes spécifiques basés sur du code de bas niveau, pour le même Android, vous devez avoir une connaissance approfondie de Java.
Il en va de même pour iOS. Une autre caractéristique d'iOS est qu'il est possible de développer pour lui uniquement depuis un ordinateur ou une tablette d'Apple. En l'absence d'un Macbook ou d'un appareil similaire, la sortie du jeu va rapidement caler et Unity n'y est pour rien, Apple lui-même impose une restriction similaire. La conclusion est simple : s'il y a un développement iOS dans les plans, vous devez choisir à l'avance un appareil adapté pour l'assemblage.
Comment et où développer un jeu sur le moteur ?
Nous pouvons mener à bien un long processus de développement de jeux à la fois sous Windows et Mac OS X. Il existe déjà des versions de l'éditeur pour Linux, mais jusqu'à présent, nous ne pouvons pas compter sur leur fonctionnement stable. Un développeur passe la plupart de son temps à créer un jeu dans l'éditeur Unity. Nous avons encore beaucoup de temps pour écrire du code de script, nous pouvons le créer soit dans le MonoDevelop standard, soit dans n'importe quel éditeur tiers. Maintenant, ils utilisent activement Visual Studio, ainsi que Sublime Text, mais uniquement avec une configuration appropriée.
Développement Applications mobiles est l'une des professions les plus rentables de l'industrie informatique. La création d'un jeu Android coûte des centaines ou des milliers de dollars, et le profit peut atteindre jusqu'à un million de dollars. À cet égard, de nombreuses personnes sont intéressées par le développement d'applications pour le téléphone. Dans cet article, vous apprendrez à créer un jeu Android à partir de zéro à l'aide d'un ordinateur, quel moteur et quel concepteur est-il préférable de choisir.
Aucun jeu réussi ne peut pas se passer de beaux graphismes, de sorte que la création du design est l'une des étapes les plus importantes du développement. La conception sur le système d'exploitation Android est implémentée à l'aide d'un "document de conception" ou d'un document de conception. Vous devez commencer à créer un jouet avec son étude détaillée. Le fichier contient :
- Modèles d'objets ;
- Spécifications fonctionnelles;
- Contenu du jeu ;
- Interface.
Examinons chacun des points plus en détail.
Modèles d'objet
Il s'agit d'informations sur la fonctionnalité de chaque élément. Les modèles d'objets sont responsables de la capacité d'acheter et de vendre des objets, ainsi que de l'amélioration des caractéristiques de jeu des personnages.
Spécifications fonctionnelles
Il décrit le gameplay, les principales caractéristiques de chaque personnage. Il décrit également les fonctionnalités articles de jeu- armes, trousses de premiers soins, armures et autres. Essentiellement, les spécifications fonctionnelles sont les règles selon lesquelles processus de jeu. Mieux cette section est élaborée, plus il sera facile de créer un jeu Android de haute qualité.
Contenu du jeu
C'est le remplissage de texte du jeu. Il décrit les dialogues des personnages et quelles armes peuvent être utilisées pour infliger des dégâts, combien de santé un coup prendra, quelles caractéristiques augmenteront lors de l'utilisation de divers équipements. Il contient également Description détaillée chaque objet.
Interface
L'interface est la façon dont l'utilisateur interagira avec le jeu. Il comprend des boutons avec lesquels vous pouvez contrôler le personnage et des sections de menu : par exemple, jouer, score, paramètres, meilleurs joueurs, aide. Si vous n'avez aucune expérience dans la création d'applications Android, avant de créer la vôtre, téléchargez depuis le Play Market et analysez jeux populaires et transférez les meilleures solutions à votre projet.
Moteur de jeu
Le cœur de tout jeu est le moteur. ce Logiciel, vous permettant de le développer et de l'exécuter. Il contient toute une gamme de programmes, dont un moteur de rendu, un moteur physique, du son, de l'animation et bien plus encore. Pour faciliter le processus d'écriture des programmes, les développeurs tiers créent leurs propres moteurs de jeu spécifiquement pour les applications Android.
Chacun d'eux offre des fonctionnalités différentes : certains sont conçus pour la 3D, d'autres pour la 2D, le multi-plateforme peut être pris en charge. Il existe un grand nombre de moteurs de ce type, mais si vous êtes débutant, il est préférable de choisir l'un des plus populaires, car toutes les fonctions nécessaires y seront présentes.
UDK
Couple 2d/3d
Qu'est-ce qu'un concepteur de jeux ?
Constructor est un programme qui combine un moteur de jeu et un environnement de développement intégré. Le constructeur rend le processus de développement accessible aux personnes qui n'ont pas de compétences en programmation. Certains concepteurs vous permettent de créer des jeux de certains genres, d'autres ont un maximum de fonctionnalités, mais coûtent beaucoup plus cher. Pour un créateur novice d'applications mobiles, le choix d'un designer est l'un des moments les plus cruciaux, car le sort de la future application dépendra de ses capacités.
Le constructeur vous permet de créer des jeux de différents genres pour Windows, Android et iOS. Des offres grand choix lieux, objets, personnages et conception sonore prêts à l'emploi, de sorte que la création du premier jeu Android ne prendra pas beaucoup de temps. Les utilisateurs familiarisés avec les langages de programmation JS et C++ peuvent utiliser le GML intégré. Le seul inconvénient est que le programme n'est pas traduit en russe.
Conclusion
Créer un jeu Android n'est pas une entreprise facile, mais très rentable. Si vous décidez de développer un jeu et de gagner de l'argent dessus, élaborez d'abord l'idée. Ensuite, rédigez un « document de conception » et choisissez un moteur de jeu capable de maximiser son potentiel. Après cela, vous pouvez procéder directement à la création de l'application dans le constructeur.
Vidéo
Pour en savoir plus sur le processus de création de jeux Android, consultez une série de vidéos dédiées à cette activité.
Comment écrire rapidement un jeu Android avec Unity
À l'heure actuelle, n'importe qui peut devenir un développeur de jeux ou d'applications mobiles à succès sans faire un effort titanesque. Un exemple d'un tel cas est Dong Nguyen, qui a développé Flappy Bird. Le jeu n'avait pas de mécanique ni de graphisme complexes, mais cela ne l'a pas empêché de devenir populaire et de rapporter à son créateur cinquante mille dollars par jour. Cependant, il n'y avait rien de remarquable dans le jeu. Tout ce qu'il fallait pour réussir, c'était d'être au bon endroit au bon moment et un peu de chance. Des choses similaires peuvent se produire aujourd'hui, vous avez juste besoin de la bonne idée.
Pour démontrer à quel point il est facile d'écrire quelque chose comme ça, nous allons écrire aujourd'hui notre propre Flappy Bird en utilisant Unity en seulement 10 minutes.
personnage de jeu
Créez d'abord un nouveau projet et assurez-vous que l'option 2D est sélectionnée.
Chargez votre sprite d'oiseau dans la scène. N'oubliez pas d'activer votre imagination !
Ajustez ensuite la taille du sprite à votre convenance en le faisant glisser autour du coin dans la direction souhaitée. Le sprite doit être visible dans la fenêtre de hiérarchie sur la gauche. Tous les objets de la scène y sont visibles, et pour le moment il ne devrait y en avoir que deux : une caméra et un oiseau.
Faites glisser la caméra vers l'oiseau et relâchez. La caméra doit être sous l'oiseau, ce qui signifie que la caméra est maintenant "l'enfant" de l'oiseau. Maintenant, la position de la caméra sera fixe par rapport à l'oiseau. Si l'oiseau avance, la caméra fait de même.
Sélectionnez à nouveau l'oiseau dans la scène ou dans la fenêtre de hiérarchie. Vous verrez une liste d'options et d'attributs sur la droite dans une fenêtre appelée Inspector . Ici, vous pouvez gérer diverses variables liées à un objet particulier.
Cliquez maintenant sur Ajouter un composant . Sélectionnez Physics2D > Rigidbody2D - c'est prêt à l'emploi instructions pour appliquer la gravité à notre personnage. Cliquez sur Contraintes dans ce panneau, puis sélectionnez geler la rotation Z . Cela empêchera l'oiseau de tourner avec l'appareil photo.
De la même manière, ajoutez un Polygon Collider qui indique à Unity où se trouvent les frontières du personnage. Appuyez sur Play et voyez comment le sprite, avec la caméra, tombe sans fin.
Jusqu'ici tout va bien !
Il est maintenant temps de commencer à piloter le personnage, car ce ne sera pas difficile.
Vous devez d'abord créer un script C#. Créez un dossier pour celui-ci (faites un clic droit quelque part dans les ressources et créez un dossier "Scripts"), faites un clic droit et sélectionnez Créer > Script C# .
Appelons-le "Caractère". Double-cliquez dessus pour l'ouvrir dans votre IDE, que ce soit MonoDevelop ou Visual Studio. Ajoutez ensuite le code suivant :
Public class Character: MonoBehaviour ( public Rigidbody2D rb; public float moveSpeed; public float flapHeight; // C'est pour l'initialisation void Start() ( rb = GetComponent(); ) // La mise à jour est appelée une fois par image void Update () ( rb .velocity = new Vector2(moveSpeed, rb.velocity.y); if (Input.GetMouseButtonDown(0)) ( rb.velocity = new Vector2(rb.velocity.x, flapHeight); ) if (transform.position.y > 18 || transformation.position.y< -19) { Death(); } } public void Death() { rb.velocity = Vector3.zero; transform.position = new Vector2(0, 0); } }
Ce code fait deux choses. Il fait avancer le personnage à une vitesse que nous définissons dans l'inspecteur et donne l'impression d'un oiseau en vol. La méthode Update () est appelée à plusieurs reprises tout au long du jeu, donc tout ce que vous mettez ici s'exécutera en continu. Dans ce cas, nous ajoutons de la vitesse à notre objet. La variable rb est le script RigidBody2D que nous avons appliqué à notre objet plus tôt, donc quand nous écrivons rb.velocity nous nous référons à la vitesse de l'objet.
Un appui sur l'écran est interprété par Unity comme un clic de souris si vous utilisez un appareil mobile. Après avoir appuyé, on force le personnage à se relever un peu.
La variable moveSpeed sera responsable de la vitesse de déplacement et la variable flapHeight - pour augmenter la hauteur du vol de l'oiseau après chaque clic. Comme ces variables sont public , nous pouvons les modifier en dehors du script.
La méthode Death() est également déclarée public , ce qui signifie que d'autres objets et scripts peuvent l'appeler. Cette méthode renvoie simplement la position du caractère au début. Il sera également utilisé à chaque fois que le personnage volera trop haut ou trop bas. Vous comprendrez bientôt pourquoi il est déclaré public. La ligne rb.velocity = Vector3.zero ; nécessaire pour supprimer l'élan - nous ne voulons pas que le personnage tombe de plus en plus vite après chaque mort, n'est-ce pas ?
Vous pouvez maintenant quitter l'IDE et ajouter le script en tant que composant du personnage. Pour cela, sélectionnez notre oiseau et cliquez sur Add Component > Scripts > Character . Maintenant, nous pouvons définir moveSpeed et flapHeight dans l'inspecteur (c'est à cela que servent les variables publiques). Attribuer valeurs variables 3 et 5, respectivement.
Et encore une chose : dans l'inspecteur, vous devez ajouter une balise au personnage. Pour ce faire, cliquez là où il est écrit Tag : Untagged, puis sélectionnez Player dans la liste déroulante.
Obstacles
Ajoutons maintenant des obstacles : les tuyaux. Quelqu'un trouve des champignons dans les tuyaux, et quelqu'un trouve sa propre mort.
Faites glisser le sprite de tuyau dans la scène à l'endroit où vous voulez que le premier obstacle soit et nommez-le pipe_up .
Créons maintenant un nouveau script appelé Pipe :
Public class Pipe: MonoBehaviour ( private Character character; // Nécessaire pour l'initialisation void Start () ( character = FindObjectOfType(); ) // La mise à jour est appelée une fois par image void Update () ( if (character.transform.position.x - transformation.position.x >
Ajoutez ce script au sprite de canal de la même manière qu'avant. Ainsi, le tuyau reviendra à l'écran après avoir quitté son bord gauche. Nous n'avons encore rien fait ici, mais nous y reviendrons.
La méthode OnCollisionEnter2D() est appelée chaque fois que le tube interagit avec un personnage. Après cela, la méthode Death() créée précédemment est appelée, ramenant le joueur au point de départ.
Donc, nous avons un tuyau qui disparaîtra de temps en temps et réapparaîtra à l'autre bout de l'écran. Frappez-la, vous mourrez.
tuyaux inversés
À l'heure actuelle, nous n'avons qu'un seul sprite de tuyau. Ajoutons-en un de plus. Pour ce faire, cliquez avec le bouton droit dans la fenêtre de hiérarchie, cliquez sur Nouvel objet 2D > Sprite, puis sélectionnez le sprite que vous souhaitez utiliser. Il est encore plus facile de simplement faire glisser à nouveau le fichier dans la scène.
Nommez ce sprite pipe_down . Dans l'inspecteur, sous Sprite Renderer, sélectionnez l'option Retourner Y pour retourner le tuyau à l'envers. Ajoutez le même RigidBody2D .
Écrivons maintenant un nouveau script C# appelé PipeD . Il aura un code similaire :
Public class PipeD: MonoBehaviour ( private Character character; // Nécessaire pour l'initialisation void Start() ( character = FindObjectOfType(); ) // La mise à jour est appelée une fois par image void Update() ( if (character.transform.position. x - transform.position.x > 30) ( ) ) void OnCollisionEnter2D(Collision2D other) ( if (other.gameObject.tag == "Player") ( character.Death(); ) ) )
Préfabriqués
Donc, ce code nous suffit pour faire tout le jeu. Nous pourrions déplacer les tuyaux vers la droite de l'écran à chaque fois qu'ils disparaissent, ou copier et coller autant de tuyaux que nous le voudrions tout au long du jeu.
Si vous optez pour la première voie, assurez-vous que les tuyaux sont justes après la génération aléatoire, et il serait difficile de maintenir un cours équitable des choses. Après la mort du personnage, ils pourraient apparaître à des kilomètres du premier tuyau !
Si vous optez pour la deuxième voie, tout se terminera par une consommation de mémoire excessive, avec le ralentissement du jeu qui en résulte et une valeur de relecture limitée, car. tout reste au même endroit à chaque fois.
Au lieu de cela, utilisons des préfabriqués. En termes simples, nous transformerons nos tuyaux en modèles que nous pourrons ensuite utiliser pour créer efficacement plus de tuyaux comme vous le souhaitez. S'il y a des programmeurs ici, alors considérez le script Pipe comme une classe et les pipes comme des instances de cet objet.
Pour cela, créez un nouveau dossier "Prefabs". Faites ensuite glisser pipe_up et pipe_down de la fenêtre de hiérarchie vers le dossier.
Chaque fois que vous faites glisser un objet de ce dossier dans la scène, il aura les mêmes propriétés, vous n'avez donc pas besoin de continuer à ajouter des composants. De plus, si vous redimensionnez un composant dans un dossier, cela affectera tous les canaux du jeu et vous n'aurez pas à redimensionner chacun individuellement.
Comme vous pouvez l'imaginer, cela économisera grandement nos ressources. Cela signifie également que nous pouvons interagir avec des objets à partir du code. Nous pouvons instancier nos tuyaux.
Tout d'abord, ajoutez ce code à l'expression conditionnelle dans la méthode Update() du script Pipe que nous avons laissée vide :
Void Update () ( if (character.transform.position.x - transform.position.x > 30) ( float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); Instancier (gameObject, new Vector2(character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation); Destroy(gameObject); ) )
Ceci est nécessaire pour créer une instance de notre gameObject . Le résultat est une nouvelle copie identique. Dans Unity, chaque fois que vous utilisez le mot gameObject , il fait référence à l'objet auquel le script est actuellement lié - dans notre cas, le tube.
Nous régénérons nos tuyaux dans des variations aléatoires pour le rendre plus amusant.
Mais au lieu de faire la même chose dans le script PipeD, nous générons les deux objets au même endroit. Ainsi, on peut facilement régler la position du second tuyau par rapport au premier. Cela signifie également que nous avons besoin de moins de code pour PipeD .
Créez un gameObject public nommé pipeDown . Ensuite, mettez à jour le code comme ceci :
Si (character.transform.position.x - transform.position.x > 30) ( float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); float gapRan = Random.Range (0, 3); Instanciation(gameObject, new Vector2(character.transform.position.x + 15 + xRan, -11 + yRan), transform.rotation); Instantiate(pipeDown, new Vector2(character.transform.position.x + 15 + xRan, 12 + gapRan + yRan), transform.rotation); Détruire(gameObject); )
Revenez à Unity et faites glisser le préfabriqué pipe_down du dossier prefabs (c'est important !) À l'endroit où il est écrit "Pipe Down" (remarquez comment notre cas de chameau est remplacé par un espace) sur le sprite de tuyau pipe up . Si vous vous souvenez, nous avons défini Pipe Down comme un gameObject public, ce qui nous donne la possibilité de déterminer quel est cet objet de n'importe où - dans ce cas via l'inspecteur. En choisissant un préfabriqué pour cet objet, nous nous assurons que lorsque le tube sera instancié, il inclura tous les attributs et scripts que nous avons ajoutés précédemment. Nous ne créons pas simplement un sprite, mais nous recréons un objet avec un collisionneur qui peut tuer le personnage.
Tout ce que nous ajouterons au même endroit dans le script PipeD est simplement Destroy(gameObject) , de sorte que le tube s'autodétruira lorsqu'il sortira du côté gauche de l'écran.
Si vous démarrez le jeu maintenant, l'écran avancera automatiquement et vous mourrez si vous touchez l'un des tuyaux. Volez assez loin et ces tuyaux disparaîtront et réapparaîtront devant vous.
Malheureusement, il y a une grande distance entre les tuyaux et l'écran semble vide. Nous pourrions résoudre ce problème en ajoutant des préfabriqués à notre scène pour créer un pipeline de tuyaux qui apparaissent constamment. Cependant, il serait préférable de générer les pipes dans un script. Ceci est important, car sinon, après la mort du personnage, les tuyaux au début du chemin seront détruits et un espace vide se formera à nouveau.
De cette façon, nous pouvons créer les premiers tuyaux lors de chaque chargement de jeu et tout remettre à sa place après la mort du personnage.
Vol sans fin
Créons maintenant les variables publiques pipe_up et pipe_down dans le script Character. Cela vous donnera la possibilité de référencer les objets créés en faisant glisser des préfabriqués sur l'objet personnage, tout comme lorsque nous avons ajouté pipe_down au script Pipe.
Nous devons ajouter ces variables :
Public GameObject pipe_up ; public GameObject pipe_down ;
Ensuite, nous écrirons une méthode comme celle-ci :
Public void BuildLevel() ( Instantiate(pipe_down, new Vector3(14, 12), transform.rotation); Instantiate(pipe_up, new Vector3(14, -11), transform.rotation); Instantiate(pipe_down, new Vector3(26, 14), transform.rotation); Instantiate(pipe_up, new Vector3(26, -10), transform.rotation); Instantiate(pipe_down, new Vector3(38, 10), transform.rotation); Instantiate(pipe_up, new Vector3( 38, -14), transform.rotation); Instantiate(pipe_down, new Vector3(50, 16), transform.rotation); Instantiate(pipe_up, new Vector3(50, -8), transform.rotation); Instantiate(pipe_down, new Vector3(61, 11), transform.rotation);Instanciation(pipe_up, new Vector3(61, -13), transform.rotation); )
Nous l'appellerons une fois dans la méthode Update() et une fois dans la méthode Death().
Après le démarrage du jeu, Update() est appelé et nos tuyaux sont placés en fonction de la configuration donnée. De ce fait, les premiers obstacles seront toujours au même endroit. Après la mort du joueur, les tuyaux reviendront aux mêmes endroits.
Revenez à la scène dans Unity et supprimez les deux tuyaux qui s'y trouvent maintenant. Votre "jeu" ressemblera à un écran vide avec un oiseau. Appuyez sur Play et les tuyaux apparaîtront, après les premiers, leur position sera déterminée au hasard.
Pour terminer
C'est ce que nous avons fait Tout le jeu! Ajoutez un compteur de score, essayez de le rendre plus original et augmentez la difficulté du jeu au fur et à mesure de votre progression. Aussi, il ne sera pas superflu de faire un menu. Une autre bonne idée est de détruire les tuyaux à l'écran après la mort du personnage. Une fois que vous avez terminé, considérez qu'il est prêt à être publié dans Jouer au magasin jeu dans votre poche! Il était une fois jeu similaire a rendu un autre développeur très riche, ce qui prouve qu'il n'est pas nécessaire d'être un génie de la programmation ou d'avoir un riche éditeur derrière soi pour réussir. Vous avez juste besoin d'une bonne idée et de dix minutes !
Vous voulez écrire des applications Android mais vous ne savez pas par où commencer ? Consultez ensuite notre excellent didacticiel pour apprendre le développement Android.
