Home-theater-designers
Une caractéristique surprenante de l'économie Internet est l'essor des jeux vidéo indépendants. Autrefois le domaine exclusif des studios triple-A de mille hommes et de plusieurs millions de dollars, un certain nombre d'ensembles d'outils ont été développés qui mettent les ressources de développement de jeux modernes entre les mains d'individus ou de petites collections ad hoc de programmeurs et de concepteurs. Nous avons déjà discuté des meilleurs jeux indépendants, alors assurez-vous de les consulter pour vous inspirer de ce qui peut être réalisé avec des outils tels que Unity.
Ces équipes de développement de jeux indépendants ont fait preuve d'une agilité et d'une tolérance au risque qui, dans de nombreux cas, leur permettent de pousser l'innovation du gameplay plus rapidement que leurs homologues à gros budget. Un certain nombre de titres indépendants au succès choquant ont été créés ces dernières années, notamment Minecraft , Limbo , et Super Meat Boy , et même si vous n'avez pas les compétences nécessaires pour créer des jeux comme celui-ci, vous pouvez créer un jeu en utilisant Buildbox .
Dans le paysage en évolution rapide du développement de jeux indépendants, Unité est devenu une sorte de standard de facto : son faible coût, sa facilité d'utilisation et son large éventail de fonctionnalités le rendent idéal pour le développement rapide de jeux. Unity est si flexible que vous pouvez même créez vos propres contrôleurs de jeu personnalisés avec un peu de bricolage !
Même les grands studios comme CCP (Développeurs de Eve en ligne ) l'utilisent pour prototyper rapidement des concepts de jeu. Unity fournit un « moteur de jeu dans une boîte », un moteur de physique et de rendu avec des crochets pour plusieurs langages de script, adaptable à pratiquement tous les genres de jeux vidéo.
Bien qu'Unity fournisse un éditeur visuel pour manipuler l'environnement de jeu, Unity n'est pas un outil de création de jeux « zéro programmation ». Il vous oblige à programmer pour produire des résultats, mais vous offre également un outil beaucoup plus flexible et puissant que n'importe quel programme de « créateur de jeux ».
Unity ne fera pas le travail à votre place, mais il abaisse considérablement la barrière à l'entrée. En partant de zéro avec C++ et OpenGL, cela peut prendre des jours pour arriver au point où quelque chose est réellement rendu à l'écran. Avec Unity, cela prend environ dix secondes. Unity met les éléments de base de la création de jeux entre les mains des programmeurs novices de manière rapide et intuitive.
Aujourd'hui, je vais vous guider à travers tout ce que vous devez savoir pour créer un jeu dans Unity, qui se décompose en dix chapitres principaux :
§3–Une brève introduction au paradigme orienté objet
§5–Exemple : Éléments de base d'un jeu
§8–Exploration de la documentation / En savoir plus
§9–Créer votre jeu / Compiler en une application autonome
1. Versions d'Unité
Unity se décline en deux versions de base : la version pro et la version gratuite. Il y a un nombre de différences , mais, d'une manière générale, la version pro prend en charge un certain nombre d'améliorations visuelles (comme les ombres douces en temps réel et le post-traitement) et un grand nombre de fonctionnalités relativement mineures qui sont extrêmement utiles pour les jeux plus complexes.
Cela dit, pour la plupart des jeux relativement simples que vous pourriez vouloir construire, la version gratuite de Unity est parfaitement adéquate. Nous allons détailler les principales différences ci-dessous pour les personnes intéressées.
1.1 Tarification
La version gratuite de Unity est, bien sûr, gratuite. Cependant, il existe quelques limitations : la version gratuite de Unity ne peut être concédée sous licence à aucune entreprise dont le revenu annuel est supérieur à 100 000 $ . Bien que de telles organisations dépassent le cadre de ce guide, si vous pensez que vous pourriez devenir une telle organisation, il est probablement sage de passer à la version Pro.
La version Pro de Unity est 75 $ un mois, ou 1500 $ pour une licence permanente, et n'a aucune limite sur ce que vous pouvez faire avec les jeux créés avec. Un essai gratuit de 30 jours est également disponible, que nous utiliserons pour ce guide, afin de vous donner un aperçu aussi complet que possible des fonctionnalités disponibles. Une licence d'étudiant d'un an est également disponible via Étudier pour 129 $ .
1.2 Caractéristiques
De nombreuses fonctionnalités sont absentes de la version gratuite de Unity. Cependant, les différences les plus importantes sont les suivantes : la version gratuite de Unity manque d'un certain nombre d'options de rendu qui permettent des jeux plus beaux et plus rapides (prise en charge de LOD, post-traitement de l'espace d'écran, shaders avancés, logiciel en temps réel ombres et rendu différé). Il manque aussi le plein système d'animation mécanique , et quelques outils d'IA.
En général, pour les projets complexes à grande échelle, ou les projets où les performances graphiques sont importantes, la version pro en vaut la peine. J'utilise la version pro, car je développe des jeux de réalité virtuelle pour l'Oculus Rift, et le support du post-traitement écran-espace est nécessaire pour interagir correctement avec le casque.
2. Installer Unity
Unity est simple à installer. Vous pouvez télécharger l'exécutable depuis unity3d.com/get-unity/download .
Une fois téléchargé, exécutez-le, puis suivez les instructions du programme d'installation. Une fois l'installation terminée, une fenêtre intitulée « Activez votre licence Unity » apparaîtra. Cochez la case « activer un essai gratuit de 30 jours de Unity Pro », puis « OK ».
Toutes nos félicitations! Vous disposez désormais d'un essai de 30 jours de Unity Pro. À l'expiration de la période d'essai, si vous ne souhaitez pas acheter la version pro, vous pouvez passer à la version gratuite et conserver votre contenu existant.
que signifie aucun emplacement trouvé
3. Une brève introduction au paradigme orienté objet
Avant de commencer avec Unity, il est important de revoir un peu les bases. Unity prend en charge les deux C # et JavaScript pour programmation de jeux ; nous allons travailler avec C# pour ce tutoriel.
Tout d'abord, si vous n'avez jamais programmé auparavant, mettez ce tutoriel de côté et passez quelques jours à travailler avec Microsoft C # Introduction au langage jusqu'à ce que vous vous sentiez à l'aise d'utiliser la langue pour des tâches simples.
Si vous souhaitez quelque chose d'un peu différent de C# (mais pas nécessairement un langage que vous pouvez utiliser dans Unity), alors jetez un œil à notre guide des six langages de programmation les plus simples pour les débutants.
Si vous avez déjà programmé dans un langage impératif ou orienté objet comme C ou Java, survolez l'introduction et familiarisez-vous avec les différences entre C# et les autres langages que vous avez utilisés dans le passé. Quoi qu'il en soit, ne poursuivez pas le didacticiel tant que vous ne vous sentez pas à l'aise pour résoudre des problèmes simples avec C# (par exemple, si je vous demandais d'écrire un programme qui imprime les cent premiers nombres premiers, vous devriez être capable d'écrire ce programme sans consultation de Google).
Le concept le plus important à comprendre ici est le paradigme orienté objet (en abrégé OUVERT ). Dans les langages orientés objet, les programmes sont divisés en unités fonctionnelles appelées Objets . Chaque objet a ses propres variables et fonctions privées. Les fonctions spécifiques à l'objet sont appelées méthodes .
L'idée ici est la modularité : en isolant chaque objet et en forçant d'autres objets à interagir avec lui via ses méthodes, vous pouvez réduire le nombre d'interactions non intentionnelles possibles et, par extension, les bogues. Vous pouvez également créer des objets que vous pourrez réutiliser ultérieurement sans aucune modification. Dans Unity, vous allez construire ces objets et les attacher à entités de jeu (dont ils gouverneront le comportement).
Les objets sont instanciés à partir de Des classes : une classe est juste un fichier qui présente la définition de votre objet. Alors, si vous voulez un moqueur objet qui gère l'IA pour un ennemi dans votre jeu, vous écririez une classe « Mook », puis attachiez ce fichier à chaque entité ennemie. Lorsque vous lancez votre jeu, chaque ennemi sera équipé d'une copie de l'objet 'Mook'.
L'attachement d'un nouveau script à un objet ressemble à ceci :
D'abord, sélectionner l'objet et allez au Inspecteur . Clique sur le Ajouter un composant bouton.
Aller à nouveau scénario , entrez le nom que vous voulez et cliquez sur créer et ajouter .
Vous avez maintenant un nouveau script que vous pouvez éditer en double-cliquant dessus !
Un fichier de classe ressemble à ceci :
using UnityEngine;
public class Mook : MonoBehaviour {
private float health;
void Start () {
health = 100;
}
void Update(){
if (health > 0) {
/* Search for player
if you encounter the player on the road, kill him
if you get shot, remove a random amount of health */
}
}
}Décomposons ceci :
- Utilisation de UnityEngine : Cette ligne indique à C# que nous souhaitons utiliser les bibliothèques Unity, qui nous permettent de nous connecter au moteur de jeu Unity.
- Classe publique Mook : MonoComportement : Cette ligne déclare la classe et son nom -- moqueur .
- Santé du flotteur privé : Cela déclare une variable de classe privée (qui ne peut être modifiée que depuis l'intérieur de la classe). La variable reçoit une valeur en Début .
- Début du vide () : Ceci déclare une méthode appelée Début . Start est une méthode spéciale qui ne s'exécute qu'une seule fois, lors du lancement initial du jeu.
- Annuler la mise à jour () : La mise à jour est une autre méthode spéciale, qui s'exécute sur chaque image. La plupart de votre logique de jeu ira ici.
- //si vous rencontrez le joueur sur la route, tuez-le : Cette ligne est un commentaire (toute ligne commençant par une double barre oblique est ignorée par C#). Les commentaires sont utilisés pour vous rappeler ce que font certains morceaux de code. Dans ce cas, ce commentaire est utilisé pour remplacer un bloc de code plus compliqué qui fait réellement ce que le commentaire décrit.
De même que Début et Mettre à jour , vous pouvez instancier vos propres méthodes avec presque n'importe quel nom. Cependant, les méthodes que vous créez ne s'exécuteront que si elles sont appelées. Déclarons une méthode pour une classe hypothétique appelée ajouterDeuxNuméros qui additionne deux nombres ensemble :
public float addTwoNumbers(float a, float b) {
return a+b;
}Cela déclare une méthode publique (accessible à d'autres objets) qui renvoie un flottant, appelé ajouterDeuxNuméros , qui prend deux flottants en entrée (appelé à et b ). Il renvoie ensuite la somme des deux valeurs en sortie.
Appeler cette méthode depuis la même classe (par exemple, depuis l'intérieur Mettre à jour ) ressemble à ça:
float result = addTwoNumbers(1, 2);L'appel de la méthode depuis une autre classe est similaire :
addTwoNumbers instance;
float result = instance.addTwoNumbers(1, 2);Encore une fois, cela crée simplement une instance de notre classe, accède à la méthode appropriée et lui fournit les nombres que nous voulons ajouter, puis stocke le résultat dans résultat . Simple.
Si votre script est attaché à un objet qui a des propriétés spéciales (comme un émetteur de particules) qui ne sont pas accessibles avec l'ensemble normal de paramètres GameObject, vous pouvez choisir de le traiter comme un type différent d'entité de jeu en utilisant le ObtenirComposant méthode.
La syntaxe pour cela ressemble à ceci:
GetComponent().Play();Si l'un de ces éléments ne vous est pas familier, revenez en arrière et parcourez l'introduction C#. Cela vous évitera beaucoup de frustration au fur et à mesure que nous procédons.
4. Les bases d'Unity
Dans cette section, nous allons parcourir les mécanismes de base du moteur Unity. Le flux de travail dans Unity ressemble à ceci :
- Créez une entité pour jouer un rôle dans le jeu (vide Objets de jeu peut être utilisé pour des tâches logiques abstraites).
- Ecrivez ou recherchez un fichier de classe, et ajoutez-le à l'entité en tant que script (en utilisant le Ajouter un composant bouton dans le inspecteur vue.
- Courir > test > déboguer > répéter jusqu'à ce que cela fonctionne et passez à l'élément suivant du jeu.
Unity est livré avec un certain nombre d'onglets de vue de base qui peuvent être disposés de différentes manières au goût de l'utilisateur. Les cinq grands sont :
- Jeu: affiche une instance du jeu en cours d'exécution avec laquelle vous pouvez interagir et tester.
- Scène: fournit une version statique et modifiable du Univers du jeu .
- Inspecteur: vous permet de modifier des entités individuelles dans le monde du jeu en les sélectionnant dans le éditeur languette.
- Projet: vous permet de parcourir les fichiers du projet et de faire glisser des modèles, des matériaux et d'autres ressources dans le éditeur onglet pour les placer dans le monde du jeu.
- Hiérarchie: cet onglet affiche tous les objets du monde, vous permettant de trouver des objets distants dans la scène et des entités parentes les unes par rapport aux autres en cliquant et en faisant glisser.
Voir le schéma ci-dessous pour les emplacements de toutes ces choses :
4.1 Entités d'unité
4.1.1 Maillages
Les mailles sont le chemin Géométrie 3D est représenté dans Unity. Vous pouvez soit utiliser le module intégré de Unity primitif objets (cubes, sphères, cylindres, etc.), ou importez vos propres modèles 3D à partir d'un logiciel de modélisation comme Mixeur ou Maya . Unity prend en charge une variété de formats 3D, y compris .fbx , et .3ds .
Les outils de base pour manipuler les maillages sont les boutons de mise à l'échelle, de rotation et de translation dans le coin supérieur gauche de l'interface. Ces boutons ajoutent des icônes de contrôle aux modèles dans la vue de l'éditeur, qui peuvent ensuite être utilisées pour les manipuler dans l'espace. Pour modifier la texture ou les propriétés physiques d'un objet, sélectionnez-les et utilisez le inspecteur vue pour analyser la Matériel et corps rigide éléments.
4.1.2 Éléments de l'interface graphique
Les images-objets et le texte de l'interface graphique traditionnelle peuvent être affichés à l'aide du Texte de l'interface graphique et le Texture de l'interface graphique GameObjects dans l'éditeur. Cependant, une manière plus robuste et réaliste de gérer les éléments de l'interface utilisateur consiste à utiliser le texte 3D et Quad GameObjects (avec des textures transparentes et un shader transparent non éclairé) pour placer les éléments HUD dans le monde du jeu en tant qu'entités.
Dans le hiérarchie vue, ces éléments de jeu peuvent être glissés sur la caméra principale pour en faire des enfants, garantissant qu'ils se déplacent et tournent avec la caméra.
Les éléments de l'interface graphique (texte et textures) peuvent avoir leur taille et leur échelle ajustées à l'aide des champs appropriés dans l'onglet inspecteur.
4.1.3 Matériaux
Les matériaux sont des combinaisons de textures et de shaders et peuvent être glissés directement sur les objets du jeu depuis l'onglet projet. Un grand nombre de shaders sont fournis avec Unity Pro, et vous pouvez ajuster la texture qui leur est attachée à l'aide de l'onglet inspecteur pour un objet auquel ils sont appliqués.
Pour importer une texture, convertissez-la en .jpg , .png , ou .bmp , et faites-le glisser dans le les atouts sous le répertoire du projet Unity (qui apparaît dans Mes documents par défaut). Après quelques secondes, une barre de chargement apparaîtra dans l'éditeur. Une fois terminé, vous pourrez trouver l'image sous forme de texture sous le projet languette.
4.1.5 Lumières
Les lumières sont Objets de jeu qui projettent de l'éclat sur le monde. S'il n'y a pas de lumière dans votre scène, tous les polygones sont dessinés au même niveau de luminosité, donnant au monde un aspect plat et délavé.
Les lumières peuvent être positionnées, tournées et ont plusieurs caractéristiques internes que vous pouvez personnaliser. Les intensité curseur contrôle la luminosité de la lumière, et le gamme contrôle la vitesse à laquelle il s'estompe.
Les lignes directrices dans le vue de la scène vous montrer la portée maximale de l'éclairage. Jouez avec les deux réglages pour obtenir l'effet souhaité. Vous pouvez également ajuster la couleur de la lumière, le motif ( biscuit affiché sur la surface vers laquelle la lumière est pointée, et quel type de lumière apparaît à l'écran lorsque vous regardez directement la lumière. Le cookie peut être utilisé pour simuler des motifs lumineux plus réalistes, créer de fausses ombres dramatiques et simuler des projecteurs.
Les trois principaux types de lumière sont endroit , point , et directionnel .
Spots avoir un emplacement dans l'espace 3D et projeter la lumière dans une seule direction dans un cône d'angle variable. Ceux-ci sont bons pour les lampes de poche, les projecteurs et, en général, vous donnent un contrôle plus précis de l'éclairage. Les spots peuvent projeter des ombres.
Lumières ponctuelles avoir un emplacement dans l'espace 3D et projeter la lumière uniformément dans toutes les directions. Les lumières ponctuelles ne projettent pas d'ombres.
Feux directionnels , enfin, servent à simuler la lumière du soleil : ils projettent la lumière dans une direction comme d'une infiniment lointaine. Les lumières directionnelles affectent chaque objet de la scène et peuvent produire des ombres.
4.1.6 Systèmes de particules
À Système de particules est un GameObject qui génère et contrôle des centaines ou des milliers de particules simultanément. Les particules sont de petits objets 2D optimisés affichés dans l'espace 3D. Les systèmes de particules utilisent un rendu et une physique simplifiés, mais peuvent afficher des milliers d'entités en temps réel sans bégaiement, ce qui les rend idéaux pour la fumée, le feu, la pluie, les étincelles, les effets magiques, etc.
Il existe de nombreux paramètres que vous pouvez modifier pour obtenir ces effets, et vous pouvez y accéder en créant un système de particules sous le éditeur de composants > sélection du système de particules > ouverture de l'onglet inspecteur . Vous pouvez modifier la taille, la vitesse, la direction, la rotation, la couleur et la texture de chaque particule, et définir la plupart de ces paramètres pour qu'ils changent également au fil du temps.
Sous le collision attribut, si vous l'activez et définissez l'espace de simulation sur monde vous obtiendrez des particules qui entreront en collision avec des objets dans le monde, qui peuvent être utilisées pour un certain nombre d'effets de particules réalistes, notamment la pluie, l'eau en mouvement et les étincelles.
5. Exemple : Éléments de base d'un jeu
Pour ce tutoriel, nous allons faire un jeu simple de Pong -- quelque chose que nous avons déjà couvert plusieurs fois dans le bricolage :
- Arduino Classique Pong
- Pong Arduino OLED
Dans cette section, nous allons passer en revue l'organisation des éléments de base - le didacticiel de script viendra plus tard.
Tout d'abord, décomposons le jeu de Pong en ses composants de base. Tout d'abord, nous avons besoin de deux pagaies et d'une balle. La balle vole hors de l'écran, nous voudrons donc un mécanisme pour la réinitialiser. Nous voulons également que le texte affiche le score actuel et, pour vous montrer tous les éléments essentiels de Unity, nous voulons un effet de particules fantaisie lorsque vous frappez la balle. L'ensemble du jeu devra être considérablement éclairé.
Qui se décompose en un objet balle (une sphère), une géniteur , deux hélices de pagaie avec émetteurs de particules ci-joint, un Entité de texte 3D , et un projecteur . Pour ce tutoriel, nous utiliserons le matériau physique par défaut rebondir , avec rebond combiner mis à multiplier . Voici à quoi ressemble la configuration, en dix captures d'écran :
Tout d'abord, créez un accessoire de cube pour la pagaie.
Redimensionnez-le de manière appropriée, le dupliquer , et mettre un sphère entre les palettes pour le ballon.
Ensuite, créez un Objet 3DText et escalader et position correctement, en changeant le taille de police attribut pour obtenir une image moins pixelisée.
Ensuite, créez deux systèmes de particules , choisissez les caractéristiques que vous voulez et attachez-les aux palettes.
Ensuite, vous voudrez positionner et faire pivoter la caméra pour qu'il cadre correctement la scène. Lorsque la caméra est sélectionnée, vous pouvez voir un petit aperçu de la vue de la caméra dans le coin inférieur droit.
Avant de terminer, nous devons créer deux cubes supplémentaires pour être des pare-chocs, pour empêcher la balle de rebondir hors de la zone de jeu. Nous pouvons les rendre invisibles en décochant la case rendu de maillage dans le onglet inspecteur .
Si vous appuyez sur jouer, vous pouvez maintenant voir les éléments de base de notre jeu présentés. Ils ne feront encore rien, mais on y arrivera !
Maintenant que nous avons cette configuration, nous allons parler de ce qu'implique le script de ces éléments pour créer un jeu.
6. Script dans Unity
Une fois que vous avez un script attaché à un objet, vous pouvez le réviser en double-cliquant dessus dans le inspecteur . Cela ouvre MonoDevelop , l'environnement de développement par défaut pour Unity. En substance, Monodevelop est un éditeur de texte avec des fonctionnalités spécifiquement optimisées pour la programmation.
Les mots-clés et les commentaires sont mis en évidence dans bleu et vert , et les valeurs numériques et les chaînes apparaissent dans rapporter . Si vous avez utilisé Éclipse ou d'autres IDE, MonoDevelop est très similaire. Vous pouvez construire vos scripts depuis l'éditeur, pour vérifier les erreurs de syntaxe, comme ceci :
En général, pour que votre script interagisse avec Unity, vous devez référencer les éléments que possède l'objet contenant le script (vous pouvez voir une liste de ces éléments sous le inspecteur onglet lorsque l'objet concerné est sélectionné). Vous pouvez ensuite appeler des méthodes ou définir des variables pour chacun de ces éléments afin d'appliquer les modifications souhaitées.
Si vous souhaitez qu'un script sur un objet affecte les propriétés d'un autre objet, vous pouvez créer un GameObject variable dans votre script et utilisez la inspecteur pour l'affecter à un autre objet de la scène.
Une liste des éléments qu'un objet peut avoir est la suivante (tirée de la vue inspecteur de l'une de nos palettes dans l'exemple ci-dessus) :
- Transformer
- Cube (filtre maillé)
- Collisionneur de boîte
- Rendu de maillage
Chacun de ces aspects de l'objet peut être influencé à partir d'un script. Ensuite, nous verrons exactement comment.
6.1 Transformer
Les fonctions de transformation d'un GameObject dans Unity contrôlent les paramètres physiques de cet objet : son escalader , son position , et son orientation . Vous pouvez y accéder depuis un script comme celui-ci :
transform.position = newPositionVector3;
transform.rotation = newRotationQuaternion;
transform.localScale = newScaleVector3;Dans les exemples ci-dessus, les variables nommées sont des types spécifiés dans les noms. Il y a quelques détails clés ici : la position et l'échelle sont, comme vous vous en doutez, stockées sous forme de Vector3s . Vous pouvez accéder au X , ET , et AVEC composants de chacun (par exemple, transformer.position.y vous donne la distance d'un objet au-dessus du plan zéro).
Cependant, pour éviter verrou de cardan , les rotations sont traitées comme quaternions (vecteurs à quatre composantes). Comme la manipulation manuelle des quaternions n'est pas intuitive, vous pouvez manipuler les rotations en utilisant les angles eulériens en utilisant le Quaternion.Euler méthode comme ceci :
transform.rotation = Quaternion.Euler(pitch, yaw, roll);Si vous souhaitez déplacer des objets en douceur d'un endroit à un autre, vous trouverez le Slerp méthode pour les quaternions et vector3s utile. Slerp prend trois arguments - l'état actuel, l'état final et la vitesse de changement, et interpole en douceur entre eux à la vitesse donnée. La syntaxe ressemble à ceci :
transform.position = Vector3.Slerp(startPositionVector3, newDestinationVector3, 1);6.2 Moteur de rendu
Les fonctions de rendu dans Unity vous permettent de contrôler la façon dont les surfaces des accessoires sont rendues à l'écran. Vous pouvez réaffecter la texture, modifier la couleur et modifier le shader et la visibilité de l'objet. La syntaxe ressemble à ceci :
renderer.enabled = false;
renderer.material.color = new Color(0, 255, 0);
renderer.material.mainTexture = myTexture;
renderer.material.shader = newShader;La plupart d'entre eux ont des fonctions assez claires. Le premier exemple rend l'objet en question invisible : une astuce utile dans de nombreuses situations. Le deuxième exemple attribue un nouveau Couleur RVB (à savoir, vert) à l'objet en question. La troisième affecte la texture diffuse principale à une nouvelle variable Texture. Le dernier exemple change le shader du matériau de l'objet en une variable de shader nouvellement définie.
6.3 Physique
Unity est livré avec un moteur physique intégré - quelque chose que les jeux de bac à sable physique utilisent tous. Cela vous permet d'attribuer les propriétés physiques des objets et de gérer les détails de leur simulation pour vous. En général, plutôt que d'essayer d'implémenter votre propre physique à l'aide d'un manuel et du système de transformation, il est plus simple et plus robuste d'utiliser le moteur physique de Unity dans toute la mesure du possible.
Tous les accessoires de physique nécessitent collisionneurs . Cependant, la simulation elle-même est gérée par un corps rigide , qui peut être ajouté dans le inspecteur vue. Les corps rigides peuvent être cinématique ou non cinématique .
Les accessoires de physique cinématique entrent en collision avec (et affectent) les accessoires de physique non cinématiques autour d'eux, mais ne sont pas affectés par la collision eux-mêmes. Les accessoires cinématiques statiques sont les objets immobiles proverbiaux, et les objets cinématiques en mouvement sont la force imparable proverbiale (pour mémoire, lorsqu'ils entrent en collision, ils se traversent simplement).
Au-delà de cela, vous pouvez ajuster la traînée angulaire de l'objet (la quantité d'énergie nécessaire pour le faire tourner), modifier sa masse, dicter s'il est ou non affecté par la gravité et lui appliquer des forces.
Exemples:
rigidbody.angularDrag = 0.1f;
rigidbody.mass = 100;
rigidbody.isKinematic = false;
rigidbody.useGravity = true;
rigidbody.AddForce(transform.forward * 100);Ce sont tous assez explicites. La seule chose à noter ici est l'utilisation de transformer.forward . Les Vector3 ont tous trois composants ( .effronté , .en haut , et .droit ) qui leur sont associés, qui sont accessibles et qui tournent avec eux ( effronté est la direction de la flèche bleue dans l'éditeur). Les transformer.forward Le mot-clé est simplement le vecteur avant de l'objet actuel de magnitude 1. Il peut être multiplié par un flotteur pour créer plus de force sur l'objet. Vous pouvez également référencer transformer.up et transformer.right , et annulez-les pour obtenir leurs revers.
6.4 Collision
Souvent, lors de la création d'un jeu, vous aimeriez qu'une collision entraîne un changement d'état dans votre code, au-delà de la simple simulation physique. Pour cela, vous aurez besoin d'un méthode de détection de collision .
Un certain travail de préparation est nécessaire pour détecter les collisions dans Unity. Premièrement, au moins un des objets dans la collision a besoin d'un corps rigide non cinématique attaché à celui-ci. Les deux objets doivent avoir des collisionneurs corrects, définis comme non déclencheurs. La vitesse totale des deux objets doit être suffisamment faible pour qu'ils entrent en collision, au lieu de simplement se sauter l'un sur l'autre.
Si vous avez tout réglé, vous pouvez vérifier la collision en plaçant une méthode spéciale de détection de collision dans un script attaché à l'objet avec lequel vous souhaitez vérifier la collision. La méthode ressemblera à ceci :
void OnCollisionEnter(Collision other) {
//do things here
}Cette méthode s'exécutera automatiquement lors de la première image où un autre objet touche votre objet. L'entité de collision autre est une référence à l'objet que vous frappez. Vous pouvez, par exemple, référencer son objet de jeu , corps rigide , et transformer caractéristiques pour le manipuler de diverses manières. Tandis que SurCollisionEntrer est probablement la fonction la plus courante que vous utiliserez, vous pouvez également utiliser SurCollisionSortie et OnCollisionStay (avec une syntaxe et une utilisation par ailleurs identiques), qui s'activent pendant la première image où vous arrêtez d'entrer en collision avec un objet et pendant chaque image où vous entrez en collision avec un objet, respectivement.
Parfois, il peut aussi être utile de faire ce qu'on appelle diffusion de rayons . En raycasting, une ligne infiniment fine (un rayon ) est projeté à travers le monde à partir d'une origine, le long d'un vecteur, et, lorsqu'il heurte quelque chose, la position et d'autres détails de la première collision sont renvoyés. Le code d'un raycast ressemble à ceci :
RaycastHit hit;
if (Physics.Raycast(transform.position, -Vector3.up, out hit)) {
float distanceToGround = hit.distance;
}Cela projette un rayon à partir de la position de l'objet actuel le long de -Vector3.up (directement vers le bas) et lie la variable frappé au premier objet avec lequel il entre en collision. Une fois que votre rayon a touché quelque chose, vous pouvez accéder distance.de.atteinte pour déterminer à quelle distance il est, ou hit.GameObject pour manipuler l'objet que vous frappez.
Des raycasts comme celui-ci peuvent être utilisés par les tireurs pour déterminer sur quoi l'arme est pointée, ou pour sélectionner des objets lorsque la caméra les regarde, ou pour certains styles de mécanique de mouvement.
6.5 Correction du temps
Un facteur important à garder à l'esprit lorsque vous manipulez des objets de cette manière a à voir avec fréquence d'images . Quel que soit le soin avec lequel vous optimisez, les fréquences d'images varieront toujours et vous ne voulez pas que votre vitesse de jeu varie en conséquence. Si quelqu'un d'autre exécute votre jeu sur un ordinateur plus rapide que celui sur lequel vous l'avez développé, vous ne voulez pas que le jeu s'exécute à une vitesse double.
La façon dont vous corrigez cela est de multiplier les valeurs que vous utilisez par le temps qu'il a fallu pour rendre la dernière image. Cela se fait en utilisant Heure.deltaHeure . Cela modifie efficacement la vitesse de toute variable à partir de laquelle vous incrémentez chaque image. changement par image à changement par seconde , et vous devriez probablement apporter cette modification à toute valeur que vous incrémentez ou décrémentez à chaque image.
6.6 Sources audio et auditeurs
Maintenant que nous avons vu comment créer, rendre et contrôler des objets, parlons de l'autre sens que les jeux informatiques peuvent servir : à savoir, sonner . Unity prend en charge deux types de sons : 2D et 3D des sons. Les sons 3D varient leur volume en fonction de la distance et se déforment lorsqu'ils se déplacent par rapport à la caméra ; Les sons 2D ne le font pas.
Les sons 2D sont appropriés pour les voix off et la musique de fond, et les sons 3D s'appliquent aux sons générés par des événements dans le monde. Pour changer si un son est ou non en 3D, sélectionnez-le dans le projet vue, passez à la inspecteur afficher et sélectionner l'option appropriée dans le menu déroulant, puis appuyer sur le bouton réimporter bouton.
Afin de jouer réellement le son, vous devrez attacher un source audio à un accessoire (l'accessoire dont vous voulez que le son provienne, dans le cas d'un son 3D). Ensuite, vous devrez ouvrir le clip audio et sélectionnez votre fichier son.
peux-tu être invisible sur facebook
Vous pouvez utiliser maSourceAudio.Pause () et myAudioSource.Play () pour contrôler ces fichiers audio. Vous pouvez régler les comportements d'atténuation, le volume et le décalage Doppler des sons sous le inspecteur onglet pour la source audio.
6.7 Saisie
Un jeu qui ne demande aucune contribution de l'utilisateur n'est pas vraiment un jeu. Il existe de nombreux types d'entrées que vous pouvez lire, et presque toutes sont accessibles via le Saisir et Code clé objets. Quelques exemples d'instructions d'entrée (qui ont des valeurs évaluées à chaque image) sont ci-dessous.
Vector3 mousePos = Input.mousePosition;
bool isLeftClicking = Input.GetMouseButton(0);
bool isPressingSpace = Input.GetKey(KeyCode.Space);Les fonctions de ces lignes sont pour la plupart explicites. En utilisant ces trois types de référence d'entrée, vous pouvez reconstruire les schémas de contrôle de la plupart des jeux informatiques 3D modernes.
6.8 Débogage d'un script
Disons qu'un script ne fonctionne pas. Comme le dit le bon docteur, des bangups et des raccrochages peuvent vous arriver. S'il y a des erreurs de syntaxe pures avec votre C#, le jeu refusera généralement de s'exécuter lorsque vous appuyez sur play, et des messages d'erreur assez utiles sont fournis si vous construire les scripts depuis l'éditeur. Voir ci-dessous:
Ces bogues ne sont généralement pas les plus difficiles à corriger. Ce qui peut être plus problématique, ce sont les erreurs sémantiques subtiles, dans lesquelles vous avez écrit avec succès un fichier plein de C# valide - mais pas celui qui fait ce que vous pensiez qu'il ferait. Si vous rencontrez l'une de ces erreurs et que vous avez du mal à la localiser, vous pouvez essayer certaines choses pour améliorer la situation.
La première consiste à mettre en pause l'exécution du jeu et à vérifier la console. Vous pouvez mettre le jeu en pause en cliquant sur le pause dans la partie centrale supérieure de l'éditeur, puis en sélectionnant console du bas de la la fenêtre menu (ou en appuyant sur Ctrl > Décalage > C ). Même s'il n'y a pas d'erreurs, les avertissements peuvent toujours aider à donner des indices sur ce qui pourrait ne pas aller.
Si cela ne fonctionne pas, vous pouvez également essayer d'avoir une idée de l'état de votre script en imprimant l'état des variables internes pour valider que le programme fait ce que vous pensez qu'il fait. Vous pouvez utiliser Debug.Log (chaîne) pour imprimer le contenu d'une chaîne sur la console lorsque l'exécution du programme atteint cette ligne. En général, si vous travaillez à rebours à partir de ce que vous pensez devrait se produire à travers les choses qui devraient le faire arriver, vous finirez par atteindre un point où vos impressions de débogage ne font pas ce que vous attendez d'elles. C'est là qu'est ton erreur.
7. Exemple : Script Pong
Pour construire Pong, décomposons le jeu en ses principaux éléments : nous avons besoin d'une balle qui ricoche entre les palettes à une vitesse croissante, nous avons besoin d'un tableau de bord qui sache quand les balles ont dépassé les palettes, et nous avons besoin d'un mécanisme pour relancer la balle quand cela se produit. Une bonne première étape serait d'ajouter un corps rigide non cinématique à la balle, deux corps rigides cinématiques aux palettes, de désactiver la gravité pour chacun d'eux et d'attribuer un matériau physique approprié à partir des actifs standard ( rebondir avec rebond combiner mis à multiplier ).
Ci-dessous, vous pouvez consulter le script du bal avec des commentaires explicatifs. Le ballon doit atteindre certains objectifs de base : il doit rebondir selon un schéma compliqué, en maintenant toujours le mouvement sur les deux axes, et il doit accélérer à un rythme difficile mais pas impossible dans la direction horizontale.
Ensuite, nous devons scripter notre pagaie, que vous pouvez voir ci-dessous. La palette doit se déplacer de haut en bas en réponse aux pressions sur les touches (mais pas en dehors de certaines limites). Il doit également déclencher le système de particules lorsqu'il entre en collision avec quelque chose.
Ensuite, nous avons besoin de l'IA ennemie : quelque chose qui fera que la raquette de l'ennemi se dirigera vers la balle à une vitesse fixe. Pour cela, nous utiliserons Vector3.Slerp pour un maximum de simplicité. Nous aimerions également le même comportement de particules que nous voyons sur notre propre pagaie.
EnemyAI.cs
Enfin, nous avons besoin d'un script pour mettre à jour le tableau de bord et réinitialiser la balle lorsqu'elle sort des limites.
Avec ces scripts attachés et les références remplies, lorsque nous exécutons notre jeu de Pong, nous expérimentons le gameplay !
Vous pouvez télécharger ma démo Pong , si vous souhaitez voir tout ce que j'ai décrit en action. Il fonctionne sur les systèmes Windows, Mac et Linux.
8. Explorer la documentation / En savoir plus
Unity est un moteur complexe avec beaucoup plus de fonctionnalités que ce qui pourrait être couvert dans un guide de ce style, et c'est avant d'inclure le large éventail d'extensions Unity (gratuites et commerciales) disponibles sur Internet. Ce guide vous donnera un point de départ solide pour développer un jeu, mais l'auto-éducation est une compétence importante dans toute entreprise, et doublement ici.
Une ressource cruciale ici est la Unity ScriptRéférence . Le ScriptReference est une base de données consultable, disponible pour C# et Javascript, qui contient une liste de chaque commande et fonctionnalité Unity, avec des descriptions de leurs fonctions et de brefs exemples de syntaxe.
Si vous rencontrez des problèmes avec l'éditeur et l'interface de Unity, ou si vous aimez simplement les didacticiels vidéo, il existe une longue liste de logiciels de haute qualité. Tutoriels vidéo Unity disponible. Plus étendu (mais moins large) tutoriels de texte pour Unity sont également disponibles auprès de CatLikeCoding.
Enfin, si vous avez des questions dépassant le cadre de la documentation ou des tutoriels, vous pouvez poser des questions spécifiques à réponses.Unity3d.com . N'oubliez pas que les réponses sont fournies par des bénévoles, alors respectez leur temps et recherchez d'abord la base de données pour vous assurer que votre question n'a pas déjà été répondue.
9. Construire votre jeu / Compiler en une application autonome
Lorsque vous avez construit quelque chose dont vous êtes fier (ou que vous avez fini de cloner notre exemple de Pong légèrement louche pour vous entraîner), il est temps de déplacer votre jeu de l'éditeur et de le transformer en quelque chose que vous pouvez publier sur Internet et forcer vos amis et votre famille à jouer. Pour ce faire, vous devrez créer une application autonome. La bonne nouvelle est que dans Unity, c'est très, très facile. Il y a cependant quelques hoquets potentiels auxquels vous devrez faire attention.
Pour commencer, sachez que vous ne pouvez construire qu'un projet sans erreur. À cette fin, assurez-vous que la console est ouverte pendant que vous construisez : il y a certaines conditions d'erreur que le jeu ignorera dans l'éditeur, mais annulera toujours une tentative de construction. Cela ne fait que vider les messages d'erreur sur la console, sans résultats visibles à l'écran, ce qui peut être frustrant si vous oubliez de vérifier. Une fois que votre jeu est compilé sans erreur, vous pouvez sélectionner Paramètres de construction sous le Déposer menu, ou appuyez sur Ctrl > Décalage
> B . Cela fera apparaître une boîte de dialogue simple qui vous permettra de créer votre jeu pour plusieurs plates-formes.
Le processus à partir de là est explicite : sélectionnez vos options et appuyez sur construire ; le jeu vous demandera un répertoire d'installation et y placera à la fois l'exécutable et le répertoire de données. Ces deux fichiers peuvent être compressés ensemble et distribués (assurez-vous simplement de ne pas facturer un jeu intégré à la démo Unity, car cela enfreint les conditions d'utilisation).
10. Remarques de clôture
Comme pour tout outil de développement de jeux, la clé du succès avec Unity est le développement itératif. Vous devez construire par incréments gérables - soyez ambitieux, par tous les moyens, mais soyez ambitieux par petits morceaux, et organisez ces morceaux de telle sorte que, même si vous n'atteignez pas votre ambition ultime, vous vous retrouverez au moins avec un produit.
Obtenez les éléments les plus cruciaux en premier : ayez une idée en tête de votre produit minimum viable , la chose la plus simple et la plus rudimentaire que vous puissiez créer tout en ayant l'impression d'avoir accompli quelque chose de valable. Atteignez ce projet minimum viable avant de passer à de plus grandes ambitions.
Ce didacticiel vous donne un bon point de départ, mais la meilleure façon d'apprendre Unity est de créer un jeu. Commencez à créer un jeu, comblez les lacunes de vos connaissances au fur et à mesure qu'elles surviennent, et le flux progressif des connaissances érodera étonnamment rapidement les choses que vous ne connaissez pas.
Si vous avez lu tout cela et que vous êtes un peu dépassé par le codage requis avec Unity, assurez-vous de vérifier comment apprendre le développement de jeux avec Unity Learn et lisez également notre guide sur la façon de créer des jeux vidéo sans aucune programmation.
Unity est un outil puissant, et avec un peu d'exploration, vous pouvez créer des projets impressionnants plus rapidement que vous ne le pensez. Faites-nous savoir ce que vous avez construit dans les commentaires ci-dessous - nous aimerions voir!
Partager Partager Tweeter E-mail 3 façons de vérifier si un e-mail est réel ou fauxSi vous avez reçu un e-mail qui vous semble un peu douteux, il est toujours préférable de vérifier son authenticité. Voici trois façons de savoir si un e-mail est réel.
Lire la suite Rubriques connexes- La programmation
- La programmation
- Forme longue
- Guide détaillé
Écrivain et journaliste basé dans le sud-ouest, Andre est assuré de rester fonctionnel jusqu'à 50 degrés Celsius et est étanche jusqu'à une profondeur de douze pieds.
Plus d'André InfanteAbonnez-vous à notre newsletter
Rejoignez notre newsletter pour des conseils techniques, des critiques, des ebooks gratuits et des offres exclusives !
Cliquez ici pour vous abonner