Programmation d`un jeu avec l`unité: guide débutant

Video: Dark Souls 2 - Guide du débutant

Table des matières

§1. Introduction

§2-versions de l`unité

§3-Installation unité

§4-A Brief Introduction au paradigme orienté objet

§5-Unity Basics

§6-Exemple: éléments de base d`un jeu

§7-script dans l`unité

§8-Exemple: le langage de script Pong

§9-Explorer la documentation / apprentissage Plus

§10-Construire votre jeu / une application Compiler autonome

§11 -? Notes de clôture

1. introduction

Une caractéristique surprenante de l`économie de l`Internet est la montée de jeux vidéos indépendants. Une fois le domaine exclusif de mille hommes, plusieurs millions de dollars des studios triple A, un certain nombre d`ensembles d`outils ont été développés qui apportent des ressources de développement du jeu moderne entre les mains d`individus ou de petites collections ad-hoc de programmeurs et les concepteurs. Ces équipes de développement de jeux indépendants ont fait preuve d`une agilité et la tolérance au risque que, dans de nombreux cas, leur permet de pousser l`innovation gameplay plus rapidement que les gros budget. Un certain nombre de titres indie scandaleusement succès ont créée ces dernières années, y compris Minecraft, Limbo, et Super Meat Boy.

Dans le paysage en évolution rapide du développement du jeu indépendant, l`unité a émergé comme quelque chose d`une norme de facto: son faible coût, facilité d`utilisation et un large jeu de fonctionnalités le rendent idéal pour le développement du jeu rapide. studios Même les grands tels que CCP (développeurs de Eve Online) Utiliser des concepts de jeu rapidement le prototypage. L`unité fournit un « moteur de jeu dans une boîte » - une physique et moteur de rendu avec des crochets pour plusieurs langages de script, adaptables à pratiquement tous les genres de jeux vidéos.Unité - Grands Jeux 3D sur plusieurs plates-formes & navigateursUnité - Grands Jeux 3D sur plusieurs plates-formes & navigateursLire la suite

Alors que l`unité fournit un éditeur visuel pour manipuler l`environnement de jeu, l`unité n`est pas une « programmation zéro créateur de jeu` outil. L`unité exige la capacité de programmer pour produire des résultats, mais vous donne également un outil beaucoup plus souple et plus puissant que tout programme « maker jeu » pourrait peut-être. L`unité ne fera pas le travail pour vous, mais il ne sert à abaisser la barrière à l`entrée de manière substantielle. A partir complètement à partir de zéro avec C ++ et OpenGL, il peut prendre des jours pour arriver au point où il y a effectivement quelque chose rendu à l`écran. En utilisant l`unité, il faut environ dix secondes. L`unité met les éléments de base de la création du jeu dans les mains des programmeurs novices d`une manière rapide et intuitive.

2. Les versions de l`unité

L`unité se décline en deux saveurs de base: la version pro et la version gratuite. Il y a un certain nombre de différences (vous pouvez voir la liste complète ici), mais, grosso modo, la version Pro prend en charge un certain nombre d`améliorations visuelles (comme en temps réel des ombres douces et post-traitement), et un grand nombre de relativement mineur caractéristiques qui sont extrêmement utiles pour les jeux plus complexes. Cela dit, pour la plupart, vous voudrez peut-être des jeux relativement simples à construire, la version gratuite de l`unité est tout à fait adéquate. Nous analyserons les différences clés ci-dessous plus en détail pour les personnes intéressées.

2.1 établissement des prix

La version gratuite de l`unité est, bien sûr, libre. Cependant, il y a quelques limitations: la version gratuite de l`unité ne peut pas être autorisé à toute entreprise ayant un revenu annuel de plus de 100 000 $. Bien que ces organisations sont au-delà de la portée de ce guide, si vous pensez que vous pourriez devenir une telle organisation, il est probablement sage de printemps pour la version Pro.

Video: Planetside 2 tuto FR - Guide du débutant

La version Pro de l`unité est de 75 $ par mois, ou 1500 $ pour une licence permanente et n`a pas de limites sur ce que vous pouvez faire avec les jeux créés avec elle. Il y a aussi un essai gratuit disponible 30 jours, que nous allons utiliser pour ce guide, afin de vous donner un aperçu complet des fonctionnalités disponibles que possible. Une licence d`étudiant d`un an est également disponible par le biais Studica pour 129 $.

2.2 Caractéristiques

Il y a de nombreuses fonctionnalités absentes dans la version gratuite de l`unité. Cependant, les différences les plus importantes sont les suivantes: la version gratuite de l`unité ne dispose pas d`un certain nombre d`options de rendu qui permettent une meilleure apparence, des jeux plus rapidement en cours d`exécution (soutien LOD, post-traitement espace écran, shaders avancés, en temps réel souple ombres et rendu différé). Il manque aussi le système complet d`animation mechanim, et quelques outils AI. En général, pour des projets complexes à grande échelle, ou les projets dont la performance graphique est importante, la version pro est utile. J`utilise la version pro, parce que je développe des jeux de réalité virtuelle pour la Oculus Rift, et le support post-traitement écran l`espace est nécessaire pour interagir correctement avec le casque.Tout ce que vous voulez savoir sur le Oculus Rift Dev-KitTout ce que vous voulez savoir sur le Oculus Rift Dev-KitL`avenir est ici - la Rift Oculus a finalement commencé à expédier. Il est encore trop tôt jours, mais si vous êtes l`un des rares chanceux qui ont soutenu ou pré-commandé le kit de dev, voici une collection de ...Lire la suite

Vous pouvez consulter une version alpha début d`un de mes jeux VR, BeatRunner. Il devrait vous donner une idée de ce que l`unité rend possible.

3. Unity Installation

L`unité est facile à installer. Vous pouvez télécharger le fichier exécutable ici (pour le programme d`installation OSX, cliquez sur le lien qui dit « en développement sur Mac OS X?« ). Laissez-le télécharger, l`exécuter, et suivez les instructions d`installation. Une fois l`installation terminée, une fenêtre intitulée « activer votre licence Unity » apparaît. Cochez la case « activer un essai gratuit de 30 jours de Unity Pro » et cliquez sur « OK « .

Toutes nos félicitations! Vous savez avoir un essai de 30 jours de Unity Pro. Lorsque le procès arrive à expiration, si vous ne voulez pas acheter la version pro, vous pouvez passer à la version gratuite et garder votre contenu existant.

4. Une brève introduction au paradigme orienté objet

Avant de commencer avec l`unité, il est important que nous allons sur les bases un peu. L`unité prend en charge les C # et javascript pour nous de jeu témoin de programmation allons travailler avec C # pour ce tutoriel. Tout d`abord, si vous ne l`avez jamais programmé avant, mettre de côté ce tutoriel et passer quelques jours de travail à C # Microsoft Langue Primer jusqu`à ce que vous vous sentez à l`aise avec la langue pour des tâches simples. Si vous avez programmé avant dans un langage orienté objet comme impératif ou C ou Java, écumer l`amorce et de vous familiariser avec C # diffère des autres langues que vous avez utilisé dans le passé. De toute façon, ne se déroule pas avec le tutoriel jusqu`à ce que vous sentez à l`aise de résoudre des problèmes simples avec C # (par exemple, si je devais vous demander d`écrire un programme qui imprime les cent premiers nombres premiers, vous devriez être en mesure d`écrire ce programme sans Google consultation).Top 10 des professionnels Code échantillon Sites pour les programmeursTop 10 des professionnels Code échantillon Sites pour les programmeursLire la suite

Le concept le plus important de comprendre ici est la paradigme orienté objet (Abrégé en POO). Dans des 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. fonctions spécifiques à l`objet sont appelées méthodes. L`idée est ici modularité: en ayant chaque objet isolé, et en forçant d`autres objets à interagir avec lui par ses méthodes, vous pouvez réduire le nombre d`interactions possibles non intentionnelles - et, par extension, des bugs. Vous pouvez également créer des objets que vous pouvez réutiliser à volonté plus tard sans modification. Dans l`unité, vous allez construire ces objets et de les attacher au jeu des entités (dont le comportement qu`ils vont gouverner).

Les objets sont instanciés des classes: une classe est juste un fichier qui définit la définition de votre objet. Donc, si vous voulez un objet « Mook » qui gère l`IA pour un ennemi dans votre jeu, vous devez écrire une classe « Mook », puis joignez ce fichier à chaque entité ennemie. Lorsque vous exécutez votre jeu, chaque ennemi sera équipé d`une copie de l`objet « Mook.

Fixation d`un nouveau script à un objet ressemble à ceci:

Tout d`abord, sélectionnez l`objet et passez à l`inspecteur. Ensuite, cliquez sur le bouton « Ajouter un composant ».

Aller à « nouveau script », entrez le nom que vous voulez, et cliquez sur « créer et ajouter. »

Maintenant, vous avez un nouveau script, que vous pouvez modifier en double-cliquant dessus!

Un fichier de classe ressemble à ceci:

en utilisant UnityEngine-public classe Mook : MonoBehaviour {privé flotte santé-vide Début () {santé = 100-}vide Mettre à jour(){si (santé gt; 0){// recherche de joueur// si vous rencontrez le joueur sur la route, le tuer// si vous obtenez coup, éliminer une quantité aléatoire de la santé}}}

Brisons cette baisse:

• en utilisant UnityEngine- -Cette ligne indique C # que nous voulons utiliser les bibliothèques de Unity, ce qui nous permet de se connecter au moteur de jeu Unity.
• public class Mook: MonoBehaviour {-Cette ligne a déclaré en fait la classe et son nom ( « Mook ») -
• Santé- flotteur privé -Ceci déclare une variable de classe privée (qui ne peut être changé à l`intérieur de la classe). La variable est donnée une valeur de démarrage ().
• vide Start () {-Ceci déclare une méthode appelée « Démarrer « . Start est une méthode spéciale qui fonctionne qu`une seule fois, quand le jeu se lance au départ.
• Mise à jour void () {-Update est une autre méthode particulière, qui fonctionne sur toutes les images. La plupart de votre logique de jeu sera ici.
• // si vous rencontrez le joueur sur la route, le tuer -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 les bits de code particulier faire. Dans ce cas, ce commentaire est utilisé pour se substituer à un bloc plus compliqué de code qui fait réellement ce commentaire décrit.

En plus de « mise à jour » « Démarrer » et vous pouvez instancier vos propres méthodes avec presque tous les nom. Cependant, les méthodes que vous créez ne fonctionnera que si on les appelle. Déclarons une méthode pour une classe hypothétique appelée myClass qui ajoute deux nombres.

public flotte AddTwoNumbers(flotte une, flotte b){revenir une+b-}

Ceci déclare une méthode publique (accessible à d`autres objets) qui retourne un flotteur, appelé « AddTwoNumbers », qui prend deux flotteurs en entrée (appelé a et b). Il retourne ensuite la somme des deux valeurs que sa sortie.

L`appel de cette méthode à partir de la même classe (par exemple, de mise à jour à l`intérieur) ressemble à ceci:

flotte résultat = AddTwoNumbers(1,2)-

Appel de la méthode d`une autre classe est similaire:

par exemple myClass-flotte résultat = exemple.AddTwoNumbers(1, 2)-

Encore une fois, ce juste crée une instance de notre classe, accède à la méthode appropriée et alimente les chiffres 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 particulières (comme un émetteur de particules) qui ne peut être consulté dans l`ensemble normal de paramètres gameobject, vous pouvez choisir de le traiter comme un autre type d`entité de jeu en utilisant la méthode GetComponent .

La syntaxe de qui ressemble à ceci:

GetComponentlt;ParticleSystemgt;().Jouer()-

Si tout cela est pas familier avec, revenir en arrière et passer par l`amorce C #. Il va vous faire économiser beaucoup de frustration que nous avançons.

5. Principes de base de Unity

Dans cette section, nous allons travailler notre chemin à travers les mécanismes de base du moteur Unity. Le flux de travail dans l`unité va quelque chose comme ceci: créer une entité à jouer un rôle dans le jeu (GameObjects blanc peuvent être utilisés pour des tâches abstraites logiques). Alors, que ce soit écrire ou de trouver un fichier de classe, et l`ajouter à l`entité en tant que script (en utilisant le bouton « ajouter le composant » dans la vue `inspecteur. Ensuite, exécutez, test, débogage, répétez jusqu`à ce qu`il fonctionne et passer à la élément suivant du jeu.

Unité est livré avec un certain nombre d`onglets de vue de base qui peuvent être disposés de diverses manières le goût de l`utilisateur. Les cinq grands sont l`onglet « jeu », l`onglet « scène », l`onglet « inspecteur », l`onglet « projet » et l`onglet « hiérarchie. L`onglet de jeu, lorsque le bouton « play » est enfoncé, affiche une instance en cours d`exécution du jeu que l`utilisateur peut interagir avec et de test. L`onglet « scène » fournit une version statique, modifiable du gameworld. L`onglet « inspecteur » permet à l`utilisateur de modifier des entités individuelles dans le monde du jeu en les sélectionnant dans l`onglet « éditeur ». L`onglet « projet » permet à l`utilisateur de parcourir les fichiers et les modèles de glisser du projet, des matériaux et d`autres ressources dans l`onglet « éditeur » pour les placer dans le monde du jeu. Enfin, l`onglet « hiérarchie » montre tous les objets du monde, vous permettant de trouver les objets éloignés de la scène, et les entités mères à un autre en cliquant et en faisant glisser. Voir le schéma ci-dessous pour les emplacements de toutes ces choses.Commencer à créer des jeux dans No Time avec Unity3D gratuitCommencer à créer des jeux dans No Time avec Unity3D gratuitLire la suite

5.1 Entités Unity

5.1.1 Meshes

Treillis sont la manière la géométrie 3D est représenté dans l`unité. L`utilisateur peut utiliser des objets « primitifs » intégrés de Unity (cubes, sphères, cylindres, etc.), ou l`importation leurs propres modèles 3D à partir d`un logiciel de modélisation comme Blender ou Maya. L`unité prend en charge une variété de formats 3D, y compris Collada (.fbx) et .3ds.Créer beaux modèles 3D organique gratuitement avec Sculptris [de Windows & Mac]Créer beaux modèles 3D organique gratuitement avec Sculptris [de Windows & Mac]Sculptris est un outil de conception 3D par Pixologic, les responsables de l`outil 3D professionnel 699 $ ZBrush. Il vient d`une bonne maison, mais contrairement à son application soeur, Sculptris est entièrement gratuit. Nous avons couvert Sculptris dans ...Lire la suite

Les outils de base pour la manipulation de mailles sont l`échelle, la rotation et les boutons de traduction dans le coin supérieur gauche de l`interface. Ces boutons permettent d`ajouter des icônes de contrôle aux modèles de la vue de l`éditeur, qui peuvent ensuite être utilisés pour les manipuler dans l`espace. Pour modifier les propriétés de texture ou physique d`un objet, sélectionnez-les et utilisez la vue « inspecteur » pour analyser les éléments « matériel » et « » modèle du solide indéformable.

5.1.2 GUI éléments

GUI traditionnelles sprites et le texte peuvent être affichés à l`aide du « GUI texte » et l`GameObjects « GUI Texture » dans l`éditeur. Cependant, d`une manière plus solide et réaliste pour gérer les éléments d`interface est d`utiliser pour placer des éléments HUD le texte 3D et Quad GameObjects (avec des textures transparentes et Shader transparente non éclairée) dans le monde du jeu comme des entités. De l`avis de « hiérarchie », ces éléments de gameplay peuvent être glissés sur la caméra principale pour les rendre les enfants, veiller à ce qu`ils se déplacent et tournent avec l`appareil photo.

éléments graphiques (textes et textures) peuvent avoir leur taille et l`échelle ajustée en utilisant les champs correspondants dans l`onglet inspecteur.

5.1.3 Matériaux

Les matériaux sont des combinaisons de textures et shaders, et peuvent être glissés directement sur des objets de jeu dans l`onglet du projet. Un grand nombre de shaders sont livrés avec Unity Pro, et vous pouvez ajuster la texture attachée à les utiliser l`onglet inspecteur pour un objet qu`ils sont appliqués à.Cinq jeux PC importants Conditions ExpliquéCinq jeux PC importants Conditions ExpliquéSi vous jouez à un jeu sur une console, les détails techniques sont traitées pour vous. Certains joueurs préfèrent, mais les joueurs de PC apprécient souvent le plus grand degré de contrôle qu`ils ont sur l`oeil d`un jeu ...Lire la suite

Pour importer une texture, juste le convertir en un jpg, png ou bmp, et faites-le glisser dans le dossier « actifs dans le répertoire du projet Unity (qui apparaît dans « Mes Documents` par défaut). Au bout de quelques secondes, une barre de chargement apparaît dans l`éditeur. Quand il se termine, vous serez en mesure de trouver l`image comme une texture sous l`onglet « projet ».

5.1.5 Lumières

Les lumières sont GameObjects qui radiance projet 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 regard « plat ».

Les lumières peuvent être positionnés, rotation, et ont plusieurs caractéristiques internes que vous pouvez personnaliser. Le curseur « intensité » contrôle la luminosité de la lumière, et la « gamme » contrôle la rapidité avec laquelle il disparaît. Les lignes directrices de la vue de la scène vous montre la portée maximale de l`éclairage. Jouez avec les paramètres pour obtenir l`effet désiré. Vous pouvez également régler la couleur de la lumière, le motif ( « cookie » affiché à la surface de la lumière est pointé, et quel genre de fusée apparaît à l`écran quand on regarde directement à la lumière. Le cookie peut être utilisé pour simuler la lumière plus réaliste motifs, créer de fausses ombres dramatiques, et simulent des projecteurs.

Les trois principaux types de lumière sont « tache », « point », et « directionnel « . Spots ont une position dans l`espace 3D et projettent la lumière dans une seule direction dans un cône d`angle variable. Ils sont bons pour les lampes de poche, projecteurs, et, en général, vous donner un contrôle plus précis de l`éclairage. Spots peuvent projeter des ombres. feux de Point ont un emplacement dans l`espace 3D, et jettent la lumière de façon uniforme dans toutes les directions. lumières Point ne jettent pas d`ombres. Les lumières directionnelles, enfin, sont utilisés pour simuler la lumière du soleil: ils projettent la lumière dans une direction comme d`infiniment loin. Les lumières directionnelles affectent tous les objets de la scène, et peuvent produire des ombres.

5.1.6 Systèmes de particules

Les systèmes de particules sont le terme pour l`unité GameObjects qui génèrent et contrôlent des centaines ou des milliers de particules simultanément. Les particules sont de petits objets optimisés 2D affichée dans l`espace 3D. Les systèmes de particules utilisent rendu simplifié et la physique, mais peuvent afficher des milliers d`entités en temps réel sans bégayer, ce qui les rend idéal pour la fumée, le feu, la pluie, des étincelles, des effets magiques, et plus encore.

Il y a beaucoup de paramètres que vous pouvez modifier pour obtenir ces effets, et vous pouvez y accéder en fraie un système de particules sous l`éditeur de composants, le choix du système de particules, puis en ouvrant 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 à changer au fil du temps ainsi. Sous l`attribut « collision », si vous activez et définissez l`espace de simulation « monde », vous obtiendrez des particules qui entrent en collision avec des objets dans le monde, qui peuvent être utilisés pour un certain nombre d`effets de particules réalistes, y compris la pluie, le déplacement l`eau et des étincelles.

6. Exemple: éléments de base d`un jeu

Pour ce tutoriel, nous allons faire un jeu simple puanteur. Dans cette section, nous allons passer en revue l`organisation des éléments de base - le tutoriel de script viendra plus tard.Comment faire pour Recréer le jeu classique Pong utilisant ArduinoComment faire pour Recréer le jeu classique Pong utilisant ArduinoPong a été le premier jeu vidéo qui a atteint le marché de masse. Pour la première fois dans l`histoire, le concept de "jeu vidéo" a été amené dans la maison familiale, grâce à l`Atari 2600 -...Lire la suite

Tout d`abord, nous allons briser ce bas le jeu de Pong dans ses composants de base. Tout d`abord, nous avons besoin de deux palettes, et une balle. La balle vole hors écran, donc nous voulons un mécanisme pour le réinitialiser. Nous voulons également le texte pour afficher le score, et, pour le bien de vous montrer tous les éléments de base de l`unité, nous voulons un effet de particules de fantaisie quand vous frappez la balle, et le jeu entier besoin d`être considérablement lit.

Cela se décompose en un objet sphérique (une sphère), un géniteur, deux accessoires de palettes avec des émetteurs de particules attachés, une entité texte 3D, et une lumière spot. Pour ce tutoriel, nous allons utiliser le matériel physic par défaut « rebond « , avec rebond moissonneuse-batteuse réglé sur « multiplier ». Voici ce que la configuration ressemble, en dix captures d`écran:

Tout d`abord, créer un accessoire de cube pour la palette.

Échelle de manière appropriée, dupliquer et mettre une sphère entre les palettes pour le ballon.

Ensuite, créez un objet 3DText et à l`échelle et le positionner correctement, en changeant la « taille de la police » attribut pour obtenir une image moins pixélisée.

Ensuite, créez deux systèmes de particules, choisir les caractéristiques que vous voulez, et les attacher aux palettes.

Ensuite, vous aurez envie de positionner et faire pivoter la caméra afin qu`il encadre correctement la scène. Bien que l`appareil photo 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 les pare-chocs, pour empêcher la balle de rebondir hors de la zone de jeu. dans l`onglet Inspecteur, nous pouvons les rendre invisibles en décochant le « maillage renderer ».

Si vous frappez le jeu, vous pouvez maintenant voir les éléments de base de notre jeu disposés. Ils ne feront rien, mais nous y reviendrons!

Maintenant que nous avons cette configuration, nous allons parler de ce qui est impliqué dans les scripts de ces éléments pour faire un jeu.

7. Scripting dans l`unité

Une fois que vous avez un script attaché à un objet, vous pouvez réviser en double-cliquant dessus dans le « inspecteur « . Cela ouvre MonoDevelop, l`environnement de développement par défaut pour l`unité. En substance, Monodevelop est un éditeur de texte avec des fonctionnalités spécifiquement optimisées vers la programmation. Mots-clés et commentaires sont mis en évidence en bleu et vert, et les valeurs et les chaînes numériques apparaissent en rouge. Si vous avez utilisé de, MonoDevelop Eclipse ou d`autres IDE est très similaire. Vous pouvez « construire » vos scripts à l`intérieur de l`éditeur, pour vérifier les erreurs de syntaxe, comme suit:Les bases de programmation informatique 101 - Variables et types de donnéesLes bases de programmation informatique 101 - Variables et types de donnéesAprès avoir présenté et a parlé un peu de la programmation orientée objet avant et où son homonyme vient, je pensais qu`il est temps de passer par les bases absolues de la programmation d`une manière spécifique non linguistique. Ce...Lire la suite

En général, pour obtenir votre script pour interagir avec l`unité, vous aurez besoin de faire référence à des éléments que l`objet contenant le script possède (vous pouvez voir une liste de ces éléments sous l`onglet « inspecteur » est sélectionné lorsque l`objet concerné). Vous pouvez ensuite appeler des méthodes ou définir des variables pour chacun de ces éléments pour adopter les changements que vous voulez.

Si vous voulez un script sur un objet pour affecter les propriétés d`un objet différent, vous pouvez créer une variable gameobject vide dans votre script, et utiliser l`inspecteur pour l`affecter à un autre objet dans la scène. Les captures d`écran ci-dessous montrent ce qui ressemble.

Une liste des éléments d`un objet peut avoir est la suivante (tirée de la vue de l`inspecteur de l`un de nos palettes dans l`exemple ci-dessus):

• Transformer
• Cube (filtre à mailles)
• boîte Collider
• mesh Renderer

Chacun de ces aspects de l`objet peut être influencée à partir d`un script. Ensuite, nous allons voir comment exactement.

7.1 Transformer

Les fonctions de transformation pour un gameobject dans l`unité de contrôle des paramètres physiques de cet objet: sa taille, sa position et son orientation. Vous pouvez y accéder à partir d`un script comme celui-ci:

transformer.position = newPositionVector3-transformer.rotation = newRotationQuaternion-transformer.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: position et l`échelle sont, comme on pouvait s`y attendre, stocké sous forme Vector3s. Vous pouvez accéder aux x, y et z composantes de chaque (par exemple, transform.position.y vous donne la distance d`un objet au-dessus du plan zéro). Cependant, pour éviter blocage de cardan, les rotations sont traités comme des quaternions (Les vecteurs quatre composants). Parce que escouades-manipulation main est peu intuitive, vous pouvez manipuler des rotations en utilisant des angles eulériens en utilisant la méthode Quaternion.Euler comme ceci:

transformer.rotation = quaternion.Euler(pas, embardée, rouleau)-

Si vous souhaitez déplacer des objets en douceur d`un endroit à l`autre, vous trouverez la méthode Slerp pour escouades et vector3s utiles. Slerp prend trois arguments - l`état actuel, l`état final, et la vitesse du changement, et interpole en douceur entre eux à la vitesse donnée. La syntaxe ressemble à ceci:

transformer.position = Vector3.Slerp(startPositionVector3, newDestinationVector3, 1)-

7.2 renderer

Les fonctions de rendu dans Unity vous permettent de contrôler la façon dont les surfaces des accessoires sont rendus à l`écran. Vous pouvez réattribuer la texture, changer la couleur, et changer le shader et la visibilité de l`objet. La syntaxe ressemble à ceci:

renderer.activée = faux-renderer.Matériel.Couleur = Nouveau Couleur(0, 255, 0)-renderer.Matériel.mainTexture = myTexture-renderer.Matériel.shaders = newShader-

La plupart d`entre eux ont des fonctions assez claires. Le premier exemple fait l`objet en question invisible: une astuce utile dans un certain nombre de situations. Le deuxième exemple attribue une nouvelle couleur RVB (à savoir, vert) à l`objet en question. La troisième attribue la principale texture diffuse à une nouvelle variable de texture. Le dernier exemple change le shader du matériau de l`objet à une variable de shaders nouvellement défini.

7.3 La physique

L`unité est livré avec un système intégré moteur physique qui vous permet d`affecter les propriétés physiques des objets et laisser les détails de leur simulation être manipulés pour vous. En général, plutôt que d`essayer de mettre en œuvre votre propre physique en utilisant un manuel et la transformation du système, il est plus simple et plus robuste à utiliser le moteur physique de l`unité dans la mesure du possible.Smash, lecteur & Ancienneté: 3 Physique Impressionnant Simulateurs Jeux de sableSmash, lecteur & Ancienneté: 3 Physique Impressionnant Simulateurs Jeux de sableLire la suite

Tous les accessoires de physique ont besoin collisionneurs. Cependant, la simulation proprement dite est assurée par un modèle du solide indéformable, qui peut être ajouté dans la vue inspecteur. Rigidbodies peut être cinématique ou nonkinematic. accessoires de physique entrent en collision avec Cinématique (et l`effet) des accessoires de physique nonkinematic autour d`eux, mais ne sont pas affectés par la collision eux-mêmes. accessoires cinématiques statiques sont les objets immobiles proverbiales, et les objets en mouvement cinématique sont la force irrésistible proverbial (pour mémoire, quand ils entrent en collision, ils passent simplement les uns des autres). Au-delà, vous pouvez régler la traînée angulaire de l`objet (la quantité d`énergie qu`il faut pour la faire tourner), changer sa masse, dicter si oui ou non elle est affectée par la gravité, et appliquer des forces à lui.

Exemples:

corps rigide.drag angulaire = 0.1f-corps rigide.Masse = 100-corps rigide.isKinematic = faux-corps rigide.useGravity = vrai-corps rigide.AddForce(transformer.vers l`avant * 100)-

Ceux-ci sont assez explicites. La seule chose à noter ici est l`utilisation de « transform.forward « . tous de Vector3 ont trois composantes (.forward, .up et .RIGHT) qui leur sont associés, accessible et tourne avec eux ( « en avant » est le sens de la flèche bleue dans l`éditeur). « Transform.forward » est tout simplement le vecteur vers l`avant pour l`objet courant avec une amplitude 1. Il peut être multiplié par un flotteur pour créer plus de force sur l`objet. Vous pouvez également faire référence à « transform.up » et « transform.right » et les nier pour obtenir leurs revers.

7.4 Collision

Souvent, lors de la construction d`un jeu, vous souhaitez une collision pour entraîner un changement d`état dans votre code, au-delà de la simulation de la physique. Pour cela, vous aurez besoin d`une méthode de détection de collision.

Il y a une certaine quantité de travail de préparation nécessaire pour détecter les collisions dans l`unité. Tout d`abord, au moins l`un des objets de la collision a besoin d`un modèle du solide indéformable non cinématique qui s`y rattachent. Les deux objets doivent avoir collisionneurs corrects, définis comme non déclencheurs. La vitesse totale des deux objets doit être suffisamment faible qu`ils entrent en collision en fait, au lieu de sauter simplement par un autre.

Si vous avez tout ce pris en charge, 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 que vous souhaitez vérifier la collision avec. La méthode ressemblera à ceci:

vide OnCollisionEnter(collision autre){// faire des choses ici}

Cette méthode se déroulera automatiquement lors de la première image qu`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, faire référence à son « gameobject, » « modèle du solide indéformable, » et « transformer les caractéristiques » de manipuler de différentes manières. Alors que « OnCollisionEnter » est probablement la fonction la plus commune que vous allez utiliser, vous pouvez également utiliser « OnCollisionExit » et « OnCollisionStay » (avec la syntaxe autrement identique et l`utilisation), qui activent au cours de la première image que vous arrêtez entrer en collision avec un objet et pendant chaque image que vous êtes entré en collision avec un objet, respectivement.

Parfois, il peut aussi être utile de faire ce qu`on appelle raycasting. En raycasting, une ligne infiniment mince (un « rayon») est jeté à travers le monde d`une certaine origine, le long de certains vecteur, et, quand il frappe quelque chose, la position et d`autres détails de la première collision sont retournés. Le code pour une raycast ressemble à ceci:

coup RaycastHit-si (La physique.raycast(transformer.position, -Vector3.en haut, en dehors frappé)){flotte distanceToGround = frappé.distance-}

Cela jette un rayon de la position de l`objet courant le long -Vector3.up (vers le bas), et relie la variable « hit » au premier objet, il entre en collision avec. Une fois que votre rayon a frappé quelque chose, vous pouvez accéder hit.distance pour déterminer quelle distance il est, ou hit.GameObject pour manipuler l`objet que vous touchez.

Raycasts comme celui-ci peuvent être utilisés pour les tireurs pour déterminer ce qui a souligné chez le pistolet, ou pour sélectionner des objets lorsque la caméra regarde, ou pour certains styles de mécanicien de mouvement.

7.5 correction du temps

Un facteur important de garder à l`esprit lorsque vous manipulez des objets de cette façon doit faire avec framerate. Peu importe avec quel soin vous optimisez, framerate toujours varier, et vous ne voulez pas que votre vitesse de jeu pour varier en conséquence. Si quelqu`un va bien votre jeu sur un ordinateur plus rapide que vous l`avez développé, vous ne voulez pas le jeu de fonctionner à double vitesse.

La façon dont vous corriger c`est en multipliant les valeurs que vous utilisez le temps qu`il a fallu pour rendre la dernière image. Cela se fait à l`aide « Time.deltaTime. Cela change effectivement la vitesse d`une variable que vous incrémenter chaque image de « changement par image » à « changement par seconde, » et vous devriez probablement faire ce changement à une valeur que vous êtes incrémenter ou décrémenter chaque image.

7.6 Sources audio et auditeurs

Maintenant que nous avons couvert comment créer, rendre, et les objets de contrôle, nous allons parler de l`autre sens que les jeux informatiques peuvent servir: à savoir, son. L`unité prend en charge les deux types de sons: sons 2D et 3D. sons 3D varient leur volume en fonction de la distance, et déforment comme ils se déplacent par rapport aux sons caméra- 2D ne le font pas. sons 2D sont appropriés pour voix off et musique de fond, et des sons 3D appliquer aux sons générés par les événements dans le monde. Pour changer si oui ou non un son est en 3D, sélectionnez dans la vue « projet », passer à la vue « inspecteur » et sélectionnez l`option appropriée dans le menu déroulant, puis appuyez sur le bouton « réimportation ».

Pour jouer effectivement le son, vous devrez joindre un « audiosource » à un accessoire (l`accessoire que vous voulez que le son provient de, dans le cas d`un son 3D. Ensuite, vous aurez besoin d`ouvrir le « AudioClip `champ et sélectionnez votre fichier son.

Vous pouvez utiliser pour contrôler les fichiers sonores myAudioSource.Pause () et myAudioSource.Play (). Vous pouvez régler les comportements de Falloff, le volume et le déplacement doppler des sons sous l`onglet « inspecteur » pour le audiosource.

7.7 Contribution

Un jeu qui ne prend pas d`entrée de l`utilisateur est pas grand-chose d`un jeu. Il y a beaucoup de différents types d`entrée que vous pouvez lire dans, et presque tous sont accessibles par les objets d`entrée et KEYCODE. Certaines déclarations d`entrée de l`échantillon (qui ont une valeurs évaluées chaque image) sont ci-dessous.

Vector3 MousePos = Contribution.MousePosition-bool isLeftClicking = Contribution.GetMouseButton(0)-bool isPressingSpace = Contribution.GetKey(Code clé.Espace)-

Les fonctions de ces lignes est surtout explicite. L`utilisation de ces trois types de référence d`entrée, vous pouvez reconstruire les systèmes de contrôle de la plupart des jeux modernes d`ordinateur 3D.

7.8 Déboguer un script

Disons qu`un script ne fonctionne pas. Comme le bon docteur dit, bangups et déconnexions peut vous arriver. S`il y a des erreurs de syntaxe pure et simple avec votre C #, le jeu sera généralement refuser d`exécuter lorsque vous appuyez sur le jeu, et certains messages d`erreur assez utiles sont fournis si vous « construire » les scripts à partir de l`éditeur. Voir ci-dessous:

Ces insectes ne sont généralement pas les plus difficiles à corriger. Ce qui peut être plus problématique des erreurs sémantiques subtiles, dans lequel vous avez écrit avec succès un dossier complet de C # valide - tout simplement pas celui qui fait ce que vous pensé que ce serait. Si vous avez une de ces erreurs, et vous l`avoir suivi des problèmes vers le bas, il y a quelques choses que vous pouvez essayer d`améliorer la situation.

La première consiste à mettre en pause l`exécution du jeu, et vérifier la console. Vous pouvez mettre en pause le jeu en cliquant sur l`icône « pause » dans la partie médiane supérieure de l`éditeur, puis en sélectionnant « console » à partir du bas du menu « fenêtre » (ou en appuyant sur Ctrl-Shift-C). Même s`il n`y a pas d`erreurs, les avertissements peuvent aider encore à donner quelques indices quant à ce qui pourrait aller mal.

Si cela ne fonctionne pas, vous pouvez aussi essayer d`avoir une idée sur l`état de votre script en imprimant l`état des variables internes pour valider que le programme est en train de faire ce que vous pensez qu`il fait. Vous pouvez utiliser debug.log (String) - pour imprimer le contenu d`une chaîne à la console lors de l`exécution du programme frappe cette ligne. En général, si vous travaillez en arrière de ce que vous pensez devrait se passer à travers les choses qui devraient faire y arriver, vous finirez par atteindre un point où vos impressions de débogage ne font pas ce que vous attendez d`eux. C`est là votre erreur.

8. Exemple: Scripting Pong

Pour construire Pong, nous allons briser le jeu en ses éléments essentiels: nous avons besoin d`une balle qui ricoche et-vient entre les palettes à une vitesse de plus en plus, nous avons besoin d`un tableau de bord qui sait quand les balles ont passé les palettes, et nous avons besoin d`un mécanisme pour redémarrer le ballon quand cela se produit. Une première étape serait d`ajouter un modèle du solide indéformable non cinématique à la balle, deux rigidbodies cinématiques aux palettes, désactivez la gravité pour tous, et affecter un matériau physic approprié des actifs standards ( « rebond » par « rebond combiner » mis à « se multiplient).

Ci-dessous, vous pouvez voir le script pour la balle avec des commentaires explicatifs. La balle doit atteindre des objectifs de base: il devrait rebondir dans un schéma complexe, en maintenant toujours le mouvement sur les deux axes, et il devrait accélérer à un rythme difficile, mais pas impossible dans le sens horizontal.

BallHandler.cs

Ensuite, il faut créer un script de notre palette, que vous pouvez, à nouveau, voir ci-dessous. La palette doit monter et descendre en réponse aux pressions sur les touches (mais pas à l`extérieur de certaines limites). Il doit également déclencher le système de particules quand il entre en collision avec quelque chose.

PaddleHandler.cs

Ensuite, il faut l`IA ennemie: quelque chose qui provoquera la palette de l`ennemi pour suivre vers la balle à un taux fixe. Pour cela, nous allons utiliser Vector3.Slerp pour un maximum de simplicité. Nous aimerions également le même comportement des 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 le ballon quand il sort des limites.

ScoreboardUpdater.cs

Avec ces scripts joints et les références remplis, quand nous courons notre jeu de Pong, nous faisons l`expérience de jeu!

Video: Guide pour bien débuter en programmation : Langage C - EP.1

Vous pouvez télécharger ma démo Pong, si vous voulez voir tout ce que je l`ai souligné dans l`action. Il fonctionne sur Windows, Mac et Linux.

9. Exploration de la documentation / apprentissage Plus

L`unité est un moteur complexe avec beaucoup plus de fonctionnalités que pourrait réalistement être couverts dans un guide de ce style, et qui est avant d`inclure la large bande de (libre et commercial) extensions de Unity disponibles sur Internet. Ce guide vous donnera un solide point de départ pour le développement d`un jeu, mais l`auto-éducation est une compétence importante dans toute entreprise, et doublement ici.

Une ressource cruciale est ici l`unité ScriptReference. Le ScriptReference est une base de données, disponible pour C # et javascript, qui a une liste de chaque commande l`unité et fonctionnalité, avec description de leurs fonctions et de brefs exemples de syntaxe.

Si vous rencontrez des problèmes avec l`éditeur et de l`interface de l`unité, ou tout simplement comme des tutoriels vidéo comme une question de préférence, il y a une longue liste de tutoriels vidéo Unity haute qualité disponibles. Plus vastes tutoriels de texte (mais moins larges) pour l`unité sont également disponibles à partir CatLikeCoding.

Enfin, si vous avez des questions au-delà de la portée de la documentation ou des tutoriels, vous pouvez poser des questions spécifiques à answers.Unity3d.com. Rappelez-vous que les réponses sont fournies par des bénévoles, afin de respecter leur temps et recherche la base de données pour vous assurer que votre question n`a pas déjà répondu.

dix. Construire votre jeu / une application Compiler autonome

Lorsque vous avez construit quelque chose que vous êtes fier (ou que vous avez terminé le clonage de notre exemple un peu louches Pong pour la pratique), il est temps de passer votre jeu de l`éditeur et la transformer en quelque chose que vous pouvez poster sur l`Internet et la force vos amis et votre famille à jouer. Pour ce faire, vous aurez besoin de construire une application autonome. Les bonnes nouvelles sont que dans l`unité, ce qui est très, très facile. Il y a, cependant, quelques hoquets potentiels que vous aurez envie de faire attention.

Pour commencer, sachez que vous ne pouvez construire un projet sans erreur. À cette fin, assurez-vous que la console ouverte que vous construisez: il y a des conditions d`erreur que le jeu ignorera dans l`éditeur, mais toujours interrompre une tentative de construction. Cela ne dépotoirs 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 vous avez votre jeu compilation sans erreur, cependant, vous pouvez sélectionner le menu « paramètres de construction sous le « Fichier », ou appuyez sur Ctrl-Shift-B. Cela affichera une boîte de dialogue simple qui vous permet de construire votre jeu pour plusieurs plates-formes.

Le processus de là est explicite: sélectionnez vos options, et appuyez sur « Build » le jeu vous demandera un répertoire d`installation, et placera aussi bien l`exécutable et le répertoire de données là-bas. Ces deux fichiers peuvent être compressés ensemble et distribués (assurez-vous que vous ne se charge pas pour un jeu construit dans la démo unité, car cela viole les conditions de service).

11. Remarques de clôture

Comme tout outil de développement de jeux, la clé du succès avec l`unité est le développement itératif. Vous devez construire par incréments gérable - être ambitieux, par tous les moyens, mais être ambitieux en petits morceaux, et arranger les morceaux de sorte que, même si vous tombez à court de votre ambition ultime, vous aurez au moins le vent avec un produit cohérent . Obtenez les éléments les plus cruciaux en premier: avoir une idée à l`esprit de votre « produit minimum viable, la plus simple, chose la plus rudimentaire que vous pourriez créer et se sentir comme si vous avez accompli quelque chose d`utile. Apprenez à ce projet viable minimum avant de passer aux plus grandes ambitions.

Ce tutoriel vous donne un solide point de départ, mais la meilleure façon d`apprendre l`unité est tout en construisant un jeu. Commencez à construire un jeu, combler les lacunes dans vos connaissances comme ils viennent, et l`écoulement progressif de la connaissance va éroder les choses que vous ne savez pas éto