Share
Dans le didacticiel précédent, nous avons intégré un système de base de détection de match à notre jeu Match-3. Bien que nous soyons sur la bonne voie pour avoir un jeu jouable, il reste quelques éléments de jeu importants dont nous avons besoin avant de pouvoir vraiment appeler ce que nous avons un "jeu". Cet article vise à compléter certains de ces détails manquants et à nous rapprocher de notre produit final..
Voici une démonstration du jeu sur lequel nous travaillons tout au long de cette série:
Nous allons couvrir les points avant de commencer à améliorer le système de correspondance, car il sera beaucoup plus facile de voir le premier problème dans notre système de correspondance actuel si un système de points est implémenté..
Le système de points dans notre jeu va être très simple, pour chaque bloc utilisé pour former un groupe donné, le joueur recevra 10 points. Dans un prochain tutoriel, nous ajouterons également un système permettant au joueur de gagner plus de points en enchaînant plusieurs groupes, mais pour le moment, nous allons nous concentrer sur l'introduction d'un système de points simple pour le joueur..
Avant de commencer à éditer les événements, nous devons ajouter un affichage Points, alors allez à Disposition 1 et procédez comme suit:
Accentsconagua
491, 383.Calibri, gras, 22 en utilisant le menu déroulant.ScoreText blanc ou 255, 255, 255 419, 398.200, 50.0.Disposition 1 devrait maintenant ressembler à ceci:
Maintenant que nous avons quelque chose à dire au joueur sur la signification du texte en points et un objet texte avec lequel afficher le score du joueur, nous pouvons passer à donner réellement des points au joueur. Aller à Feuille d'événement 1 et créer un nouveau Variable globale.
Nom de la variable globale: "Score" Type = Nombre Valeur = 0
La variable devrait ressembler à ceci:
C'est la variable que nous modifierons chaque fois que nous attribuerons des points au joueur. Ensuite, nous allons créer une nouvelle fonction qui, lorsqu'elle sera appelée, détectera le nombre de blocs que le joueur a mis en correspondance dans des groupes et leur donnera le nombre de points approprié..
Événement: Condition: Fonction> Activé Nom de la fonction = "GivePoints" Condition: Système> Pour chaque objet = Bloc Condition: Bloc> Est-ce que la variable d'instance booléenne est définie Variable d'instance = IsMatched Action: Système> Ajouter à la variable = Score Valeur = 10 Action: ScoreText > Définir le texte Texte = Score
Votre code devrait ressembler à ceci:
Donc, pour réitérer, cet événement examine chaque bloc. Chaque fois qu'il trouve un bloc qui a IsMatched mis à vrai - cela signifie qu'il a été confirmé que le groupe fait partie du groupe - cela donne au joueur 10 points pour ce bloc et met à jour le texte du score.
Si vous testez votre jeu à ce stade, il semblera que la fonction ne fonctionne pas. La raison en est que nous n'avons pas appelé la fonction dans le code. Les points ne sont donc jamais incrémentés et le texte n'est jamais mis à jour. Aller à votre FindMatches fonction et ajouter une nouvelle action au début du sous-événement final pour cette fonction.
Action: Fonction> Fonction d'appel Name = "GivePoints"
Votre FindMatches la fonction devrait maintenant ressembler à ceci:
Remarque: Assurez-vous d'avoir ajouté cette nouvelle action au début du sous-événement. Si vous ajoutez cette action à la fin, cela ne fonctionnera pas car tous les blocs correspondants auront été détruits avant la fin du processus. Give Points la fonction est appelée. Cela signifie que, lorsqu'il recherche les blocs correspondants, il n'en trouvera aucun et le joueur ne recevra aucun point..
À ce stade, vous pouvez tester votre jeu à nouveau et voir les mises à jour du texte des points. Le joueur reçoit le nombre correct de points pour chaque match joué..
Maintenant que nous avons le système de points, je veux que vous lanciez le jeu et que vous créiez le scénario ci-dessous..
Maintenant, permutez les blocs que j'ai surlignés ici et surveillez votre score pour voir le nombre de points que vous gagnez..
Lorsque vous avez formé ce match, vous devriez avoir vu que vous avez gagné 50 points. En effet, à l’heure actuelle, le système de points attribue au joueur 10 points pour chaque bloc marqué comme IsMatched, au lieu de donner 10 points au joueur pour chaque bloc utilisé dans chaque match, comme le système que j'ai décrit ci-dessus.
Si le système de points fonctionnait correctement, il donnerait au joueur 60 points: 30 pour le groupe vertical de trois blocs et 30 pour le groupe horizontal de trois blocs. Ce problème provient du fait que le système de match ne dispose d'aucun moyen de marquer lorsqu'un bloc est jumelé horizontalement et verticalement; il sait seulement si le bloc est assorti du tout.
Pour résoudre ce problème, nous allons d’abord ajouter deux nouveaux Variables d'instance à notre objet Block, MatchedX et Apparié.
Variable d'instance: Nom = MatchedX Type = Booléen Valeur initiale = false Variable d'instance: Nom = MatchedY Type = Booléen Valeur initiale = false
Vos variables devraient ressembler à ceci:
Ces variables vont être utilisées conjointement avec IsMatched Indique au système quand le bloc fait partie de groupes horizontaux ou X et quand le bloc fait partie de groupes verticaux ou Y. Maintenant que nous avons les variables, nous allons modifier le CheckMatches fonction de sorte que quand il étiquette un bloc IsMatched parce qu'il a trouvé un groupe assez grand, il va également étiqueter ce bloc comme faisant partie d'un groupe X ou Y, selon que le paramètre 3 ou le paramètre 4 est à 1.
Aller au CheckMatches fonction et remplacer l'original NumMatchesFound vérifiez avec ces deux nouveaux sous-événements:
Sous-événement: Condition: Système> Comparer deux valeurs Première valeur = Function.Param (3) Comparaison = Egale à la deuxième valeur = 1 Condition: Système> Variable de comparaison Variable = NumMatchesFound Comparaison = Valeur supérieure ou égale = 3 Action: Bloquer> Définir Variable Instance Booléenne = IsMatched Valeur = True Action: Bloquer> Définir Variable Instance Booléenne = MatchedX Valeur = Vrai Sous-événement: Condition: Système> Comparer deux valeurs Première valeur = Fonction.Param (4) Comparaison = Egale à Deuxième valeur = 1 Condition : Système> Variable de comparaison Variable = NumMatchesFound Comparaison = valeur supérieure ou égale à 3 = Action: Bloquer> Définir l'instance booléenne variable = IsMatched Valeur = Vrai Action: Bloc> Définir l'instance booléenne
Votre CheckMatches la fonction devrait maintenant ressembler à ceci:
Donc, la nouvelle version de CheckMatches fonctionne de la même manière que le précédent, sauf qu’il vérifie également maintenant si le bloc s’avère être une correspondance dans un groupe vertical ou un groupe horizontal, et le label en conséquence avec les nouvelles variables MatchedX et Apparié.
Maintenant que nous avons un moyen de déterminer quand un bloc est apparié verticalement, horizontalement et dans les deux directions, au lieu de simplement savoir qu'il a été apparié dans un groupe, nous devons ajouter un sous-événement à l'événement. Give Points fonction qui distribuera 10 points supplémentaires pour un bloc qui a à la fois MatchedX et Apparié mis à true.
Aller au Give Points fonction et ajouter ce sous-événement:
Sous-événement: Condition: Bloc> Est-ce que la variable d'instance booléenne est définie Variable d'instance = MatchedX Condition: Bloc> Est-ce que la variable d'instance booléenne est définie Variable d'instance = CorrespondanceY Action: Système> Ajouter à la variable = Score Valeur = 10 Action: Texte> Définir le texte Valeur = But
Votre Give Points la fonction devrait maintenant ressembler à ceci:
Si vous lancez votre jeu et créez à nouveau le scénario que j'ai illustré ci-dessus, votre score devrait maintenant augmenter correctement de 60 points..
Maintenant que nous avons mis en place un système de points et que nous avons mis à jour le système de correspondance, nous allons commencer à améliorer un autre aspect important du gameplay. Si vous avez déjà passé du temps à jouer avec le jeu jusqu'à présent, vous savez que l'un des plus gros problèmes est que, lorsque les Blocs sont détruits, rien ne leur arrive. Plus précisément, les blocs au-dessus des espaces vides ne tombent pas pour remplir ces espaces.
C’est très bien dans les tests, mais dans la version finale, il serait préjudiciable au gameplay de laisser les choses en l'état, nous allons donc ajouter «la gravité» qui fera tomber les blocs et les remplira. espaces vides lorsque d'autres blocs sont détruits.
La façon dont nous allons mettre en œuvre ce système est en fait assez simple. Nous allons effectuer une vérification en utilisant le Bloquer> Est-ce que chevauchement au décalage événement pour voir s’il existe un bloc en dessous du bloc que nous examinons. Si nous trouvons qu'il n'y a pas de bloc, nous déplacerons le bloc que nous examinons pour combler l'espace vide; sinon, nous ne ferons rien.
Pour que cela fonctionne, nous allons créer un nouvel événement:
Evénement: Condition: INVERT> Bloc> Est chevauchant le décalage Objet = Bloc Décalage X = 0 Décalage Y = 8 Action: Bloc> Déplacer à l'angle Angle = 90 Distance = (Largeur.bloc + 2) / 2
Votre code devrait ressembler à ceci:
Si vous lancez le jeu à ce moment-là, vous verrez que dès que le jeu commence, tous les blocs tombent de l'écran! La raison en est que nous n’avons rien inséré dans le code pour indiquer où se trouve le "sol" du champ de jeu..
Donc, essentiellement, les blocs de la rangée inférieure réalisent qu’il n’ya pas de blocs en dessous d’eux et tombent en conséquence. Ensuite, une fois que la rangée de blocs la plus basse est tombée, la rangée la plus basse suivante voit qu’il n’ya plus de blocs en dessous d’eux, et qu’ils tombent aussi. Ce processus se poursuit jusqu'à ce que tous les blocs soient tombés et laisse l'écran complètement vide..
Vous pouvez voir une version légèrement ralentie de ceci en action dans le GIF ci-dessous:
Pour résoudre ce problème, nous allons ajouter une deuxième condition à l'événement..
Evénement: Condition: Bloquer> Comparer Y Comparaison = inférieur ou égal à Y = SPAWNY - 1
Votre code devrait maintenant ressembler à ceci:
En ajoutant cette nouvelle condition, nous nous assurons que seuls les blocs situés au-dessus de la position Y de la rangée la plus basse sont affectés par notre "gravité". Malgré ce correctif, nous avons encore quelques problèmes.
Le problème principal est que l'événement qui cherche à savoir s'il y a un espace vide en dessous d'un bloc n'a rien à dire à ce qu'il soit inactif lorsque le joueur fait glisser un bloc. Cela signifie que si vous faites glisser un bloc trop loin sans le lâcher, les blocs situés dans la position au-dessus d'où vous l'avez fait glisser tomberont dans l'espace laissé par le bloc que vous avez déplacé. En plus de cela, le bloc que vous faites glisser aura également un problème si vous le sortez du champ de jeu et il commencera à se détacher du curseur de la souris car il n'y a pas de bloc en dessous..
Pour résoudre ce problème, nous devons ajouter une nouvelle variable globale indiquant au système lorsque nous déplaçons un bloc, une nouvelle action au bloc en faisant glisser et en déposant des événements pour définir cette variable globale et une troisième condition à l'événement gravity. cette variable en compte avant d'activer.
Commençons par créer la variable globale:
Variable globale: Nom = BlockBeingMoved Type = Numéro Valeur initiale = 0
Votre variable devrait ressembler à ceci:
Maintenant, allez au Sur DragDrop, faites glisser événement et ajouter une nouvelle action:
Action: Système> Définir la valeur Variable = BlockBeingMoved Value = 1
Aussi, allez au Drop DragDrop événement et ajoutez une nouvelle action à l'événement principal:
Action: Système> Définir une valeur Variable = BlockBeingMoved Valeur = 0
Avec les lignes ajoutées, vos événements DragDrop devraient maintenant ressembler à ceci:
Enfin, accédez à l'événement gravity et ajoutez une nouvelle condition:
Condition: Système> Variable de comparaison Variable = BlockBeingMoved Comparison = Égal à Valeur = 0
Votre code de gravité devrait maintenant ressembler à ceci:
La nouvelle variable que nous avons créée, BlockBeingMoved, est utilisé pour indiquer au système quand un blocage est déplacé par le joueur. Si la variable est égale 0 cela signifie qu'aucun bloc n'est déplacé et qu'il peut exécuter les scripts de gravité comme d'habitude. Si la variable est égale 1, cela signifie un bloc est être déplacé, et les scripts de gravité ne doivent pas être exécutés.
Si vous lancez le jeu à ce stade, vous verrez que peu importe où vous déplacez le bloc pendant que vous le faites glisser, aucun problème ne survient..
Nous n’avons plus qu’un dernier problème à régler en ce qui concerne le système gravitaire. Exécutez le jeu et créez un scénario similaire à celui-ci:
Maintenant, faites le swap que j'ai mis en évidence dans cette image suivante.
Vous remarquerez que lorsque le groupe de blocs verts / étoiles est détruit, un bloc orange / hexagone tombe et forme un groupe de trois blocs, mais n'est pas détruit..
La raison pour laquelle ces blocs ne sont pas détruits, c'est parce que nous n'avons jamais appelé le FindMatches fonctionne une deuxième fois pour voir si de nouvelles correspondances ont été formées lorsque les Blocs sont tombés pour remplir les espaces vides. Pour résoudre ce problème, allez à l'événement qui vérifie les espaces vides sous les blocs et ajoutez cet événement Else:
Evénement: Condition: Système> Sinon Action: Fonction> Fonction d'appel Name = "FindMatches"
Votre code devrait ressembler à ceci:
Cette instruction else signifie que, chaque fois qu'il trouvera qu'il n'y a pas d'espaces vides, il effectuera une vérification pour voir s'il y a des groupes à détruire. Cet événement sera automatiquement exécuté chaque fois que les blocs tomberont dans de nouvelles positions, car il est activé par une instruction Else liée à cette vérification. Il ne sera déclenché que s'il est certain que tous les blocs sont bien en place..
Si vous lancez le jeu à ce stade, vous constaterez que vous pouvez désormais créer des chaînes de blocs en détruisant les blocs de manière à former des groupes lorsque les blocs restants tomberont. En plus de cela, vous constaterez également que lorsque vous commencez le jeu, tous les groupes créés initialement seront également détruits. Comme je l'ai dit dans le didacticiel précédent, nous éliminerons éventuellement les correspondances prédéfinies, ce qui importera peu à la fin..
Enfin, nous devons faire une autre chose avant que nous puissions considérer notre système de gravité complet. Selon l'endroit où vous avez placé l'image-objet Block initiale lorsque vous avez terminé le premier tutoriel, vous remarquerez peut-être que lorsque vous démarrez le jeu, celui-ci tombe et devient visible..
Si vous ne savez pas ce que je veux dire, allez à Disposition 1, définir la position de votre sprite de bloc à 521, -32, et lancez le jeu. Lorsque vous jouez au jeu, vous devriez voir le bloc original atterrir à la position que j'ai mise en évidence dans l'image ci-dessous:
Comme vous pouvez le voir dans l'image ci-dessus, le bloc initial tombe de sa position hors écran et devient visible. Nous ne voulons pas de cela parce que cela ne nous posera que des problèmes plus tard. Pour résoudre ce petit problème, nous allons ajouter une action à la Au début de la mise en page événement qui détruira tous les blocs présents dans la mise en page lors du chargement initial.
Action: Bloquer> Détruire
Votre événement devrait maintenant ressembler à ceci:
Maintenant, lorsque vous lancez le jeu, vous ne devriez plus voir le bloc. Vous vous demandez peut-être pourquoi nous n'avons pas simplement supprimé le bloc de la mise en page afin que nous n'ayons pas à nous soucier de ce problème. La raison pour laquelle nous ne l'avons pas fait est que Construct 2 ne peut pas créer de copies de tout type d'objet avec Events, sauf s'il existe déjà une instance de ce type Object dans le jeu lors de son premier chargement. En le supprimant dans un événement, nous le supprimons afin qu'il ne devienne pas un problème plus tard, et nous permettons de générer autant de blocs que nécessaire par le biais du code..
Nous avons abordé de nombreux sujets dans ce didacticiel, et même si nous pourrions en faire davantage, je pense qu’il est important de faire une pause et de laisser cette information entrer dans les détails. Dans le prochain épisode, nous allons résoudre quelques petits problèmes. le texte en points flottants que vous avez peut-être remarqués se trouve dans la démo finale et configurez le système de chaînage.
J'espère que vous avez beaucoup profité de cette partie de la série et je vous reverrai la semaine prochaine.
