RMEx
RMEx

Community


Vous n'êtes pas connecté. Connectez-vous ou enregistrez-vous

Event qui suit un chemin

Voir le sujet précédent Voir le sujet suivant Aller en bas  Message [Page 1 sur 1]

Il s'agit d'un code à mettre dans un event pour que selui-ci se mettre à suivre un chemin qu'on lui trace, en attribuant au chemin un type de terrain qui lui est propore (ici 1). J'ai codé ce système en pensant au tower defense d'Ibiky.

Voici un screen du code en question. il n'est pas optimisé à max mais j'avais la flemme je pense ^^ :


Et voici une démo en vidéo, parce que les vidéos c'est bien :D



Bon par contre Joke je pense qu'il y a des modifs à faire dans le css car ça rend pas bien du tout ce post XD

Voir le profil de l'utilisateur
J'avoue que je n'ai pas tout compris, j'aurais bien aimé quelques explications dans le sujet ou des commentaires, particulièrement concernant les SV 6 et 7. La vidéo montre bien ce qu'on doit obtenir. Tu as essayé avec une boucle plutôt qu'avec des étiquettes ?

Voir le profil de l'utilisateur
@Ulis a écrit:Tu as essayé avec une boucle plutôt qu'avec des étiquettes ?
En fait les étiquettes sont utilisées comme une forme de continue, dès qu'un déplacement est fait on retourne au début de la boucle. La boucle est donc faite non pas avec des étiquettes mais avec l'event en entier (vu que c'est du processus parallèle).

Pour ce qui est de l'event en fait il est composé de deux modules : un premier pour détecter si l'event peut faire un pas en avant et un second pour vérifier s'il peut aller dans chaque direction qui n'est pas derrière-lui (pour ne pas qu'il fasse demi-tour).

Le but du premier module est en fait pour gérer les croisements : Si jamais sa route est croisée par une autre il va toujours prendre en face de lui. Je sais pas si je suis clair ><

Pour ce qui est du bloc avec les SV[] au début il s'agit justement d'un code pour trouver la case qui se trouve devant le héros quelle que soit sa direction.

Donc pour faire ligne par ligne :

Code:
SV[2] = me
SV[0] = event_x(SV[2])
SV[1] = event_y(SV[2])
On récupère son id dans SV[2] puis on s'en sert pour mettre sa position en x et y dans SV[0] et SV[1].

Code:
SV[3] = event_direction(SV[2])
On récupère la direction dans laquelle il regarde (qui peut être 2, 4, 6, 8 s'il regarde en bas, gauche, droite, haut)

Code:
SV[4] =  [[0, 1], [-1, 0], [1, 0], [0, -1]]
Ici on crée un tableau de tableaux, chaque tableau représentant [un décalage en x, un décalage en y] chaque sous-tableau peut alors, en étant ajouté aux SV[0] et SV[1] représenté une case.
Et comment savoir quel sous tableau prendre ? L'astuce est d'utiliser la direction du héros
(qui peut être 2, 4, 6 ou 8) et l'utilser comme indice dans SV[4] pour pointer vers le bon décalage.

Code:
SV[5] = (SV[3] / 2) - 1
Avec cette formule je change la direction du héros en indice utilisable

Code:
SV[6] = SV[0] + SV[4][SV[5]][0]
SV[7] = SV[1] + SV[4][SV[5]][1]
Maintenant que j'ai mon indice il ne me reste plus qu'à l'utiliser dans le tableau et l'ajouter au X de l'event.

Par exemple :
Si l'event regarde en bas, la commande
Code:
SV[3] = event_direction(SV[2])
Stockera 2 dans SV[3] puis
Code:
SV[5] = (SV[3] / 2) - 1
Prend cette valeur et stocke "0" dans SV[5] (2/2-1 = 0)
SV[4][SV[5]]va donc retourner le sous-tableau à l'index 0 et [0] en sélectionnera la première valeur(0), de même que [1] en prendra la seconde (1)
Du coup pour SV[6], j'ai la position en X de l'event + 0 = sa position X, et pour SV[7], j'ai la position en Y de l'event + 1 = la case en dessous.

Donc avec ces deux données je pointe la case en j'ai la case juste en dessous de l'event quand il regarde en bas, plutôt cool ^^

Voir le profil de l'utilisateur
@Hellper a écrit:SV[5] = (SV[3] / 2) - 1

Sa c'est tout con mais c'est l’idée du siècle !

Voir le profil de l'utilisateur
Tu devrais utiliser l'event printer histoire d'éviter d'avoir des screens tous dégeux comme ça :O

Voir le profil de l'utilisateur
En effet c'est pratique, ça donne ça :

Event - SuisChemin
| > Appeler Script : SV[2] = me
| > Appeler Script : SV[0] = event_x(SV[2])
| > Appeler Script : SV[1] = event_y(SV[2])
| > Appeler Script : SV[3] = event_direction(SV[2])
| > Appeler Script : SV[4] =  [[0, 1], [-1, 0], [1, 0], [0, -1]]
| > Appeler Script : SV[5] = (SV[3] / 2) - 1
| > Appeler Script : SV[6] = SV[0] + SV[4][SV[5]][0]
| > Appeler Script : SV[7] = SV[1] + SV[4][SV[5]][1]
| > Condition : Script : terrain_tag(SV[6], SV[7]) == 1
| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| > Déplacer évènement : > Un pas en Avant
| >| > Aller à l'Étiquette : FIN
| >| >
| > Fin - Condition
| > Commentaire : S'il peut se déplacer en bas.
| > Condition : Script : event_direction(SV[2]) != 8
| >| > Condition : Script : terrain_tag(SV[0], SV[1]+1) == 1
| >| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| >| > Déplacer évènement : > Un pas vers le Bas
| >| >| > Aller à l'Étiquette : FIN
| >| >| >
| >| > Fin - Condition
| >| >
| > Fin - Condition
| > Commentaire : S'il peut se déplacer en à droite.
| > Condition : Script : event_direction(SV[2]) != 4
| >| > Condition : Script : terrain_tag(SV[0]+1, SV[1]) == 1
| >| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| >| > Déplacer évènement : > Un pas vers la Droite
| >| >| > Aller à l'Étiquette : FIN
| >| >| >
| >| > Fin - Condition
| >| >
| > Fin - Condition
| > Commentaire : S'il peut se déplacer à gauche.
| > Condition : Script : event_direction(SV[2]) != 6
| >| > Condition : Script : terrain_tag(SV[0]-1, SV[1]) == 1
| >| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| >| > Déplacer évènement : > Un pas vers la Gauche
| >| >| > Aller à l'Étiquette : FIN
| >| >| >
| >| > Fin - Condition
| >| >
| > Fin - Condition
| > Commentaire : S'il peut se déplacer en haut.
| > Condition : Script : event_direction(SV[2]) != 2
| >| > Condition : Script : terrain_tag(SV[0], SV[1]-1) == 1
| >| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| >| > Déplacer évènement : > Un pas vers le Haut
| >| >| > Aller à l'Étiquette : FIN
| >| >| >
| >| > Fin - Condition
| >| >
| > Fin - Condition
| > Étiquette : FIN
| >

Edit : Par contre ça rend pas super XD

Voir le profil de l'utilisateur

Joke

avatar
Admin
J'ai corrigé le CSS... x)

L'exercice est intéressant et ta solution est très pertinente, merci d'avoir présenté et décrit ce que tu as fait !

J'ai tenté de faire la même chose, mais avec "changer direction", genre, s'il ne peut pas avancer, il essaie de voir à sa propre droite s'il peut, sinon, il se retourne jusqu'à pouvoir :

Event - EV002
| > Boucle
| >| > Appeler Script : SV[1] = event_x(me)
| >| > Appeler Script : SV[2] = event_y(me)
| >| > Appeler Script : SV[1] += 1 if event_direction(me) == 6
| >| > Appeler Script : SV[1] -= 1 if event_direction(me) == 4
| >| > Appeler Script : SV[2] += 1 if event_direction(me) == 2
| >| > Appeler Script : SV[2] -= 1 if event_direction(me) == 8
| >| > Condition : Script : terrain_tag(SV[1], SV[2]) == 1
| >| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| >| > Déplacer évènement : > Un pas en Avant
| >| >| > Opération : Interrupteur local A = Désactivé
| >| >| >
| >| > Sinon
| >| >| > Condition : Interrupteur local A == Activé
| >| >| >| > Déplacer évènement : Cet événement (Attendre la fin)
| >| >| >| > Déplacer évènement : > Quart de tour à Droite
| >| >| >| >
| >| >| > Sinon
| >| >| >| > Déplacer évènement : Cet événement (Attendre la fin)
| >| >| >| > Déplacer évènement : > Quart de tour à Gauche
| >| >| >| > Opération : Interrupteur local A = Activé
| >| >| >| >
| >| >| > Fin - Condition
| >| >| >
| >| > Fin - Condition
| >| >
| > Fin - Boucle
| >

Là avec le code ci-dessus, ça fonctionne, sauf qu'on voit l'événement tourner une fois à droite puis deux fois vers la gauche quand il ne peut pas tourner à droite, et c'est ridicule.

En refaisant la même chose, mais avec une direction virtuelle (indexée comme je veux), là ça passe bien, puisqu'il tourne virtuellement (donc, pas visiblement) :

Event - EV002
| > Boucle
| >| > Appeler Script : SV[1] = event_x(me)
| >| > Appeler Script : SV[2] = event_y(me)
| >| > Appeler Script : SV[2] += 1 if SL[:destination] == 0 #bas
| >| > Appeler Script : SV[1] -= 1 if SL[:destination] == 1 #gauche
| >| > Appeler Script : SV[2] -= 1 if SL[:destination] == 2 #haut
| >| > Appeler Script : SV[1] += 1 if SL[:destination] == 3 #droite
| >| > Condition : Script : terrain_tag(SV[1], SV[2]) == 1
| >| >| > Appeler Script : move_to(me, SV[1], SV[2], true)
| >| >| > Opération : Interrupteur local A = Désactivé
| >| >| >
| >| > Sinon
| >| >| > Condition : Interrupteur local A == Activé
| >| >| >| > Appeler Script : SL[:destination] -= 1
| >| >| >| > Appeler Script : SL[:destination] %= 4
| >| >| >| >
| >| >| > Sinon
| >| >| >| > Appeler Script : SL[:destination] += 1
| >| >| >| > Appeler Script : SL[:destination] %= 4
| >| >| >| > Opération : Interrupteur local A = Activé
| >| >| >| >
| >| >| > Fin - Condition
| >| >| >
| >| > Fin - Condition
| >| >
| > Fin - Boucle
| >



Je sais que la commande move_to passe par un pathfinding, et donc qu'il serait peut-être préférable de faire quatre conditions pour dire directement "déplacer direction X", mais je me suis dit qu'une chemin d'une case en avant devait se calculer assez rapidement. ^^

Ma proposition gère les demi-tours aussi :

Voir le profil de l'utilisateur
Merci pour la partage :)
Du coup ça m'a donné envie de m'y remettre un peu et j'ai pondu une nouvelle version qui gère le demi-tour en reprenant le principe de tableau de tableaux que j'avais avant mais en pus poussé. Par forcément le meilleur code mais j'aimais bien faire comme ça ^^
Et j'ai mis une lambda, donc c'est cool : D

Event - SuisChemin
| > Appeler Script : SV[0] = event_x(me)
| > Appeler Script : SV[1] = event_y(me)
| > Appeler Script : SV[2] = lambda{|tab|[SV[0] + tab[SV[5]][0], SV[1] + tab[SV[5]][1]]}
| > Appeler Script : SV[3] = event_direction(me)
| > Appeler Script : #En face
| > Appeler Script : SV[4] =  [[0, 1], [-1, 0], [1, 0], [0, -1]]
| > Appeler Script : #A droite
| > Appeler Script : SV[7] =  [[-1, 0], [0, -1], [0, 1], [1, 0]]
| > Appeler Script : #A gauche
| > Appeler Script : SV[8] =  [[1, 0], [0, 1], [0, -1], [-1, 0]]
| > Appeler Script : #Derriere
| > Appeler Script : SV[9] =  [[0, -1], [1, 0], [-1, 0], [0, 1]]
| > Appeler Script : SV[5] = (SV[3] / 2) - 1
| > Appeler Script : SV[6] = SV[2].call(SV[4])
| > Condition : Script : terrain_tag(SV[6][0], SV[6][1]) == 1
| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| > Déplacer évènement : > Un pas en Avant
| >| > Aller à l'Étiquette : FIN
| >| >
| > Fin - Condition
| > Appeler Script : SV[6] = SV[2].call(SV[7])
| > Condition : Script : terrain_tag(SV[6][0], SV[6][1]) == 1
| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| > Déplacer évènement : > Quart de tour à Droite
| >| > Déplacer évènement : > Un pas en Avant
| >| > Aller à l'Étiquette : FIN
| >| >
| > Fin - Condition
| > Appeler Script : SV[6] = SV[2].call(SV[8])
| > Condition : Script : terrain_tag(SV[6][0], SV[6][1]) == 1
| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| > Déplacer évènement : > Quart de tour à Gauche
| >| > Déplacer évènement : > Un pas en Avant
| >| > Aller à l'Étiquette : FIN
| >| >
| > Fin - Condition
| > Appeler Script : SV[6] = SV[2].call(SV[9])
| > Condition : Script : terrain_tag(SV[6][0], SV[6][1]) == 1
| >| > Déplacer évènement : Cet événement (Ignorer action impossible, Attendre la fin)
| >| > Déplacer évènement : > Demi tour
| >| > Déplacer évènement : > Un pas en Avant
| >| > Aller à l'Étiquette : FIN
| >| >
| > Fin - Condition
| > Étiquette : FIN
| >

Voir le profil de l'utilisateur

9

Contenu sponsorisé


Voir le sujet précédent Voir le sujet suivant Revenir en haut  Message [Page 1 sur 1]

Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum