Share
Nous sommes maintenant à mi-parcours de cette série et jusqu'à présent, nous avons beaucoup couvert. Dans le tutoriel précédent, nous avons ajouté un système de points à notre jeu, nous avons finalement appliqué la «gravité» aux blocs et amélioré notre système de correspondance. Dans ce tutoriel, nous allons apporter de petites améliorations à notre système d’échange, ajouter le texte en virgule flottante que vous pouvez voir dans la version finale du jeu et terminer notre système de correspondance une fois pour toutes..
Voici une démonstration du jeu sur lequel nous travaillons tout au long de cette série:
À l'heure actuelle, le jeu dispose d'un mécanisme d'échange très simple. Bien que le système que nous utilisons pour effectuer ces échanges soit très efficace, vous pouvez rencontrer deux problèmes en jouant, et les deux doivent être résolus avant de continuer..
Ces problèmes découlent de la même idée: que le système d’échange ne prend pas en compte les limites du terrain de jeu..
Qu'est-ce que cela signifie, exactement? Eh bien, tout d’abord, si vous le souhaitez, vous pouvez déplacer un bloc en dehors du terrain de jeu vers la gauche ou la droite, en effectuant un échange comme celui illustré ci-dessous:
Si vous entrez dans le jeu et effectuez cet échange, vous verrez que le jeu ne fait rien pour vous arrêter et agit comme si le champ de jeu continuait pour toujours dans une direction horizontale. La raison en est que, en ce moment, le terrain de jeu Est-ce que continuer pour toujours horizontalement.
Puisque nous n'avons jamais défini où se trouvent les limites gauche et droite du champ de jeu, ni même que le champ de jeu a des limites gauche et droite, le jeu ne tente jamais d'empêcher le joueur de déplacer le bloc plus loin sur le côté. Ce problème se pose également lorsque vous permutez l’autre côté du jeu..
Pour résoudre ce problème, nous allons ajouter de nouvelles conditions à la Bloquer> Sur Drop DragDrop Un événement. Accédez à cet événement et ajoutez cette condition au sous-événement qui recherche les swaps à gauche:
Condition: LeftBlock> Compare X Comparison = plus grand ou égal X = SPAWNX
Ajoutez maintenant cette condition au sous-événement qui vérifie les échanges justes:
Condition: RightBlock> Comparaison X Comparaison = inférieur ou égal à X = SPAWNX + Block.Width * 8
Vos événements de permutation gauche et droite devraient maintenant ressembler à ceci:
Ces nouvelles conditions que nous avons ajoutées sont utilisées par les événements d'échange pour vérifier que l'échange est effectué dans les limites horizontales du champ de jeu. Le premier assure que la position dans laquelle le bloc serait échangé n'est pas plus à gauche que les blocs les plus à gauche, et le second garantit que la position dans laquelle le bloc est échangé n'est pas plus à droite que la droite. la plupart des blocs.
Avec le second, j'ai utilisé une formule avec Block.Width trouver où se trouvent les blocs les plus à droite pour s'assurer que, si la taille des blocs change, cela n'empêchera pas cette condition de fonctionner.
Si vous exécutez le jeu, vous ne devriez plus être en mesure de procéder à des échanges horizontaux qui placeraient des blocs en dehors de la zone de jeu..
L’autre problème que nous avons est que le jeu ne vous empêche pas d’échanger un bloc sous le champ de jeu. Ouvrez le jeu et essayez de faire un échange semblable à celui que j'ai illustré dans cette image:
Après avoir effectué cet échange, vous devriez avoir vu le bloc disparaître essentiellement derrière la partie inférieure du terrain de jeu, et les blocs qui se trouvaient au-dessus auraient dû tomber pour remplir l'espace maintenant vide. Encore une fois, ce problème est dû au fait que nous n’avons jamais défini l’emplacement du bord inférieur du champ..
Dans le didacticiel précédent, nous avions déclaré que les blocs devaient cesser de tomber après avoir atteint une certaine hauteur, mais nous n'avons jamais précisé s'il était acceptable qu'un bloc passe au-dessous de cette hauteur lors d'un échange..
Le résoudre sera aussi simple que les deux précédents. Accédez au sous-événement qui vérifie les échanges vers le bas et ajoutez cette condition:
Condition: comparez Y Comparaison = Moins ou égal Y = SPAWNY
Votre code pour cette section devrait maintenant ressembler à ceci:
Tout comme la condition précédente, cela garantit que l'échange ne placerait pas le bloc dans une zone en dehors du champ de jeu. Dans ce cas, il regarde la zone en dessous du terrain de jeu.
Si vous testez votre jeu à ce stade, vous ne devriez plus pouvoir effectuer d’échanges qui placent le bloc sous la base du champ de jeu..
À ce stade, nous avons résolu les problèmes liés au système d’échange et pouvons améliorer encore notre système de points..
En ce moment, notre système de points est assez efficace. Cela fonctionne comme prévu et affiche déjà tout correctement. Malgré cela, cependant, si vous donniez le jeu à un joueur et que vous l'assistiez, il pourrait ne pas être en mesure de dire exactement combien de points il obtenait de chaque groupe qu'il a créé, car le jeu peut évoluer rapidement..
Pour résoudre ce problème, nous allons ajouter des fenêtres contextuelles indiquant le nombre de points que le joueur gagne à partir des groupes qu’il forme. Cela ajoutera une touche visuelle supplémentaire au jeu et montrera clairement au joueur à quel point des groupes plus importants peuvent être précieux..
Avant que nous puissions commencer à ajouter la fonctionnalité, nous devons créer un nouvel objet qui fera office de texte contextuel. Suivez donc ces étapes..
Accentsconagua
FloatingPointsText Terrain de jeu 616, 250 127, 43 0 Calibri, gras, 24 255, 255, 255 1,25.L'objet que nous venons de créer va être utilisé pour créer le texte flottant qui indique au joueur le nombre de points qu'un groupe donné lui attribuera. Maintenant que nous avons réellement cet objet, nous devons l'implémenter de sorte que lorsque le joueur crée une correspondance, il crée une nouvelle instance de l'objet et modifie le texte pour afficher le nombre de points approprié..
Pour générer le texte de points, nous allons ajouter deux nouvelles actions au NumMatchesFound vérifie dans le FindMatches une fonction.
Aller au FindMatches fonction, et ajoutez ces deux actions à la fin de chaque NumMatchesFound> 3 vérifier:
Action: Système> Créer un objet Objet = FloatingPointsText Layer = 2 X = Block.X - Block.Width / 2 Y = Block.Y - Block.Width / 2 Action: FloatingPointsText> Définir le texte Texte = NumMatchesFound * 10
Votre FindMatches la fonction devrait maintenant ressembler à ceci:
Alors que font ces actions? La première action crée le FloatingPointsText objet au-dessus du premier bloc du groupe et le second multiplie par 10 le nombre de blocs du groupe, comme le fait notre formule de points, et définit le texte du nouvel objet sur ce nombre.
Si vous lancez le jeu à ce stade, vous remarquerez que le texte ne bouge pas du tout. Pour résoudre ce problème, nous allons ajouter un nouvel événement à notre jeu..
Revenir à Feuille d'événement 1 et ajoutez un nouvel événement:
Condition: Système> Chaque action de tick: FloatingPointsText> Déplacer à un angle Angle = -90 Distance = 0,25
Votre nouvel événement devrait ressembler à ceci:
Si vous lancez le jeu maintenant, vous verrez que le texte bouge.
À ce stade, notre FloatingPointsText fonctionne comme nous le souhaitons, mais vous avez peut-être remarqué un léger problème maintenant que le système est en place. Le problème lui-même découle du fonctionnement du système de correspondance. Maintenant que nous pouvons constater qu’il ya toujours un problème de correspondance, nous pouvons régler ce dernier problème et mettre de côté notre système de correspondance..
Si vous ne savez pas encore de quel problème je parle, entrez dans le jeu et formez un groupe de quatre blocs. Une fois que votre groupe est constitué, vous devriez voir quelque chose de similaire à ce que j'ai dans l'image ci-dessous:
Comme vous pouvez le constater, nous avons effectivement deux instances des objets texte flottants. Si vous faites un groupe avec cinq blocs, le problème s'aggrave et vous verrez en réalité trois occurrences du texte des points..
La raison de ce problème est basée sur la façon dont les correspondances sont détectées. À l'heure actuelle, notre système d'appariement examine chaque bloc individuellement et regarde dans le bon sens et dans le bas pour trouver des correspondances. Pour cette raison, le système d’appariement recherche ici trois groupes de tailles différentes, même s’il s’agit en réalité d’un seul grand groupe..
Le premier groupe sera trouvé quand il commencera par le bloc A et contiendra cinq blocs:
Le deuxième groupe sera trouvé quand il commencera par le bloc B et contiendra quatre blocs:
Et le troisième groupe sera trouvé quand il commencera par le bloc C et contiendra trois blocs:
Donc, en ce moment, notre système de correspondance est très inefficace - et en panne - puisqu'il vérifie les mêmes blocs plusieurs fois et enregistre plus de groupes qu'il n'y en a réellement..
Résoudre ce problème est en réalité beaucoup plus simple qu'il n'y paraît au premier abord.
Le problème ici provient principalement du fait que le système de mise en correspondance n'a aucun moyen de savoir si le bloc par lequel il commence est en réalité le début du groupe. Si nous pouvions garantir que nous ne considérions que les blocs les plus éloignés à droite, ou les plus élevés, au sein des groupes auxquels ils appartenaient, le système d'appariement serait efficace tel quel..
Donc, tout ce que nous avons à faire est d’ajouter une condition ou un événement qui garantit qu’il n’y a pas de blocs correspondants au-dessus ou à gauche du bloc avec lequel nous commençons, et d'indiquer à la fonction quand elle a effectué cette vérification, de sorte procéder normalement si le bloc qu'il regarde est le début du groupe.
La première chose que nous allons ajouter est un nouveau paramètre pour le CheckMatches une fonction. Ce paramètre sera un entier et ce sera soit 1 ou 0.
Si le paramètre est 1, il indiquera à la fonction qu'il doit effectuer le contrôle pour s'assurer qu'il regarde le bloc initial du groupe; Si c'est 0, il indiquera à la fonction qu'il a déjà effectué cette vérification et peut procéder normalement pour déterminer si le groupe est composé de trois blocs ou plus.
Alors, commencez par aller à la FindMatches une fonction. Dans cette fonction, vous appelez CheckMatches deux fois. Comme c'est la première fois que vous appelez CheckMatches quel que soit le bloc que vous regardez, vous devez ajouter un nouveau paramètre à chacun de ces appels de fonction et le régler sur 1 de sorte qu'il va vérifier si le bloc qu'il regarde est le début d'un groupe.
Votre FindMatches La fonction devrait maintenant ressembler à ceci, et j’ai mis en évidence les deux déclarations modifiées pour votre commodité:
Maintenant que nous disons CheckMatches lorsqu'il doit effectuer cette nouvelle vérification, nous devons en fait l'ajouter pour qu'elle puisse être exécutée. Aller à votre CheckMatches fonction et ajoutez ce nouveau sous-événement en tant que premier sous-événement:
Evénement: bloc> comparer X Comaprison = égal à X = Function.Param (0) - ((Block.Width + 2) * Function.Param (3)) Condition: Bloc> Comparer Y Comaprison = égal à Y = = Function.Param (1) - ((Block.Width + 2) * Function.Param (4)) Condition: Fonction> Paramètre de comparaison Index = 5 Comparaison = Egal à Valeur = 1
Avant de terminer la modification du CheckMatches fonction, vous devez également ajouter une instruction Else en haut de l'événement d'origine pour la CheckMatches fonction, et vous devez ajouter le nouveau paramètre à la CheckMatches appel de fonction et réglez-le sur 0.
Le nouveau code de la fonction CheckMatches devrait ressembler à ceci:
L'événement que nous avons ajouté fait exactement ce que j'ai décrit ci-dessus. Tout d'abord, il regarde le bloc au-dessus ou à gauche du bloc initial que vous passez..
Si ce bloc a la même couleur que celui que vous avez transmis, il ne fait rien car il sait que le bloc que vous avez transmis n'est pas le premier bloc de ce groupe..
D'autre part, si c'est ne pas de la même couleur que le bloc que vous avez entré, la vérification initiale a lieu à cause de l'instruction Else que nous venons d'ajouter et elle recherche un groupe de trois blocs ou plus comme d'habitude.
Si vous testez le jeu à ce stade et créez un groupe de plus de trois blocs, vous ne devriez voir qu'un seul objet texte flottant vous indiquant le nombre de points que ce groupe valait..
Maintenant que nous avons terminé de corriger toutes ces caractéristiques et que nous avons enfin terminé notre système d’appariement, nous sommes prêts à mettre en œuvre le système de mouvement. Comme nous avons déjà beaucoup travaillé dans ce tutoriel et que le système de déplacement nécessite la création de plusieurs systèmes complexes, je vais attendre le prochain article pour démarrer le système de déplacement..
Si vous êtes impatient de commencer à travailler dessus, considérez quelques-unes de ces choses. De toute évidence, la première chose à faire est de mettre en œuvre le mouvement lui-même. Pour cela, essayez d’utiliser un système similaire à celui que nous avions utilisé pour faire flotter les objets texte. À partir de là, commencez à réfléchir à la manière dont vous modifieriez la vitesse à laquelle ils bougent. Enfin, comment allez-vous générer de nouvelles rangées de blocs pour le joueur et comment saurez-vous quand générer de nouvelles lignes?
Prenez le temps d’envisager ces choses et je vous reverrai la semaine prochaine pour le prochain grand épisode de la série..
