Construisez un jeu de coureur sans fin à partir de zéro obstacles et ennemis

Bienvenue à la sixième partie de notre série de didacticiels Endless Runner! Notre jeu commence à prendre forme et à se sentir plus poli. Après avoir terminé les étapes de la journée, ce sera beaucoup plus interactif et amusant. Nous ajouterons deux autres événements qui créeront de nouveaux défis passionnants pour les joueurs. Premièrement, nous allons ajouter la possibilité pour notre héros de tirer un petit coup pour éliminer les obstacles qui se dirigent vers lui. Gardez à l'esprit que la petite image "bleuâtre" est en train de tirer de notre monstre. Les images avec lesquelles nous travaillons ne sont pas spécialement professionnelles, elles sont simplement destinées à la pratique. Une fois que le monstre aura la capacité de tirer des verrous, nous ajouterons également des événements qui renverront des obstacles vers lui. Après cela, nous allons créer deux types d'obstacles: le premier est un mur à pointes qui va s'asseoir sur le sol et se déplacera à la même vitesse que le sol, et le second est un fantôme qui volera du côté supérieur droit de l'écran vers le joueur.

Alors, commençons! La première chose à faire est de s’assurer que tous les actifs sont au bon endroit. Téléchargez le fichier joint à ce didacticiel et dans le "nouveau" dossier, vous trouverez trois nouveaux actifs. Vous pouvez également cliquer avec le bouton droit de la souris sur les images et les enregistrer dans le bon dossier. Les images doivent être nommées spikeBlock.png, ghost.png et blast.png..

Ouvrez votre fichier main.lua qui se trouve dans le "vieux" dossier des téléchargements du tutoriel. Nous allons commencer par donner à nos joueurs la possibilité de tirer car nous ne voulons pas les laisser sans défense, car ils sont bombardés de nouveaux défis! Nous pouvons ajouter cette capacité en trois étapes. Le premier instanciera 5 verrous et les mettra dans un groupe. Plutôt que de créer et de détruire des objets chaque fois que nous voulons les utiliser, nous pouvons être plus efficaces en les préparant et en les stockant hors écran jusqu'à ce que nous ayons besoin de les utiliser. Nous allons en fait faire la même chose pour chacune des trois images différentes, alors n'hésitez plus et ajoutez ce code entre où nous déclarons la variable de vitesse et où nous créons nos blocs.

 --créer des fantômes et définir leur position pour qu'ils soient hors écran pour a = 1, 3, 1 faire fantôme = display.newImage ("ghost.png") ghost.name = ("fantôme"… a) fantôme.id = un fantôme. x = 800 ghost.y = 600 ghost.speed = 0 --variable permettant de déterminer s’ils sont en jeu ou non fantôme.isAlive = false - rend les fantômes transparents et plus… fantomatiques! ghost.alpha = .5 ghosts: insert (ghost) end --create spikes pour a = 1, 3, 1 spike = display.newImage ("spikeBlock.png") spike.name = ("spike"… a) spike .id = a spike.x = 900 spike.y = 500 spike.isAlive = faux spikes: insert (spike) end --create blast pour a = 1, 5, 1 do blast = display.newImage ("blast.png" ) blast.name = ("blast"… a) blast.id = un blast.x = 800 blast.y = 500 blast.isAlive = faux blasts: insérer une fin (blast)

Notez qu'ils ont tous des caractéristiques communes. Nous devons y aller et les nommer au cas où nous voudrions jamais les référencer individuellement. Nous leur donnons un identifiant, ce qui nous donne également plus d'options de référence futures. Nous leur donnons leurs coordonnées x et y hors écran (nous empilons des images similaires les unes sur les autres). Une autre chose que nous leur donnons tous est la variable 'alive'. Ceci est défini sur false par défaut car ils seront assis hors de l'écran. Donner aux sprites cette variable nous permettra de vérifier rapidement si le sprite est utilisé ou non. Le seul lutin qui a quelque chose de différent est le fantôme. Pour les images-objets fantômes, nous ajouterons une variable de vitesse afin que les images fantômes se déplacent à des vitesses aléatoires. Nous allons également régler l'alpha des fantômes sur .5 afin qu'ils apparaissent plus, dirons-nous, comme des fantômes!

Nous devons ensuite créer leurs groupes d’affichage respectifs, puis les ajouter au groupe d’affichage à l’écran afin que nous puissions les voir dans le jeu. Ajoutez-les juste en dessous de l'instanciation des autres groupes d'affichage.

 fantômes locaux = display.newGroup () spikes locaux = display.newGroup () explosions locales = display.newGroup ()

Ensuite, allez dans la section où nous ajoutons tout à l’écran. Ajoutez ces groupes d'affichage avec le reste. Je voudrais que la nouvelle commande ressemble à ceci:

 --la plupart de l'ordre ici n'a pas d'importance tant que les arrière-plans - sont à l'arrière et les fantômes et le monstre sont à la fin de l'écran: insert (backbackground) écran: insert (backgroundfar) écran: insert (backgroundnear1) écran: insert (backgroundnear2 ) écran: insérer (blocs) écran: insérer (pointes) écran: insérer (explosions) écran: insérer (fantômes) écran: insérer (monstre) écran: insérer (collisionRect)

Une fois que vous avez tout compris, cela devrait ressembler à quelque chose comme ceci si vous deviez l'exécuter dans la perspective iPhone 4:

Après avoir mis cela en place, nous ajouterons la fonction qui met à jour tous les boulons que notre monstre tire. Ajoutez la fonction suivante sous la fonction checkCollisions ().

 function updateBlasts () --pour chaque souffle que nous avons instancié, vérifiez ce qu'il fait pour a = 1, blasts.numChildren, 1 faire - si l'explosion n'est pas en cours, nous n'avons pas besoin de vérifier quoi que ce soit si ( Explosions [a] .isAlive == true) then (Explosions [a]): traduire (5, 0) --si l'explosion s'est éloignée de l'écran, puis tuez-la et remettez-la à son emplacement d'origine si (explosions [ a] .x> 550) puis souffle [a] .x = 800 explosions [a]. j = 500 explosions [a] .isAlive = faux fin - contrôle des collisions entre les explosions et les pointes de b = 1, spikes.numChildren, 1 fais si (pointes [b] .isAlive == vrai) puis si (coups [a] .y - 25> pointes [b] .y - 120 et coups [a]. points +. < spikes[b].y + 120 and spikes[b].x - 40 < blasts[a].x + 25 and spikes[b].x + 40 > explosions [a] .x - 25) puis explosions [a]. x = 800 explosions [a]. j = 500 explosions [a]. isAlive = fausses pointes [b] .x = 900 pointes [b] .y = 500 spikes [b] .isAlive = false end end end - vérifier les collisions entre les explosions et les fantômes pour b = 1, ghosts.numChildren, 1 do if (fantômes [b] .isAlive == true) puis if (explosions [ a] .y - 25> fantômes [b] .y - 120 et explosions [a] .y + 25 < ghosts[b].y + 120 and ghosts[b].x - 40 < blasts[a].x + 25 and ghosts[b].x + 40 > explosions [a] .x - 25) puis exécute des explosions [a] .x = 800 explosions [a] .y = 500 explosions [a] .isAlive = faux fantômes [b] .x = 800 fantômes [b] .y = 600 fantômes [b] .isAlive = faux fantômes [b] .speed = 0 fin fin fin fin fin

La fonction ci-dessus va avoir deux responsabilités principales. La première consiste à mettre à jour la position de l'explosion et à vérifier si elle est entrée en collision avec quoi que ce soit. Vous pouvez voir que quand il entre en collision avec quelque chose, la façon dont nous le détruisons est simplement de le déplacer hors écran et de définir isAlive sur false. Le boulon sera prêt à être utilisé à nouveau. Une autre chose que vous avez peut-être remarquée est que nous n'instancions que cinq boulons. Alors, que se passe-t-il si les cinq verrous sont déjà en jeu et que l'utilisateur essaie de tirer une autre fois? Rien! Avec la configuration actuelle, l’utilisateur est limité à cinq explosions actives à la fois. Il est facile de changer cela en en instanciant davantage au début du jeu, mais cela vous montre comment définir des limites pour les joueurs. C’est aussi une méthode que nous allons utiliser pour nous assurer que 50 fantômes ne génèrent pas de manière aléatoire en une seule fois sur l’écran, ce qui tue instantanément le joueur..

Ensuite, nous devons passer à la fonction touchée pour donner au joueur la possibilité de tirer. Modifiez la fonction touchée pour qu'elle corresponde à ce qui suit:

 --la seule différence dans la fonction touchée est maintenant si vous touchez le côté droit de l'écran, le monstre déclenchera une petite fonction de verrou bleu touchée (événement) si (event.phase == "commencé") puis si (événement. X < 241) then if(onGround) then monster.accel = monster.accel + 20 end else for a=1, blasts.numChildren, 1 do if(blasts[a].isAlive == false) then blasts[a].isAlive = true blasts[a].x = monster.x + 50 blasts[a].y = monster.y break end end end end end

Enfin, assurez-vous d’ajouter updateBlasts () à la fonction de mise à jour principale et vous devriez être prêt à commencer. Essayez-le et voyez l'incroyable puissance que notre monstre a maintenant! Après l'avoir lancé, vous devriez voir quelque chose comme ça:

Maintenant que les joueurs peuvent se défendre, allons-y et posons-leur des défis. Ces deux prochains événements seront surmontés simplement en les tirant une fois. Cependant, une fois qu’ils seront en place, il vous sera facile de les modifier pour les adapter à votre propre projet. Nous allons commencer avec le mur à pointes.

Le mur à crampons sera simplement placé sur le sol actuel et se déplacera à la même vitesse constante que le sol qui l’entoure. La première chose à faire est d’ajouter la fonction updateSpikes. Juste en dessous de la fonction updateBlasts (), ajoutez le code suivant:

 --vérifiez si les pointes sont actives ou non, si elles le sont - puis mettez-les à jour de manière appropriée updateSpikes () pour a = 1, spikes.numChildren, 1 do if (spikes [a] .isAlive == true), puis (spikes [a]): traduire (vitesse * -1, 0) si (pointes [a] .x < -80) then spikes[a].x = 900 spikes[a].y = 500 spikes[a].isAlive = false end end end end

Cela fera la même chose que notre fonction updateBlast. Il mettra simplement à jour la position du mur à crampons et vérifiera s'il est sorti de l'écran (ce qu'il ne peut pas faire actuellement car il toucherait le joueur en premier). Juste au cas où, nous vérifierons pour être sûr. La dernière chose à faire est d'organiser un événement. Dans checkEvent () sous les autres contrôles, ajoutez ceci:

 --plus souvent vous voulez que les événements se produisent, alors - plus vous ferez la vérification si (check> 72 et check < 81) then inEvent = 12 eventRun = 1 end

Nous allons en fait ajouter notre mur dans la fonction updateBlocks (). De cette façon, nous sommes sûrs d’avoir le terrain actuel. Juste avant d'appeler checkEvent (), insérez ce qui suit:

 --En installant les pointes de cette façon, nous sommes assurés de n'avoir que 3 pointes au maximum à la fois. if (inEvent == 12), alors pour a = 1, spikes.numChildren, 1 do if (spikes [a] .isAlive == true), alors - rien d'autre spikes [a] .isAlive = true spikes [a]. y = groundLevel - 200 pointes [a] .x = nouvelle fin de fin de pause X

La dernière chose à faire pour que cela fonctionne est d’ajouter la détection de collision pour voir si notre joueur l’a rencontré ou non. Placez ceci juste en dessous de la section dans checkCollisions () où nous vérifions les collisions entre les blocs et le monstre..

 --arrêtez le jeu si le monstre se heurte à un mur de pics pour a = 1, spikes.numChildren, 1 do if (pics [a] .isAlive == true) puis if (collisionRect.y - 10> pics [a] .y - 170 et pointes [a] .x - 40 < collisionRect.x and spikes[a].x + 40 > collisionRect.x) then --stop the monster speed = 0 end end end

Assurez-vous d’ajouter updateSpikes () à la fonction principale de mise à jour et lancez-la! Vous devriez maintenant avoir ces pointes sur le chemin de votre monstre.

Donnez-lui un tourbillon et entraînez-vous à les abattre. N'oubliez pas de tester pour vous assurer que les collisions fonctionnent correctement avec les explosions. Assurez-vous également que courir dans les murs tue le joueur. Une fois que vous avez testé cela et êtes prêt pour plus, commencez à mettre le code en place pour le fantôme.

Mettre le fantôme dedans est à peu près identique à mettre le mur. La plus grande différence entre les deux est que pour le fantôme nous allons randomiser où il intervient et à quelle vitesse il se déplace. Nous ferons également en sorte que les fantômes montent et descendent de sorte qu'ils se déplacent toujours là où se trouve l'utilisateur. De tels détails rendent les obstacles totalement différents pour l'utilisateur, même s'ils fonctionnent de manière similaire.

Reprenons en ajoutant la fonction updateGhosts (). Allez-y et ajoutez updateGhosts () à la fonction de mise à jour principale..

 --met à jour les fantômes s'ils sont en vie function updateGhosts () pour a = 1, ghosts.numChildren, 1 do if (fantômes [a] .isAlive == true) alors (fantômes [a]): translate (vitesse * -1, 0 ) si (fantômes [a] .y> monster.y) puis fantômes [a] .y = fantômes [a] .y - 1 extrémité si (fantômes [a] .y < monster.y) then ghosts[a].y = ghosts[a].y + 1 end if(ghosts[a].x < -80) then ghosts[a].x = 800 ghosts[a].y = 600 ghosts[a].speed = 0 ghosts[a].isAlive = false; end end end end

Ensuite, retournez dans la fonction checkEvent () et ajoutez ceci en dessous des vérifications précédentes:

 --événement fantôme si (cocher> 60 et cocher < 73) then inEvent = 13 eventRun = 1 end

Cette fois, au lieu de déplacer les fantômes de la fonction updateBlocks, nous le ferons dans la fonction runEvent (). Ajoutez ceci en dessous des autres déclarations if:

 --ce sera un peu différent car nous voulons vraiment que cela rende le jeu encore plus aléatoire. changez l'endroit où les fantômes - apparaissent et à quelle vitesse ils viennent chez le monstre. if (inEvent == 13), puis pour a = 1, ghosts.numChildren, 1 doit faire if (ghosts [a] .isAlive == false), puis ghosts [a] .isAlive = true. a] .y = math.random (-50, 400) fantômes [a] .speed = math.random (2,4) pause fin fin fin

Une fois que cela est là, nous devons vérifier les collisions entre le monstre et les fantômes. Ajoutez ceci à checkCollions () juste après le travail pour les murs à pointes:

 --assurez-vous que le joueur n'a pas été touché par un fantôme! pour a = 1, ghosts.numChildren, 1 do if (fantômes [a] .isAlive == true) puis if (((((monster.y-fantômes [a] .y)).)<70) and ((monster.y - ghosts[a].y) > -70)) et (fantômes [a] .x - 40 < collisionRect.x and ghosts[a].x + 40 > collisionRect.x)) then --stop the monster vitesse = 0 fin fin fin

Vous devriez maintenant avoir tout en place, y compris les fantômes à éviter!

Le jeu devrait maintenant être beaucoup plus amusant et stimulant pour les utilisateurs. Dans le prochain didacticiel, nous ajouterons deux éléments supplémentaires qui rendront notre jeu plus complet: (1) un système de notation et (2) la mort d'un monstre! Nous avons couvert beaucoup de choses dans ce tutoriel, donc si vous avez des questions, veuillez écouter les commentaires ci-dessous. Merci d'avoir lu!