Besoin d'aide dans mon code [Résolu]

Démarré par jibtou, 24 Octobre 2013 à 18:17

0 Membres et 1 Invité sur ce sujet

24 Octobre 2013 à 18:17 Dernière édition: 24 Octobre 2013 à 22:10 par jibtou
Salut tout le monde :)

Voilà, j'ai un petit utilitaire en script sur rpg maker xp qui me permet de générer des particules. Je l'ai modifier pour pouvoir faire tout un tas de truc avec (rotation des sprites, vitesse des particules, tailles/variation de taile, etc..)
cependant j'ai besoin de vous pour un problème qui ne relève pas du ruby mais bien... des mathématiques  :chepa:
Oui, je suis une brèle en math  :linkXD:
Bref:
Dans mon code j'ai une première fonction qui définit tous les paramètres de la particules, une deuxième qui défini la position de départ et qui génère la particule, une dernière qui joue le role de l'update et qui l'actualise jusqu'à sa disparition de l'écran.
Me première fonction ressemble à ça:
random = rand(4)
     case random
     when 0
     sprite='Dark Particles1'
     when 1
     sprite='Dark Particles1'
     when 2
     sprite='Dark Particles2'
     when 3
     sprite='Dark Particles3'
     when 4
     sprite='Dark Particles4'
     end
     
     dx = ********* ce qui me pose problème*******
     dy = ********* ce qui me pose problème*******
     
 
     add_particles(object, x, y, z, sprite, [dx, dy], [gravité x, gravité y], [opacité de départ, décroissance de l'opacité], lock, 0, vitesse de rotation sur elle même, increase de taille, taille d'origine)


Voilà mon problème: je compte faire en sorte que le script génère (grâce à une boucle), un nombre définit de particules qui vont partir chacune dans une direction différente pour former un cercle.
Le souci: j'ai pas suivi mes cours de math de terminale il y a deux ans  ^_^
Dans ma fonction update, la position de ma particule est définie par cette équation:
@coords[0] += @acceleration[0]
@coords[1] += @acceleration[1]
self.x = @origin[0] + @coords[0]
self.y = @origin[1] + @coords[1]


ou @origin[0] est la positionX de base de ma particule
@origin[1] est la positionY de base de ma particule
@acceleration[0] et @acceleration[1] sont les accélérations horizontales et verticales de ma particule définies plus haut comme étant dx et dy.
self.x et self.y seront les positions finales que va prendre ma particule à cet instant.

Il faudrait que via une boucle, les valeurs de dx et dy varient à chaque itération pour que, au bout du compte, on ait généré un certain nombre de particules qui partent toutes avec la même vitesse, la même accélération mais dans une direction différente. Et que leur direction respective soient telles que l'angle entre celles-ci soit égales et que, à la fin du processus, on ait fait un tour complet.

Je pense bien que ce ne doit pas être très compliqué mais ça me semble pas faisable sans des connaissances mathématiques de base  :(

Marrant, ça implique encore la connaissance des coordonnées cartésiennes / polaires. J'en avais parlé dans je ne sais plus quel topic, mais je n'avais pas eu le temps de bien expliquer. Je vais être plus exhaustif ce soir^^. C'est un truc à retenir je pense, c'est assez utile dans la création de jeu vidéo ! Par contre c'est effectivement un peu rébarbatif, mais bon, ce sont des maths :mrgreen:.


Les coordonnées sont très utiles. Elles permettent de gérer la position d'un objet ou son mouvement. Elles consistent en 2 nombres, x et y, c'est-à-dire une distance horizontale et une distance verticale. Il faut aussi savoir qu'une coordonnée est toujours relative à une origine (le point situé en 0,0 (O sur le schéma) ).



Ça, ce sont les coordonnées cartésiennes. Elles permettent de gérer la position d'un objet grâce à 2 variables : x et y. Elles sont assez instinctives, on les connaît bien.

Les coordonnées polaires servent aussi à gérer la position d'un objet, mais de manière différente : elles permettent de gérer la position d'un objet grâce à 2 variables : l'angle et le rayon (θ et r sur le schéma).



C'est typiquement ce dont tu as besoin dans ton cas . Je te laisse gérer la partie programation, il te manque juste la partie mathématiques.

Pour gérer tes déplacements tu utilises des coordonnées cartésiennes. (c'est-à-dire que tu rajoutes une valeur x et une valeur y de façon régulière).
Or, tu as besoin que ces déplacements générés aléatoirement aient la même vitesse, ce qui n'est pas évident avec les coordonnées cartésiennes^^. En revanche, avec c'est beaucoup plus simple avec le système polaire !

Il suffit de préciser le rayon (= ta vitesse de déplacement) et de choisir ton angle, et c'est bon !

Il te faut juste ensuite convertir ça en coordonnées cartésiennes classiques (ton dx et ton dy). La formule est:
- valeur x = r * cos(A)
- valeur y = r * sin(A)

Où:
- A est ton angle en radians (Angle en radian = Pi * (angle en degré) / 180 )
- r est le rayon voulu

Tu connais ainsi ton déplacement x et y correspondant. De cette façon, tu pourras générer des déplacements de vitesse constante dans des directions différentes (il suffit de faire varier l'angle).

J'espère t'avoir aidé ! Bon courage pour implémenter ça, c'est assez simple une fois qu'on a pris le coup :).

Merci beaucoup, c'est très clair!!  :D

Je me sens un peu idiot parce que c'est tout bête en fait, je fais des trucs bien plus compliqués pendant mes cours de physique mais dès que ça ressemble à des maths pure de près ou de loin je bute  :linkXD:
Je n'avais juste pas pensé à user des cosinus et sinus pour arriver à mes fins :p

Je vais essayer de l'appliquer, ça n'a pas l'air bien compliqué à coder!

Merci encore, je ferai un double post pour dire si ça a marché ou bien si je vois un problème, histoire d'être sûr que la réponse soit vue :)

Ça marche du tonnerre !
Ça rend très biene t je peux rendre le cercle de partcules plus ou moins dense en changeant juste la valeur d'une variable :) J'en ai profité pour rajouter une décroissance d'opacité exponentielle pour un rendu plus réaliste... ça rend bien  ^_^

Merci beaucoup pour cette très belle idée :)
Je rajoute résolu dans le titre  :super: