Construire le jeu dans l'unité 2048 via C # et Visual Studio - Dimitris Ilias Gkanatsios
Comme toujours, vous pouvez trouver le code source ici sur GitHub et tester le jeu ici via WebGL.
Capture d'écran montrant le jeu dans l'éditeur Unity. Sur la gauche, nous pouvons voir la partition et un bouton de remise en marche, au milieu du principal écran de jeu et à droite une visualisation de 2 dimensions contenu du tableau du jeu, à des fins de débogage.
Méthodes d'entrée
Nous avons mis en place deux méthodes pour obtenir l'entrée d'utilisateur dans le jeu. Le premier est via les touches fléchées du clavier, l'autre en balayant l'écran dans un écran tactile (ou la souris). Nous avons mis en place une énumération pour obtenir l'entrée de l'utilisateur et une interface qui doit être mis en œuvre par chaque méthode d'entrée que nous voulons utiliser. De plus, si nous devons ajouter une autre méthode d'entrée à l'avenir, par exemple entrée d'un contrôleur XBOX, nous pourrions simplement implémenter l'interface IInputDetector.
Procédé détecte si une touche de direction est enfoncée et retourne la direction respective. Gardez à l'esprit que nous utilisons la méthode GetKeyUp que nous ne voulons pas avoir plusieurs entrées par flèche appuyer sur la touche.
La méthode pour obtenir la direction balayant l'écran est plus compliquée. Voyons voir le code dans les parties:
Nous avons une simple énumération de tenir l'état du coup. At-il été démarré ou non?
Nous utilisons certains champs pour nous aider à la mise en œuvre. La durée de balayage maximale est de 1 seconde et le minimum est de 100 millisecondes.
Si l'utilisateur touche (ou clique avec la souris) l'écran, nous commençons le processus de balayage.
Lorsque l'utilisateur se termine la trainée, nous vérifions si la durée os la traînée est dans les délais souhaités. Si tel est le cas, nous devons trouver l'angle du swipe via la méthode Vector2.Angle. Nous utilisons également la méthode Vector3.Cross (calcule le produit vectoriel) pour déterminer la direction du differenceVector.
classe contient des variables statiques Globals sur les lignes, les colonnes et AnimationDuration.
ItemMovementDetails
La classe ItemMovementDetails est utilisé pour transporter des détails sur un objet qui est sur le point d'être déplacé et / ou en double. Les propriétés NewRow / newColumn contiennent les informations de l'emplacement de l'élément du tableau, tandis que les propriétés GOToAnimateScale et GOToAnimatePosition contiennent des informations sur les objets du jeu qui sont sur le point d'être déplacé et / ou mis à l'échelle sur. Le processus normal consiste à déplacer un élément (changer sa position), mais si cet objet va fusionner avec un autre, cela aura également son ampleur a changé (et disparaître). Plus sur le sujet que peu de temps!
La classe d'objet est simple.
- La propriété Value contient la valeur de l'élément (par exemple 2,4,8,16, etc.)
- les propriétés de ligne et de colonne contiennent les valeurs de rangée et de colonne respectives de la matrice que cet élément à belonds
- La propriété GO contient une référence à l'unité gameobject cet article se réfère à
- La valeur WasJustDuplicated contient des informations si cet élément a été reproduit dans ce mouvement / swipe.
Cette méthode récupère un élément non nul dans la matrice. Il est utilisé pour créer un nouvel élément après chaque coup.
Cette méthode est appelée après chaque coup et définit toutes les valeurs WasJustDuplicated à false.
Cette méthode vérifie si deux articles passés comme arguments (via leur colonne / indexation de rangée) ont la même valeur. Tout d'abord, il vérifie si les indices sont passés en dehors des limites. Ensuite, il vérifie si l'élément dans cette position de tableau n'est pas nulle et si elle était non seulement dupliqué (à savoir qu'il n'a pas été reproduit après le coup en cours). Si toutes ces vérifications sont vraies,
- nous reproduisons la première valeur de l'élément et définissez le champ WasJustDuplicated true
- nous enlevons le deuxième élément du tableau après que nous gardons une référence à elle, afin d'animer
- nous revenons une nouvelle instance de classe ItemMovementDetails, portant l'information de l'élément à sa position animée et l'élément à avoir son échelle animée (et à la fin, disparaître).
En ce qui concerne le mouvement des éléments selon le swipe de l'utilisateur, nous avons différents scénarios que nous devons couvrir. Rappelez-vous que les éléments nuls dans le tableau représentent des espaces vides.
c) 2 | 2 | X | 2 => 4 | 2 | X | X. Les deux premiers « 2 » ont fusionné, et le troisième se déplacera à la deuxième colonne
d) X | 2 | 2 | 2 => 4 | 2 | X | X. Même situation que l'option précédente. Les deux premières « 2 » sont fusionnés, déplacés vers la première colonne et la troisième « 2 » est déplacé vers la deuxième colonne.
Cette méthode déplace l'élément à l'endroit où il est censé aller (basé sur des contrôles de valeur). Il attribue l'élément à sa nouvelle position et « l'ancien » annule un. En outre, il vérifie si l'élément à côté de lui a la même valeur. Si tel est le cas, nous revenons ces informations alors que si elles sont différentes, nous revenons juste détails de l'élément qui a été déplacé.
Ici, nous commençons notre boucle. Bien sûr, nous allons vérifier toutes les lignes. Ensuite, nous boucle à travers toutes les colonnes, en prenant les index de la liste des columnNumbers. En parcourant chaque ligne, nous vérifions d'abord chaque élément pour nul. Si elle est nulle, nous continuons de vérifier l'élément suivant (en cochant la colonne suivante -. Moyens suivants, soit -1 ou 1, selon le swipe Quand on arrive à une colonne non nulle, nous vérifions si cette colonne est le même que le un à côté. Encore une fois, « à côté de » signifie soit -1 ou 1, selon que le glissement est à gauche ou à droite. Si ces éléments sont les mêmes, nous ajoutons cette information à la liste des movementDetails et continuer la boucle dans la colonne suivante.
Si ces éléments ne sont pas les mêmes, alors nous devons déplacer l'élément que nous référençons actuellement dans la position puis la première nulle. Pour un mouvement vers la gauche, si l'élément est [ligne, colonne], alors les seules positions possibles sont de [ligne, 0] à [ligne, colonne-1], nous aurions donc besoin des premiers éléments de la colonne de la liste des columnNumbers. Pour un coup droit, les seules positions possibles sont de [rang, Globals.Columns-1] à [ligne, colonne + 1], donc nous avons besoin les premiers Globals.Columns - éléments de la colonne de la liste des columnNumbers inversée. Nous effectuons une boucle dans ces colonnes (en utilisant la méthode LINQ Take) en gardant une référence à chaque numéro de colonne (via la variable columnFirstNullItem) et vérifier chaque élément si elle est nulle. Si nous trouvons un, nous sortir de la boucle.
Si nous ne trouvons pas un élément null, l'élément actuellement référencé est dans sa position correcte, donc nous le laisser tel quel. Si nous le faisons, nous déplaçons l'élément actuellement référencé à la position nulle et nous créons une instance de la classe ItemMovementDetails, afin de transporter des informations d'animation. A la fin de la méthode MoveHorizontal, on retourne la liste movementDetails, qui contient des informations pour toutes les animations qui doivent être effectuées.
classe Utilities contient deux méthodes statiques, utiles pour le débogage. Nous allons leur rendre visite
Ainsi, la colonne augmente à droite et la ligne sur le fond. Cela est différent de la direction l'unité, de sorte que nous inverser la boucle de lignes à être visuellement précis.
Cette méthode est similaire à celui que j'utilisé quand j'ai développé le mécanisme de jeu de match-3. Il charge un fichier appelé « debugLevel » dans le dossier Ressources. Le dossier contient des nombres entiers (qui représentent les valeurs des éléments) et X (qui représentent les valeurs nulles). Nous utilisons le tuyau ( « | » |) caractère comme séparateur. Méthode retourne un tableau de chaînes à deux dimensions qui contient le contenu du fichier.
GameManager
Cette méthode est utilisée pour créer le tableau via les informations obtenues par le GetMatrixFromResourcesData qui a été précédemment décrit.
La méthode Initialize est appelée soit lorsque le jeu commence ou alors le joueur touche le bouton de redémarrage. Tout d'abord, il détruit tous les éléments existants dans le jeu. Ensuite, il initialise le tableau, crée deux nouveaux éléments et les variables score initialise et gameState.
La méthode de CreateNewItem est utilisé pour créer un nouvel élément sur le tableau. Il est utilisé soit au début du jeu ou après le coup de chaque utilisateur. Comme vous pouvez le voir, il a des arguments optionnels. Ceux-ci permettent à l'appelant d'invoquer la méthode de différentes manières, selon la fonctionnalité souhaitée de la fonction.
Si les arguments de ligne et de colonne sont nuls, cela signifie que nous voulons placer l'élément dans une position aléatoire. Si elles ne sont pas nulles, cela signifie que nous déboguent le niveau via le fichier premade dans le dossier Ressources. peuplements même pour l'argument de valeur, à l'exception du fait que cela soit une valeur du niveau premade ou la valeur 2 (valeur par défaut pour les nouveaux éléments).
La méthode crée une nouvelle instance de la classe d'objet, attribue les champs qui lui sont propres, instancie une nouvelle gameobject en fonction de la valeur de l'article et anime son échelle via l'excellente bibliothèque animation GoKit / entrepont. En fin de compte, il affecte la nouvelle instance de l'élément à son emplacement approprié dans le tableau de l'article.
La méthode InitialPositionBackgroundSprites crée un nouveau sprite d'arrière-plan pour toutes les positions du tableau.
Dans la méthode de mise à jour, nous vérifions si l'utilisateur nous a donné une entrée. Si tel est le cas, nous effectuons le swipe liés et recueillir la liste des movementDetails, contenant des animations potentielles qui doivent être effectuées. Si cette liste a au moins un élément, puis nous cal la méthode Items Animer.
Les AnimateItems commence par une boucle dans la liste des movementDetails. Ensuite, il anime chaque élément à sa nouvelle position dans l'espace mondial.
Si l'élément en cours dans la liste movementDetails a une valeur non nulle dans le domaine GOToAnimateScale, cela signifie que l'objet sera déplacé puis disparaître. Ainsi, la méthode met à jour la partition et vérifie la nouvelle valeur en double. Est-ce est égal à 2048, cela signifie que le jeu est terminé. Dans le cas contraire, nous créons l'élément dupliquée, faire petit et l'affecter à la bonne position dans le tableau.
L'élément qui sera fusionné et dupliquée a) de déplacer et b) disparaissent. Pour ce faire, nous avons besoin de deux animations se passer dans la chaîne, une animation de mouvement et une animation à grande échelle. Nous créons un nouvel objet GoTweenChain qui nous permet d'effectuer ces deux animations. Nous commençons cette animation et on ajoute les deux GameObjects qui ont été fusionnées au objectsToDestroyList. Nous CreateNewItem alors. appeler WaitForSeconds tenir sur l'exécution jusqu'à ce que toutes les animations ont arrêté et ensuite en boucle dans la liste des objectsToDestroy pour détruire tous les GameObjects inutiles. La raison pour laquelle nous utilisons cette liste est parce que nous ne voulons pas détruire ces GameObjects immédiatement, car les animations ne seront pas exécutées.
La méthode UpdateScore met à jour juste la partition et il affiche à l'écran alors que la méthode GetGOBasedOnValue retourne une maison préfabriquée spécifique en réponse à l'argument de la valeur. Par exemple, pour une valeur 2, la méthode renverra le gameobject préfabriqué pour la valeur 2.