Share
Bienvenue à la cinquième édition de la série Endless Runner! Jusque-là, nous devrions avoir un petit monstre fonctionnant sur une plate-forme de défilement sans fin. Nous devrions avoir trois niveaux de défilement de parallaxe, une interaction entre notre esprit-monstre et le sol, ainsi que la possibilité de le faire sauter via une interaction tactile. Ainsi, l'étape d'aujourd'hui donnera un défi aux utilisateurs: au lieu de simplement courir sur un terrain plat, il y aura des changements de niveau et des creux dans lesquels ils devront sauter pour continuer à jouer..
Nous allons accomplir ce défi amusant en ajoutant un «système d'événements». Cela ne doit pas être confondu avec les événements intégrés que le SDK Corona utilise. Pour nos besoins, le mot «événement» est simplement un moyen simple d’expliquer ce qui se passe. Ce tutoriel utilisera le même format que le dernier. Dans le fichier de téléchargement, vous trouverez deux dossiers: "ancien" et "nouveau". Si vous n'avez pas suivi les autres didacticiels et que vous souhaitez simplement passer directement à celui-ci, vous pouvez simplement ouvrir l'ancien dossier. Il contiendra tous les fichiers dont vous avez besoin pour commencer. Le nouveau dossier contiendra le projet terminé. Si vous voulez voir à quoi tout ressemble à la fin, n'hésitez pas à prendre un pic..
Vous pouvez reconnaître le mot "événement" des tutoriels précédents. Par exemple, regardez la fonction touchée:
fonction touchée (événement) si (événement.phase == "commencé") puis si (événement.x < 241) then if(onGround) then monster.accel = monster.accel + 20 end end end end
Dans cette fonction, nous avons utilisé le mot «événement» pour décrire simplement ce qui se passait. Nous aurions très bien pu utiliser le code suivant:
fonction touchée (kapow) si (kapow.phase == "commencé") puis si (kapow.x < 241) then if(onGround) then monster.accel = monster.accel + 20 end end end end
'Event' ou 'kapow' sont simplement des variables que nous utilisons. «L'événement» se trouve être plus descriptif que «Kapow». Ainsi, lorsque nous disons «événement», nous ne parlons pas d'une variable qui décrit quelque chose qui se passe (comme le montre l'exemple précédent), mais nous utilisons le mot comme moyen de décrire un système qui contrôle le déroulement du jeu. . Vous vous demandez peut-être ce que ce "système d'événements" peut contrôler. Eh bien, à quel point notre démo est-elle amusante en ce moment? Est-ce quelque chose que vous voudriez essayer de vendre? Plus important encore, est-ce quelque chose que quelqu'un voudrait jouer? La réponse est un non douloureux, car courir et sauter sans obstacles est ennuyeux.
Afin de rendre notre jeu plus intéressant, nous devons ajouter des fonctionnalités. Des choses comme les niveaux changeants, les fosses, les obstacles, les méchants, etc., rendront le jeu beaucoup plus intéressant. Cependant, dans un jeu comme Endless Runner, nous ne pouvons pas avoir les mêmes obstacles apparaissant au même moment dans chaque jeu. Nous devons tout avoir au hasard. C'est ce qui rend ces jeux si addictifs. C'est donc ici que notre «système d'événements» va vraiment briller. Dans ce didacticiel, nous allons discuter de la création de deux événements différents: d’une part, les niveaux de changement de terrain de haut en bas, et d’autre part, la création d’un puits. Ces événements vont être générés aléatoirement à des intervalles aléatoires. Vous pouvez le faire de plusieurs façons. Pour cet exemple, le moyen le plus logique est de vérifier si nous devons commencer un nouvel événement chaque fois que nous déplaçons l'une de nos pièces au sol vers la droite de l'écran. Allons-y et regardons ce dont nous avons besoin pour faire ça.
Allez-y et ouvrez le fichier main.lua dans l'ancien dossier et nous commencerons à apporter des modifications. La première chose à faire est d’ajouter des variables que nous utiliserons tout au long du programme. Ajoutez ces lignes en haut du fichier juste en dessous de la ligne require de l’image-objet:
--ces 2 variables seront les contrôles qui contrôlent notre système d’événements. local inEvent = 0 local eventRun = 0
Ensuite, allez à la fonction updateSpeed et changez la vitesse. Nous devrions choisir une vitesse lente et progressive pour que le jeu se déroule comme prévu. Changer la ligne à ceci:
--cela ralentira considérablement la vitesse d'accélération des carreaux. --ajustez ce nombre pour que la vitesse de jeu se rapproche de celle qui fonctionne pour votre jeu. vitesse = vitesse + .0005
La prochaine chose que nous allons faire est d’ajouter notre premier événement. Notre premier événement va faire passer chacun des blocs à une hauteur nouvellement ajustée chaque fois que l’un d’eux est déplacé du côté opposé de l’écran. Cela se fera bien entendu de manière aléatoire afin que notre jeu soit toujours nouveau et passionnant. Pour démarrer notre système d’événements, changez d’abord la fonction updatesBlocks () pour ressembler à ceci:
function updateBlocks () pour a = 1, blocks.numChildren, 1 do if (a> 1), puis newX = (blocks [a - 1]). x + 79 sinon newX = (blocks [8]). x + 79 - fin de vitesse if ((blocs [a]). x < -40) then (blocks[a]).x, (blocks[a]).y = newX, groundLevel checkEvent() else (blocks[a]):translate(speed * -1, 0) end end end
La première ligne définirait simplement la position y du bloc comme étant identique à celle qu’elle était avant de créer une surface de roulement plate que nous avons vue jusqu’à présent. La seconde change la position de y en étant quel que soit le groundLevel. Le niveau du sol variable sera modifié de manière aléatoire par petits intervalles dans les fonctions suivantes. Continuez et ajoutez ces fonctions n'importe où sous la fonction de mise à jour.
function checkEvent () --d'abord, vérifiez si nous sommes déjà dans un événement. Nous ne voulons qu'un événement à la fois si (eventRun> 0), puis -si nous sommes dans un événement diminuer eventRun. eventRun est une variable qui nous indique comment - beaucoup plus longtemps l'événement va avoir lieu. Chaque fois que nous vérifions, nous devons décrémenter --il. Ensuite, si eventRun est à 0, l'événement est terminé et nous définissons donc inEvent - à 0. eventRun = eventRun - 1 if (eventRun == 0) puis inEvent = 0 end end --si nous sommes dans un événement, ne rien faire si (inEvent> 0 et eventRun> 0) alors --Ne rien d'autre - si nous ne sommes pas dans un événement, vérifiez si nous allons commencer un nouvel événement. Pour ce faire, nous générons un nombre aléatoire compris entre 1 et 100. Nous vérifions ensuite si notre «contrôle» est - en cours pour commencer un événement. Nous utilisons 100 ici dans l'exemple car il est facile de déterminer - la probabilité qu'un événement se déclenche (nous pourrions tout aussi facilement choisir 10 ou 1000). --Par exemple, si nous décidons qu'un événement est sur le point de commencer - chaque fois que le contrôle est supérieur à 80, nous savons que chaque fois qu'un bloc est réinitialisé, il y a 20% de chances qu'un événement démarre. Donc, un bloc sur cinq devrait commencer un nouvel événement. C’est là que vous devrez répondre aux besoins de votre jeu. check = math.random (100) --Ce premier événement va modifier l’élévation du sol. Pour ce jeu, nous voulons seulement que l'élévation change d'un bloc à la fois afin d'éviter de longs cycles de changement d'élévation impossible à passer; nous définissons donc eventRun à 1. if (check> 80 et check < 99) then --since we are in an event we need to decide what we want to do. By making inEvent another --random number we can now randomly choose which direction we want the elevation to change. inEvent = math.random(10) eventRun = 1 end end --if we are in an event call runEvent to figure out if anything special needs to be done if(inEvent > 0) then runEvent () end end --cette fonction est assez simple, elle vérifie simplement quel événement doit se produire, puis - met à jour les éléments appropriés. Notez que nous vérifions pour nous assurer que le sol se trouve dans une certaine marge. Nous ne voulons pas que le sol apparaisse au-dessus ou au-dessous de ce qui est visible à l'écran. fonction runEvent () if (inEvent < 6) then groundLevel = groundLevel + 40 end if(inEvent > 5 et inEvent < 11) then groundLevel = groundLevel - 40 end if(groundLevel < groundMax) then groundLevel = groundMax end if(groundLevel > groundMin) alors groundLevel = groundMin fin fin
La première fonction checkEvent sera appelée chaque fois que nous réinitialiserons l'emplacement du bloc. Alors, allez-y et appelez checkEvent () juste après la ligne que nous avons modifiée dans updateBlocks (). Chaque fois que checkEvent () est appelé, nous vérifions si nous devons ou non démarrer un événement. Il vérifiera également si un événement est déjà en cours d'exécution. Cela nous aidera à contrôler nos comportements afin d'éviter que de nombreux événements fous ne se produisent en même temps. Exécutez ceci et vous devriez maintenant avoir un jeu beaucoup plus amusant à jouer!
Notez que si vous heurtez un mur, vous ne mourrez pas; vous arrêtez simplement. C'est suffisant pour le moment. Rappelez-vous simplement que lorsque vous mourez ou à tout autre moment où vous souhaitez redémarrer le simulateur, vous devez simplement appuyer sur les touches de commande ou de commande R et le niveau redémarrera instantanément..
Vous pouvez maintenant voir comment nous créons des événements pour contrôler le déroulement du jeu. Nous allons maintenant ajouter un deuxième événement, mais cette fois-ci, nous n'utiliserons pas runEvent pour apporter nos modifications. Nous allons ajouter une fosse sur laquelle le joueur devra sauter pour continuer à jouer. Cela peut être ajouté assez rapidement, alors mettons-nous au travail!
La première chose à faire ici est d’ajouter une vérification dans la fonction checkEvent (). Ajoutez cette section juste en dessous de l'autre vérification à l'intérieur de la même déclaration if / else:
if (check> 98) alors inEvent = 11 eventRun = 2 end
Ensuite, allez à la fonction updateBlocks () et changez la section qui ressemble à ceci:
si ((blocs [a]). x < -40) then (blocks[a]).x, (blocks[a]).y = newX, groundLevel checkEvent() else (blocks[a]):translate(speed * -1, 0) end
Faites que ça ressemble à ceci:
si ((blocs [a]). x < -40) then if(inEvent == 11) then (blocks[a]).x, (blocks[a]).y = newX, 600 else (blocks[a]).x, (blocks[a]).y = newX, groundLevel end checkEvent() else (blocks[a]):translate(speed * -1, 0) end
Après cela, vous devriez avoir un deuxième événement dans le jeu qui peut générer aléatoirement le pit!
Notez cependant qu'au lieu de définir l'action qui se produira à l'intérieur de la fonction runEvent, nous le faisons directement à l'intérieur de la fonction updateBlock (). C'est pourquoi les systèmes d'événements tels que celui-ci sont utiles. Cela nous permet de définir facilement des événements et de mettre à jour le jeu dans les zones de notre code qui nous semblent les plus utiles. J'espère que cela vous donne une idée de ce que vous pouvez faire avec les événements. Amusez-vous à jouer avec eux et rendez votre jeu riche en événements intéressants. Dans le prochain tutoriel, nous ajouterons deux événements supplémentaires pour que le jeu reste un défi: les monstres méchants et les obstacles destructibles! Alors accordez-vous la prochaine fois, et si vous avez des questions, s'il vous plaît laissez-moi savoir dans les commentaires.
Accentsconagua