Bonjours à tous, je suis nouveau sur ce forum et m'y suis inscrit car débutant pas doué en programmation.
j'ai suivi quelques tuto pour utiliser processing mais je n'est pas réussi à trouver comment réaliser un déplacement aléatoire. Je suis capable de faire rebondir un objet sur les bords de la fenêtre mais je vois pas comment faire en sorte qu'il est un mouvement aléatoire fluide sur l'ensemble de la fenêtre (comme un explorateur).
Si quelqu'un veut bien me filer un coup de main
Hum, il faudrait expliciter un peu plus. Tu veux dire, que l'objet se déplace de façon "aléatoire" dans une zone de l'écran?
Ce que tu peux faire :
1) Tirer au hasard un point dans la zone
2) Faire avancer l'objet vers ce point jusqu'à l'atteindre
3) Retour à l'étape 1)
C'est la base. Mais une fois que tu aura fait ça, tu pourra affiner le comportement
Salut Tryss2, d'abord merci de prendre le temps de me répondre!
J'ai eu plus ou moins la même idée que toi, je te link mon code car étant début, je pense qu'il est fort probable de l'améliorer...
n'hésite pas à me faire des remarques. Je vais réfléchir à la suite, mais déjà, je trouve pas très naturel le mouvement ...Code:#variable cote = 15 posx = 0 posy = 0 nposx = 0 nposy = 0 #initialisation def setup(): global cote size(300,300) background(255) rectMode(CENTER) rect(width/2, height/2, cote, cote) #boucle def draw(): global posx, posy, cote, nposx, nposy frameRate(50) background(255) rectMode(CENTER) rect(posx, posy, cote, cote) if posx == nposx : nposx = int(random((cote/2),width-(cote/2))) if posy == nposy : nposy = int(random((cote/2),height-(cote/2))) if posx < nposx : background(255) posx = posx+int(random(1,5)) rectMode(CENTER) rect(posx, posy, cote, cote) if posx > nposx : background(255) posx = posx-int(random(1,5)) rectMode(CENTER) rect(posx, posy, cote, cote) if posy < nposy : background(255) posy = posy+int(random(1,5)) rectMode(CENTER) rect(posx, posy, cote, cote) if posy > nposy : background(255) posy = posy-int(random(1,5)) rectMode(CENTER) rect(posx, posy, cote, cote)
Ton mouvement n'est pas naturel pour 2 raisons principales :
1) la vitesse de ton rectangle est aléatoire à chaque affichage
2) ta vitesse sur chaque axe ne dépend pas de la direction de l'objectif
Et la plupart du temps, tu choisi un nouvel objectif avant d'avoir atteint le précédent.
Maintenant, remarques/idée/indication principale :
1) Faire des fonctions
Il te faut :
une fonction atDestination() : elle renvoie vrai ou faux si tu le rectangle est arrivé à destination
une fonction moveToward(destx, desty, speed) : elle fait avancer le rectangle vers la destination
une fonction newDestination() : elle génère un nouveau point de destination
2) Petit point mathématique :
Un objet qui part du pointse retrouve au point
Avec
(
Ou, en coordonnées
Fin de la partie mathématique
Ceci te permettra d'avoir un mouvement à vitesse constante dans n'importe quelle direction
Salut Tryss2 !
Je vais essayer de réfléchir à cette histoire de fonction en plus.
Coté math, j'ai déjà réalisé plus code qui utilise les coordonnées (et pour celui ci aussi). Je crois que j'ai enlevé l'usage des coordonnées car je n'avais pas réussi à lui dire de partir sur une autre cible une fois la coordonnée atteinte... il ne réalisé donc que des rebonds ou pire dérivait vers l'infini emportant avec lui mon enthousiasme. Bref j'avais trouvé cette solution pour le faire bouger.
Petite précision :
pour la variabilité de la vitesse de déplacement, c'était volontaire. Une fourmi ne se déplace pas à vitesse constante (n'y rien d'organique je pense au moins). Mais le random(0,5) est un peu trop violent, j'ai regardé avec (0,2) c'est smooth. Le truc, c'est que j'aurais peut être (hypothèse pour le moment) souhaiter que entre le point A et B, il aille à droite ou a gauche de temps à autre histoire de simuler un libre arbitre (du style : "tiens y'a quoi par la, bon en fait rien d'interréssant")
Petite questions :
1 : J'ai pas vérifié mais il me semblait logique que le carré atteigne la nouvelle position avant de partir sur une autre (un petit print pour vérif s'impose).
2 : J'ai un peu modifié le code (rien de ouf hein) pour le rendre plus propre et surtout pouvoir faire appel à plusieurs carrés ... Mais quelle désillusion quand je n'ai pas vu plusieurs carrés apparaitre, je suppute que les carrés sont superposés les uns sur les autres. Est-ce bien le cas? Si oui, un randomSeed pourra t'il me venir en aide? Je vais travailler ( quand j'aurais un peu de temps libre ) sur tes indication mais je profite de ce que j'ai déjà pour approfondir.
3 : dans le code ci joint, j'ai fait une class mais je n'arrive pas à l'externaliser (sur processing) aurais-tu quelques tuyaux ?
Merci en tout cas.
Code:class mobile(): def __init__(self,x,y,cote): self.x = x self.y = y self.nposx = int(random((cote/2),x-(cote/2))) self.nposy = int(random((cote/2),y-(cote/2))) self.posx = int(random((cote/2),x-(cote/2))) self.posy = int(random((cote/2),y-(cote/2))) self.cote = cote def mob_aff(self): if self.posx < self.nposx : background(255) self.posx = self.posx+int(random(1,2)) rectMode(CENTER) rect(self.posx, self.posy, self.cote, self.cote) if self.posx > self.nposx : background(255) self.posx = self.posx-int(random(1,2)) rectMode(CENTER) rect(self.posx, self.posy, self.cote, self.cote) if self.posy < self.nposy : background(255) self.posy = self.posy+int(random(1,2)) rectMode(CENTER) rect(self.posx, self.posy, self.cote, self.cote) if self.posy > self.nposy : background(255) self.posy = self.posy-int(random(1,2)) rectMode(CENTER) rect(self.posx, self.posy, self.cote, self.cote) def mob_dep(self): if self.posx == self.nposx : self.nposx = int(random((self.cote/2),self.x-(self.cote/2))) if self.posy == self.nposy : self.nposy = int(random((self.cote/2),self.y-(self.cote/2))) print(self.posx, self.nposx) l = [] for i in range(10): carre = mobile(300, 300, 15) l.append(carre) def setup(): size(300,300) background(255) print(l) #boucle def draw(): global carre frameRate(50) carre.mob_aff() carre.mob_dep()
Je t'avouerai que je ne peux pas t'aider pour processing, jamais utilisé (et, soyons francs, la flemme d'installer ça
Et ici, c'est normal que tu n'ai qu'un carré d'affiché sur ce code, ta liste l contient les carrés que tu crées, mais tu n'utilises pas cette liste dans ta fonction draw !
Sinon, en fait tu choisi un nouveau nposx quand pox=npox, mais tu n'as pas atteint le point (nposx ; nposy) avant de te rediriger vers un autre point (nposx2 ; nposy).
Je te conseillerai d'avoir un code qui va "en ligne droite" d'abord. Après tu peux le réutiliser en créant un chemin avec une liste de points de passage, puis tu va de point en points. Et après, on peut même imaginer faire des virages "souples", et des accélérations/ralentissements "naturels" (tu va vite te rendre compte que le pur hasard "random" ça fait rarement organique). L'idée, c'est qu'une fois que tu as toutes les fonctions pour que ton mobile se déplace, tu peut te poser la question "comment je veux qu'il se ballade"
Enfin, dernier truc : si tu comptes vraiment te mettre à la programmation, utilise un environnement de développement (IDE) avec un débuggeur. Tu gagnera beaucoup de temps (et ça évite de rajouter des printf de débug tout moches)
Si tu cherches à produire des mouvements plus naturels, alors une idée est de copier les équations physiques. Par exemple ci-dessous devrait produire un "mouvement passif" naturel (code non vérifié), et à partir de là ajouter des mouvements actifs peut se faire en réfléchissant directement sur les accélérations (i.e. les produits d'une force).
Code:class monNewton(): def __init__(self, cote = 15, px = 0, py = 0, vx = 0, vy = 0, gv = 9.81, rb = 0.9) self.cote = cote # cote du carré à dessiner self.px, self.py = px, py #positions self.vx, self.vy = vx, vy #vitesses self.gv, self.rb = gv, sqrt(rb) # gravité et amortissement des rebonds def maj(self, tps, min_x, max_x, min_y, max_y): #positions self.px += vx * tps self.py += vy * tps #vitesses (ici uniquement affectée par gravité) self.vy += gv * tps # vitesses bis (to do: ajouter accélérations actives) #rebonds if self.px > max_x: self.px = max_x - self.rb * ( self.px - max_x ) self.vx = (-1) * self.rb * self.vx if self.px < min_x: self.px = min_x + self.rb * ( min_x - self.px ) self.vx = (-1) * self.rb * self.vx if self.py > max_y: self.py = max_y - self.rb * ( self.py - max_y ) self.vy = (-1) * self.rb * self.vy if self.py < min_y: self.py = min_y + self.rb * ( min_y - self.py ) self.vy = (-1) * self.rb * self.vy return self.px, self.py, self.cote, self.cote # return something one can use in rect() def set_random(cote, width, height): x = int(random((cote/2),width-(cote/2))) y = int(random((cote/2),height-(cote/2))) vx = int(random((cote/2),width-(cote/2))) - x vy = int(random((cote/2),height-(cote/2))) - y return cote, x, y, vx, vy # one of the reasons why a class is such a good idea boule1 = monNewton(set_random(15, 300, 300)) boule2 = monNewton(set_random(15, 300, 300)) boule3 = monNewton(set_random(15, 300, 300)) while True: frameRate(50) # 50 Hz = 1000 / 20 ms background(255) rectMode(CENTER) rect(boule1.maj(20, 0, 300, 0, 300)) # tps, min_x, max_x, min_y, max_y rect(boule2.maj(20, 0, 300, 0, 300)) rect(boule3.maj(20, 0, 300, 0, 300))
@Jiav : j'ai plus l'impression qu'il était intéressé par un mouvement en "vue de dessus", et pas en "vue de coté". Dans ce cas, gérer les accélérations d'un point de vue physique est moins nécessaire
Merci à tout les deux, je vais pas avoir trop de temps pendant au moins 2 semaines mais je regarderai ton code Jiac par curiosité (bien que je pense pas être assez familier du code pour bien comprendre) mais effectivement, je suis pas intéressé par des accélérations ou bien la gravité comme précise Tryss2. Je suis effectivement plus intéressé par la vue de dessus!
Tryss2, ça semble tellement logique effectivement qu'il faille faire entrer la liste dans draw... mais dans ma tête, c'était automatique
Je viens de rajouter ça :
Mais pas plus de carré...Code:def draw(): global carre, l frameRate(50) for carre in l: carre.mob_aff() carre.mob_dep()
Pareil pour le coup du nposx... Bon je vais voir ce que je peux faire pour modifier ça (cependant je pense ne pas préférer qu'il se déplace en ligne droite mais je vais essayer quand même)
Enfin je vais regarder ce que tu appelles un IDE (peut être "sublime text"? )
Bonjour,
Il est possible de considérer que la destination (Xo, Yo) est un attracteur. Si (X, Y) est la position actuelle et (dX, dY) est la vitesse (dT est symbolisé par une itération) l'attracteur modifiera la vitesse (accélération) : dX = a*dX + b*(Xo-X) et dY = a*dY + b*(Yo-Y). La nouvelle position est alors X = X+dX et Y=Y+dY. Les coefficients a (inertie) et b (attraction) sont inférieurs à 1 et supérieur à 0. Il est préférable travailler en réels et ne convertir en entier que la position affichée.
En jouant avec a et b les trajectoires seront plus ou moins courbes (avec l'inertie donnée par a, elles peuvent même sortir de la zone avant de revenir).
Le choix d'un nouvel objectif (aléatoire) ne se fait que lorsque le précédent est atteint.
On peut également multiplier les carrés, puis un jour gérer les collisions
Salutations
Bonjour,
En complément, le mouvement n'est pas réaliste puisque l'accélération est d'autant plus grande que la distance l'est (un peu comme un train qui ne ralentit qu'a l'approche en gare) mais il n'y a pas de risque de satellisation (tourner autour de l'objectif sans jamais l'atteindre) ou d'évasion (libération).
Salutations
