Cet article a fait l'objet d'une traduction automatique.

Unity

Développer votre premier jeu avec Unity et C# - Partie 2

Adam Tuliper

Téléchargez l'exemple de Code

Bienvenue de nouveau à ma série sur l'unité. Dans le premier article, j'ai couvert certains principes de base de l'unité et l'architecture. Dans cet article, je vais explorer 2D dans l'unité, qui s'appuie sur le support 2D Qu'unité ajoutée dans la version 4.3. Vous pourriez faire 2D dans l'unité avant la 4.3, mais le processus a été très douloureux sans une trousse d'outils tiers. Ce que je veux, c'est à juste faites glisser une image dans ma scène et apparaissent afin de fonctionner comme je m'attends via une interface de glisser-déplacer. Voilà certains de ce que l'unité 4.3 apporte à la table et dans cet article, j'aborderai plusieurs de ses caractéristiques, tout en développant un jeu de jeu de plateforme 2D base pour apprendre certaines notions essentielles de l'unité.

2D dans l'unité

Pour obtenir l'appui 2D dans l'unité, lorsque vous créez un nouveau projet, vous sélectionnez 2D dans la liste déroulante dans la boîte de dialogue Nouveau projet. Lorsque vous faites, du projet par défaut est affectées aux 2D (lus sous Edit | Paramètres de projet | Rédacteur en chef) et toutes les images importées dans votre projet sont introduits comme sprites par opposition à quelques textures. (J'aborderai ceci dans la section suivante.) Aussi, la scène vue par défaut en mode 2D. C'est vraiment juste un bouton d'aide qui vous corrige à deux axes au cours du développement de la scène, mais n'a aucun effet dans votre jeu proprement dit. Vous pouvez cliquer dessus à tout moment pour sauter dans et hors de mode de travail 2D. Un jeu en 2D de l'unité est vraiment toujours un environnement 3D ; votre travail est juste limité aux axes X et Y. Figure 1 et Figure 2 indiquent le mode 2D sélectionnées et non sélectionnées. J'ai l'appareil photo mis en évidence que vous pouvez voir un aperçu de la zone d'affichage de la caméra, mais notez qu'il donne dans l'espace comme une forme de rectangle.

Figure 1 2D Mode sélectionné — caméra a le Focus

Figure 2 2Mode ne pas sélectionnée — caméra a le Focus

La caméra en surbrillance est configurée comme une caméra orthographique, un des deux modes de caméra dans l'unité. Ce type de caméra, qui est couramment utilisé en 2D, n'échelle des objets plus loin que vos yeux le voyait ; autrement dit, il n'y a pas de profondeur de la position de la caméra. L'autre type de caméra est le point de vue, ce qui montre les objets que nos yeux voient eux, avec la profondeur. Il y a diverses raisons à utiliser une caméra type plutôt que de l'autre, mais en général, choisissez perspective si vous avez besoin de profondeur visuelle, sauf si vous voulez faire évoluer vos objets en conséquence. Vous pouvez changer le mode il suffit de sélectionner la caméra et changer le type de projection. Je recommande cela essayer et voir comment votre caméra de Regarde un des changements de zone lorsque vous démarrez le déplacement d'objets plus loin dans l'axe Z. Vous pouvez modifier le mode de comportement par défaut à tout moment, ce qui affecte seulement future importation d'images dans votre projet.

Si vous avez un projet existant dans l'unité ou que vous n'êtes pas sûr si vous avez sélectionné 2D depuis la fenêtre de projet, vous pouvez définir vos paramètres par défaut du projet pour la 2D en allant dans Edit | Paramètres de projet | Rédacteur en chef ; dans le cas contraire, vous devrez définir manuellement le type de texture sur chaque image 2D que vous importez, qui est un peu fastidieux si vous avez beaucoup de l'oeuvre.

Il s'agit de la Sprite

Lorsque 3D est sélectionné comme le mode de comportement par défaut, les images sont reconnus comme type de Texture. Vous ne pouvez pas faire glisser une texture dans votre scène ; une texture doit être appliquée à un objet. De cette façon n'est pas beaucoup de plaisir à créer des jeux 2D. Je veux simplement faire glisser et déposer une image et le faire apparaître dans ma scène. Si votre mode de comportement par défaut est 2D, cependant, les choses deviennent faciles. Lorsque je fais glisser et déposez une image dans l'unité, il est maintenant reconnu comme type Sprite.

Cela permet de glisser et déposer vos oeuvres d'art dans l'unité, puis de faire glisser l'unité et déposez-le dans votre scène de construire votre jeu. Si vous avez des œuvres d'art qui semble petit, plutôt que redimensionnez-la de partout vous pouvez juste diminuer la valeur des Pixels d'unités. C'est une opération très courante dans l'unité pour la 2D ou en 3D et est généralement plus performant que la mise à l'échelle d'objets via la propriété échelle de sa transformation.

Lors de la suppression des objets, vous remarquerez peut-être qu'un objet se retrouve sur le dessus de l'autre. L'unité crée une série de sommets dans les coulisses, même pour les images 2D, donc l'ordre de dessin peut différer sur différentes parties des images. Il est toujours préférable de spécifier explicitement l'ordre de vos images. Vous pouvez le faire par l'intermédiaire de trois méthodes, énumérés dans l'ordre que l'unité dessine vos sprites :

1. Si la propriété de « Tri couche » dans le moteur de rendu de Sprite.
2. Paramétrage de la propriété « Ordre en couche » aussi sur le moteur de rendu de Sprite.
3. Réglage de la valeur Z de la position de la transformation.

La tri couche prend priorité dans l'ensemble, suivi par décret en couche, qui à son tour a la priorité sur la valeur de z de la transformation.

Tri couches dessiner dans l'ordre de définition. Lorsque vous ajoutez d'autres couches (dans Edit | Paramètres de projet | Tags et couches), l'unité s'appuie sur n'importe quel objet qu'il trouve sur le calque par défaut tout d'abord (puis décret reprend de couche et la valeur Z de la position de la transformation), puis fond, puis les plates-formes et ainsi de suite. Donc vous pouvez facilement corriger chevauchement des images en leur attribuant la couche des plates-formes et ce qui donne la vous voulez sur le dessus une ordonnance en couche de 1, donc il est tirés au sort après quoi que ce soit avec l'ordre dans la couche de 0.

Fonctionnalités communes

Figure 3 montre un niveau contenant certaines plates-formes et les images de fond qui ont été construits en dehors en faisant glisser et en supprimant et en définissant les couches tris.

Figure 3 niveau de jeu

Dans sa forme actuelle, il ressemble à un jeu, mais il n'agit pas comme tel. À tout le moins, il a besoin d'un certain nombre de caractéristiques pour être un jeu fonctionnel. J'aborderai plusieurs d'entre eux dans les sections suivantes.

Clavier, souris et mouvement Touch dans l'unité, clavier, souris, accéléromètre et touch sont lus au moyen du système d'entrée. Vous pouvez lire les clics de souris et de mouvement d'entrée ou touch facilement en utilisant un script comme suit sur le lecteur principal (je vais construire sur ce script sous peu.) :

void Update()
{
  // Returns -1 to 1
  var horizontal = Input.GetAxis("Horizontal");
  // Returns true or false. A left-click
  // or a touch event on mobile triggers this.
  var firing = Input.GetButtonDown("Fire1");
}

Si vous cochez Edit | Paramètres de projet | D'entrée, vous pouvez voir les entrées par défaut (l'unité vous donne un tas qui sont là dans chaque nouveau projet) ou définir de nouveaux. Figure 4 montre les valeurs par défaut pour la lecture de mouvement horizontal. Les paramètres de « gauche » et « droite » représentent les flèches gauche et droite mais il faut noter également "que a" et « d » sont utilisés pour le mouvement horizontal. Ceux-ci peuvent mapper aux entrées de la manette. Vous pouvez ajouter de nouveaux ou modifier les valeurs par défaut. Le champ de sensibilité vérifie à quelle vitesse l'unité passera de 0 à 1 ou -1. Lorsque vous appuyez sur la flèche droite, la première image pourrait donner une valeur de.01 et de s'ajuster assez rapidement jusqu'à 1, bien que vous pouvez régler la vitesse pour donner à votre vitesse horizontale instantanée de caractère ou le mouvement. Je vais vous montrer le code peu de temps pour appliquer ces valeurs à vos objets du jeu. Il n'y a aucun élément GameObject proprement dit, requis pour la lecture de ces valeurs ; vous utilisez simplement le mot-clé de l'entrée dans votre code pour accéder à la fonctionnalité pour l'entrée de la lecture. Entrée, en règle générale, doit être lu dans la fonction de mise à jour par opposition à FixedUpdate pour éviter le manque d'événements d'entrée.

Figure 4 horizontale d'entrée par défaut

Mouvement linéaire choses doivent pouvoir se déplacer. S'il s'agit d'un jeu de haut en bas, gravité n'est pas généralement importante. Si c'est un jeu de plateforme, la gravité est extrêmement importante. Dans les deux cas, la détection de collision objet est critique. Voici les règles de base. Un Rigidbody2D ou RigidBody (utilisé pour la 3D) composant ajouté à un objet de jeu donnera automatiquement cet élément de masse et de faire comprendre la gravité et de recevoir des forces. Selon Wikipedia, « en physique, un corps rigide est une idéalisation d'un corps solide dont la déformation est négligée. En d'autres termes, la distance entre deux points donnés d'un corps rigide reste constante dans le temps, indépendamment des forces extérieures exercées sur elle. » Le même principe s'applique dans les jeux. Ajout d'un corps rigide vous permet de faire des appels comme ceux de Figure 5.

Figure 5 ajout de mouvement et la vitesse

void FixedUpdate()
{
  // -1 to 1 value for horizontal movement
  float moveHorizontal = Input.GetAxis("Horizontal");
  // A Vector gives you simply a value x,y,z, ex  1,0,0 for
  // max right input, 0,1,0 for max up.
  // Keep the current Y value, which increases 
  // for each interval because of gravity.
  var movement = new Vector3(moveHorizontal * 
    _moveSpeed, rigidbody.velocity.y, 0);
  rigidbody.velocity = movement;
  if (Input.GetButtonDown("Fire1"))
  {
    rigidbody.AddForce(0, _jumpForce, 0);
  }
}

En règle générale, le mouvement linéaire devrait arriver via mise à jour et accéléré le mouvement par l'intermédiaire de FixedUpdate. Si vous êtes débutant, il peut sembler déroutant ce qu'il faut l'utiliser quand et, en fait, le mouvement linéaire travaillera en soit fonction. Mais vous obtiendrez de meilleurs résultats visuels en suivant cette règle.

Détection de collision un objet reçoit sa masse de sa composante RigidBody, mais vous devez également indiquer l'unité comment gérer les collisions avec cet objet. La taille et la forme de votre dessin-modèle ou les modèles n'importe pas ici, bien que l'échelle n'affecte physique sur l'objet lui-même. Ce qui importe, c'est la taille et la forme du composant collisionneur, qui est tout simplement une région définie, autour ou au sein de l'objet que vous voulez l'unité pour détecter un autre objet communiquant avec. C'est ce qui permet des scénarios comme détecter quand vous entrez dans la région d'un zombie ralenti ou rochers qui vont rebondir sur un flanc de montagne sur l'approche.

Il sont diversement en forme de collisionneurs. Un collisionneur pour 2D peut être un cercle, bord, polygone ou une zone. Collisionneurs de boîte sont parfaits pour les objets en forme de carrés ou rectangles, ou lorsque vous souhaitez simplement détecter les collisions dans une zone carrée. Pensez à une plate-forme, vous pouvez vous tenir sur — c'est un bon exemple d'un collisionneur de boîte. Simplement en ajoutant ce composant à votre objet de jeu permet de tirer parti des collisions physiques. Dans Figure 6, j'ai ajouté un collisionneur de cercle et les corps rigides de la nature et un collisionneur de boîte à la plate-forme. Lorsque je clique sur jouer dans l'éditeur, le joueur tombe immédiatement sur la plateforme et s'arrête. Aucun code requis.

Figure 6 Ajouter collisionneurs

Vous pouvez déplacer et redimensionner la région qu'un collisionneur couvre en changeant ses propriétés sur la composante de hadrons. Par défaut, les objets avec collisionneurs ne passent par l'autre (à l'exception des déclencheurs qui j'aborderai ensuite). Les collisions ont besoin de pièces de collider sur les deux objets de jeu et au moins un objet doit avoir un composant RigidBody, sauf si c'est un déclencheur.

Si je veux l'unité d'appeler mon code, lorsque cette instance de collision se produit d'abord, j'ai simplement ajouter le code suivant à un objet de jeu via un composant de script (discuté dans l'article précédent) :

void OnCollisionEnter2D(Collision2D collision)
{
  // If you want to check who you collided with,
  // you should typically use tags, not names.
  if (collision.gameObject.tag == "Platform")
  {
    // Play footsteps or a landing sound.
  }
}

Déclencheurs parfois vous voulez détecter une collision mais ne veux pas n'importe quel physique impliqué. Penser à un scénario comme ramasser le Trésor dans un jeu. Vous ne voulez pas les pièces de monnaie d'être expulsé devant le joueur quand il s'approche ; vous voulez des pièces à être ramassés et pas gêner le mouvement du joueur. Dans ce cas, vous utilisez un collisionneur appelé un déclencheur, qui n'est rien d'autre qu'un collisionneur avec la case à cocher IsTrigger activée. Qui désactive la physique et l'unité seulement appelle votre code lorsque l'objet A (qui contient un collisionneur) relève de la région de l'objet B (qui a aussi un collisionneur). Dans ce cas, la méthode de code est OnTriggerEnter2D au lieu de OnCollisionEnter2D :

void OnTriggerEnter2D(Collider2D collider)
{
  // If the player hits the trigger.
  if (collider.gameObject.tag == "Player")
  {
    // More on game controller shortly.
    GameController.Score++;
    // You don’t do: Destroy(this); because 'this'
    // is a script component on a game object so you use
    // this.gameObject or just gameObject to destroy the object.
    Destroy(gameObject);
  }
}

La chose à retenir est qu'avec les déclencheurs, il n'y a aucune interaction physique, il s'agit simplement d'une notification. Déclencheurs ne nécessitent pas d'un composant Rigidbody sur l'objet du jeu, non plus, car aucun calcul de force n'est en cours.

Une chose qui se déclenche souvent des nouveaux développeurs est le comportement des corps rigides, lorsque vous ajoutez des collisionneurs à eux. Si j'ai un collisionneur de cercle sur mon objet et j'ai mis cet objet sur un plan incliné (comme indiqué par sa forme de hadrons), il commence à rouler, comme Figure 7 montre. Il modélise ce que vous verriez dans le monde physique si une roue a été définie sur un plan incliné. La raison pour laquelle que je n'utilise pas un collisionneur de boîte pour mon personnage est car une boîte a les bords qui peuvent se laisser prendre lors du déplacement sur les bords des autres collisionneurs, ce qui donne une expérience moins lisse. Un collisionneur de cercle, cela rend plus lisse. Toutefois, pour les fois où une rotation sans heurt n'est pas acceptable, vous pouvez utiliser le paramètre Angle fixe sur la composante Rigidbody.

Figure 7 utilisation d'un collisionneur de cercle pour un mouvement doux

Audio pour entendre le son, vous avez besoin d'un composant Audio écouteur, qui existe déjà sur n'importe quelle caméra par défaut. Pour lire un son, simplement ajouter un élément de la Source Audio à un objet de jeu et la valeur de l'élément audio. L'unité prend en charge la plupart des principaux formats audio et doit pouvoir coder plus de clips en MP3. Si vous avez un tas de sources audio avec clips assignés dans l'éditeur de l'unité, n'oubliez pas qu'ils vont tous être chargés au moment de l'exécution. Au lieu de cela, vous pouvez charger l'audio via le code situé dans un dossier de ressources spéciales et détruisez-la lorsque terminé.

Quand j'ai importé audio dans mon projet, je l'ai gardé comme un fichier WAV, ce qui est audio non compressé. L'unité sera ré-encoder votre audio plus long pour l'optimiser, il faut donc toujours utiliser la meilleure qualité audio, que vous avez. Cela est particulièrement vrai pour les fichiers courts comme des effets sonores, dont l'unité ne sera pas coder. J'ai aussi ajouté un composant Source Audio pour mon appareil photo principal, bien que je pouvais avez ajouté à n'importe quel objet en jeu. J'ai ensuite assignés le clip audio aventure à cet élément de la Source Audio et coché boucle, alors bouclez constamment. Et en trois étapes simples, j'ai maintenant une musique de fond lorsque mon jeu se joue.

GUI/Heads-Up display GUI A système peut comprendre beaucoup de choses dans un jeu. Elle peut impliquer le système de menu, la santé et affichage de score, inventaire des armes et plus. En règle générale, un système de GUI est ce que vous voyez sur l'écran qui reste en place, peu importe où la caméra est à la recherche (bien qu'il ne doit pas). La fonctionnalité de l'interface graphique de l'unité subit actuellement une révision complète et le nouveau système uGUI va sortir dans l'unité 4.6. Car qui n'est pas encore sorti, je vais simplement discuter de certaines des fonctionnalités fondamentales ici, mais vérifiez mon blog de Channel 9 pour les détails du nouveau système de GUI à channel9.msdn.com/Blogs/AdamTuliper.

Pour ajouter du texte simple affichage à l'écran (par exemple, score : 0), j'ai cliqué sur l'objet de jeu | Créer d'autres | Texte de GUI. Cette option n'est plus présente dans l'unité 4.6, vous aurez envie de regarder que vidéo sur uGUI je l'ai mentionné. Vous pouvez encore ajouter un composant d'interface graphique texte à l'objet jeu de 4,6 en cliquant sur le bouton Ajouter composant ; il manque juste dans le menu de l'éditeur. Avec le système existant de l'unité GUI (héritage), vous ne voyez pas vos objets GUI dans la vue de la scène, uniquement dans l'affichage du jeu, qui fait de création de la mise en page un peu bizarre. Si vous le souhaitez, vous pouvez utiliser le code pur de mettre en place votre interface graphique, et il existe une classe GUILayout qui vous permet de suivre automatiquement les widgets. Mais je préfère un système GUI où je peux cliquer et faire glisser et travailler avec facilement, c'est pourquoi je trouve uGUI bien supérieure. (Avant uGUI, le chef de file dans ce domaine était un produit de tierce partie assez solid appelé NGUI, qui servait en fait de la base de code initial pour uGUI.)

Pour mettre à jour ce texte d'affichage, la méthode la plus simple consiste à simplement chercher ou attribuer, dans l'éditeur, une référence à l'objet jeu de texte GUI et la traiter comme une étiquette dans .NET et mettre à jour sa propriété text. Cela le rend facile à mettre à jour l'écran texte GUI :

void UpdateScore()
{
  var score = GameObject.Find("Score").GetComponent<GUIText>();
  score.text = "Score: 0";
}

Il s'agit d'un exemple légèrement raccourci. Pour une performance, j'ai eu en réalité cache une référence au composant GUIText de la méthode Start pour n'interroge pas, pour cela, chaque appel de méthode.

Score Tracking suivi des scores est facile. Vous avez simplement une classe qui expose une méthode publique ou propriétés sur lequel définir une partition. Il est fréquent dans les jeux d'avoir un objet appelé un contrôleur de jeu qui agit en tant qu'organisateur du jeu. Le contrôleur de jeu peuvent être responsable du déclenchement des parties enregistrées, chargement, score gardant et plus encore. Dans cet exemple, je peux avoir simplement une classe qui expose une variable de résultat, comme le montre Figure 8. J'attribue ce composant à un objet de jeu vide, n'est disponible lors du chargement de la scène. Lorsque le score est mis à jour, le GUI est à son tour mis à jour. La variable _scoreText est assignée dans l'éditeur de l'unité. Juste déposer n'importe quel objet de jeu GUIText dans ce domaine exposé ou utiliser le widget de recherche où ce composant script expose la variable Score texte dans l'éditeur.

Figure 8 créer la Variable _scoreText

public class GameController : MonoBehaviour
{
  private int _score;
  // Drag a GuiText game object in the editor onto
  // this exposed field in the Editor or search for it upon startup
  // as done in Figure 12.
  [SerializeField]
  private GUIText _scoreText;
  void Start()
  {
    if (_scoreText == null)
    {
      Debug.LogError("Missing the GuiText reference. ");
    }
  }
  public int Score
  {
    get { return _score; }
    set
    {
      _score = value;
        // Update the score on the screen
      _scoreText.text = string.Format("Score: {0}", _score);
    }
  }
}

Je peux ensuite simplement mettre à jour (dans cet exemple) code de déclenchement du champignon comme suit pour incrémenter le score avec chaque micro :

void OnTriggerEnter2D(Collider2D collider)
{
  if (collider.gameObject.tag == "Player")
  {
    GameController.Score++;
    Destroy(gameObject);
  }
}

Animations tout comme avec XAML, les animations sont créées en effectuant diverses actions en images clés. Je pouvais facilement consacrer un article entier juste pour les animations dans l'unité, mais je vais le garder brièvement ici en raison de l'espace. L'unité dispose de deux systèmes d'animation, l'ancien système et le Mecanim plus récent. Le système utilise des fichiers de animation(.ani), tandis que Mecanim utilise les États de contrôler quel fichier animation joue.

Animation en 2D utilise Mecanim par défaut. Pour créer une animation, la méthode la plus simple consiste à glisser-déposer des images dans votre scène et laissez l'unité à créer les animations pour vous. Pour commencer, je fais glisser certains sprites unique dans l'unité et l'unité crée à son tour plusieurs choses pour moi. Tout d'abord, il crée un objet de jeu avec un composant de moteur de rendu de sprite pour dessiner les sprites. Puis il crée un fichier d'animation. Vous pouvez le voir en allant à la fenêtre | Animateur et mettre en valeur votre objet de jeu. L'animateur montre le fichier animation assigné, qui, dans mon cas, contient six images clés parce que j'ai laissé tomber six images dans ma scène. Chaque image clé contrôle un ou plusieurs paramètres sur un composant quelconque ; ici, il modifie la propriété de Sprite de la composante de Sprite Renderer. Les animations sont rien de plus que de simples images montrant à des taux qui rend le œil à percevoir le mouvement.

Ensuite, l'unité crée un composant de l'animateur sur l'objet du jeu, comme le montre Figure 9.

Figure 9 la composante animateur pointant vers un contrôleur

Cette pointe de composant à un ordinateur d'état simple appelée un contrôleur de l'animation. Il s'agit d'un fichier crée de l'unité, qui montre bien l'État par défaut ; en d'autres termes, il est toujours en mode « veille » comme c'est le seul état disponible. Cet état de repos ne fait rien plus que pointer vers mon fichier d'animation. Figure 10 montre les données de l'image clé actuelle sur la ligne du temps.

Figure 10 les données d'Animation inactif

Cela peut sembler beaucoup pour passer juste pour jouer une animation. La puissance des machines d'État, cependant, est que vous pouvez les contrôler en définissant les variables simples. N'oubliez pas, un État ne fait rien plus que pointer vers une animation du fichier (bien qu'en 3D, vous pouvez obtenir fantaisie et faire des choses comme se mêlent animations).

Puis, j'ai pris plus de photos pour faire de l'animation d'une exécution et laissé tomber sur mon objet jeu Yeti. Parce que j'ai déjà une composante de l'animateur sur l'objet de jeu, l'unité juste crée un nouveau fichier d'animation et ajoute un nouvel état appelé « exécuter ». Je peux simplement avec le bouton droit sur le ralenti et créent une transition pour exécuter. Cela crée une flèche entre les États inactifs et exécution. Je peux ensuite ajouter une nouvelle variable appelée « Running », qui est simple à utiliser, vous venez de cliquer sur la flèche entre les États et changer la condition d'utiliser la variable, comme le montre Figure 11.

La figure 11, changeant de ralenti aux États de Run

Lorsque l'exécution devient vraie, l'état inactif animation passe à l'état d'exécution d'animation, qui signifie simplement l'exécution animation file joue. Vous pouvez contrôler ces variables dans le code très facilement. Si vous voulez commencer votre animation exécution en déclenchant l'état d'exécution lorsque l'utilisateur clique sur le bouton de la souris, vous pouvez ajouter le code indiqué dans Figure 12.

Figure 12 modification État avec Code

private Animator _animator;
void Awake()
{
    // Cache a reference to the Animator 
    // component from this game object
    _animator = GetComponent<Animator>();
}
void Update()
{
  if (Input.GetButtonDown("Fire1"))
  {
    // This will cause the animation controller to
    // transition from idle to run states 
    _animator.SetBool("Running", true);
  }
}

Dans mon exemple, j'ai utilisé des sprites unique pour créer une animation. Il est assez commun, cependant, d'utiliser une feuille de sprite — un seul fichier image avec plusieurs images dedans. L'unité prend en charge les feuilles de sprite, il s'agit de dire l'unité comment découper votre sprite et puis laisser tomber ces tranches dans votre scène. Les étapes seuls différentes évoluent Sprite Mode du monophasé à multiples sur les propriétés de sprite et ouvrir l'éditeur de Sprite, qui peut ensuite automatiquement couper le sprite et appliquer les modifications, comme indiqué dans Figure 13. Enfin, vous développez le sprite (il ya une petite flèche sur l'icône de la sprite dans la vue projet), mettre en évidence les sprites qui en résulte et déposez dans votre scène, comme vous le faisiez auparavant.

La figure 13, création d'un Sprite

Animation peut être un sujet compliqué jusqu'à ce que vous apprenez le système. Pour plus d'informations, consultez mon blog channel9 ou l'une des nombreuses ressources fines sur le site d'apprentissage de l'unité.

La fin du niveau lorsque le joueur parvient à la fin du niveau, vous pouvez simplement avoir un collisionneur est défini sur un déclencheur, qui permettre aux joueurs de frapper cette zone. Quand cela arrive, vous avez juste charger un autre niveau ou recharger l'actuel :

void OnTriggerEnter2D(Collider2D collider)
{
  // If the player hits the trigger.
  if (collider.gameObject.tag == "Player")
  {
    // Reload the current level.
    Application.LoadLevel(Application.loadedLevel);
    // Could instead pass in the name of a scene to load:
    // Application.LoadLevel("Level2");
  }
}

L'objet de jeu et ses propriétés respectives sont indiquées en Figure 14. Notez la hauteur du collisionneur est suffisamment élevée pour que le joueur ne peut pas sauter par-dessus elle et aussi que ce collisionneur est défini comme un déclencheur.

Figure 14 le jeu objet et ses propriétés

Jeu dans un jeu 2D simple comme ça, le flux est assez simple. Le joueur commence. La gravité sur le corps rigide permet au joueur de tomber. Il y a un collisionneur du lecteur et sur la plate-forme, afin que le lecteur s'arrête. Clavier/souris / saisie tactile sont lus et déplace le lecteur. Le joueur saute entre les plates-formes en appliquant rigidbody.AddForce rendaient saut et mouvements gauche ou droite en lisant Input.GetAxis­(« horizontale ») et son application à le rigidbody.velocity. Le joueur ramasse des champignons, qui sont des collisionneurs justes définir comme déclencheurs. Lorsque le joueur les touche, ils incrémentent le score et se détruisent. Quand le joueur permet enfin au dernier signe, il y a un collisionneur/déclencheur qui recharge juste le niveau actuel. Un élément de tâche supplémentaire ici serait d'ajouter un grand collider sous la terre pour détecter quand les chutes de joueur hors de la plate-forme et simplement rechargement le niveau puis, aussi bien.

Constructions préfabriquées réutilisation est importante dans le codage, ainsi qu'en conception. Une fois que vous affectez plusieurs composants et personnalisez vos objets du jeu, vous aurez souvent envie les réutiliser dans la même scène ou même plusieurs scènes ou les jeux. Vous pouvez créer une autre instance d'un objet de jeu dans votre scène, mais vous pouvez également créer une instance d'un préfabriqué qui n'existe pas encore dans votre scène. Examiner les plates-formes et leurs collisionneurs. Si vous souhaitez les réutiliser à travers des scènes, Eh bien, actuellement, vous ne pouvez pas. Mais en créant des constructions préfabriquées, vous pouvez. Il suffit de glisser n'importe quel objet de jeu de la hiérarchie dans le dossier du projet et un nouveau fichier est créé avec l'extension .prefab qui inclut les hiérarchies de n'importe quel enfant. Vous pouvez maintenant faire glisser ce fichier dans vos scènes et réutiliser. L'objet original jeu vire au bleu de noter que c'est connectée à un prefab. Mise à jour le fichier de .prefab met à jour toutes les instances dans vos scènes, et vous pouvez aussi pousser des changements d'une scène mis à jour le préfabriqué redescendre dans le fichier .prefab, ainsi.

Cliquez sur le préfabriqué pour afficher les objets du jeu qu'il contient, comme le montre Figure 15. Si vous apportez des modifications ici, toutes les instances de votre scène seront actualisés.

La figure 15, affichage du contenu d'un Prefab

Jaquette en haut

Il y a un certain nombre d'opérations courantes effectuées à travers des jeux. Dans cet article, j'ai couvert les bases d'un jeu de plateforme qui utilise des collisionneurs, corps rigides, animations, maintien de la partition, base GUI texte et lecture des entrées d'utilisateur à employer la force pour déplacer le joueur. Ces blocs de construction peut être réutilisés dans différents types de jeu. Restez branchés pour une discussion de la 3D dans mon prochain article à venir !

Apprentissage supplémentaire

• Voir ce projet construit sur : channel9.msdn.com/events/Build/2014/2-503
• Microsoft Virtual Academy - développement 2D & Jeux 3D avec Unity pour Windows : aka.ms/UnityMVA
• Adamle canal 9 de Blog : aka.ms/AdamChannel9
• Ressources de l'unité : Unity3D.com/learn

 

---

Adam Tuliper est un spécialiste technique senior avec Microsoft vivant en Californie du Sud ensoleillée. Il est un dev de jeu indie, co-admin de l'Orange County unité Meetup et un pluralsight.com auteur. Lui et son épouse sont sur le point d'avoir leur troisième enfant, tellement tendre la main pour lui alors qu'il doit toujours un moment de libre à adamt@microsoft.com ou sur Twitter à twitter.com/AdamTuliper.

Remercie les experts techniques suivants d'avoir relu cet article : Matt Newman (Subscience Studios), Tautvydas Žilys (l'unité)