Problème avec la gravité du langage simplifié de Java "processing"

Version imprimable

Bonjour,

Je rencontre un problème avec le langage simplifié de Java.

Il s'agit de la gravité, si je peux l'appeler comme ça...

Pour être plus précis, j'arrive à faire sauter mon personnage avec la touche du clavier up mais pas à le faire retomber sur sa position initiale.

Voilà mon script
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 PImage persobis; int x = 100 ;int y = 100; void setup() { persobis = loadImage("persobis.png"); size(900,500); } void draw() { background(200); image(persobis,x,y,100,100); } void keyPressed() { if (key == CODED){ if (keyCode == LEFT) x = x - 5; if (keyCode == RIGHT) x = x + 5; if (keyCode == UP) y = y - 5; if (keyCode == DOWN) y = y + 5; } }
Quelqu'un saurait-il m'indiquer comment faire ?

Merci d'avance pour votre aide.

13/03/2016, 00h01
lankoande

Bonsoir

De cette manière je ne pense pas qu'on puisse trouver une solution à ton soucis.

Ton code est incomplet, si tu veux bien poster la classe en entier dans laquelle se fait l'opération.

çà va beaucoup guider :D !

__salut !
14/03/2016, 07h25
nico vdl

Merci lankoande mais je ne comprends pas trop ce que tu veux me dire par là, que veux-tu dire par poster la classe entier ?
14/03/2016, 16h45
joel.drigo

Salut,

Le problème c'est que tu es sur un forum Java, pas Processing. Je ne suis pas sûr qu'il y ait des classes en Processing : le but étant de "simplifier" (si tant est que ça simplifie quoique ce soit de supprimer les classes), je suppose qu'il n'y a pas de classes explicitement définies en Processing.

Ensuite, en Java, le genre de traitement que tu voudrais faire ne pourrait se faire avec un seul processus : en général, on a une file et le processus de traitement d'évenements poste des évènements sur cette file, qui est traitée dans son propre processus (ainsi quand on appuie sur une touche, le personnage ne se déplace pas seulement d'un coup, mais se déplace continuellement vers une direction, jusqu'à ce qu'on l'arrête (une condition de collision par exemple, ou un autre évènement clavier)). Ce processus "sait" (on le programme pour ça) que le personnage doit toujours "descendre" jusqu'au sol : ainsi s'il n'y a pas d'évènements contraire (par exemple, "en train de sauter") dans la file, le personnage va retomber. L'intérêt d'avoir une file dans un process à part est surtout que le personnage (ou les ennemis d'ailleurs) peut faire des actions indépendamment d'entrée utilisateur, ce qui est le cas quand le personnage "tombe". Si on ne se base que sur les évenments du clavier, comme il n'y a pas d'évènements ("pas de touche appuyée"), on ne peut pas le faire dans un simple processus évenementiel.

Et ne connaissant pas Processing, je ne peux te guider vers la solution : essaye de voir sur le site dans les différents exemples, un exemple qui pourrait être similaire, avec quelque chose qui se déplace, même lorsqu'on appuie par sur une touche du clavier.
14/03/2016, 19h18
nico vdl

Ok merci beaucoup.

Sinon, peux-tu me dire à quoi ressemble un fill en Java ? Vu que beaucoup de code Java correspondent à processing, ça pourrait peut-être m'aider...
15/03/2016, 13h51
wax78

Citation:

Envoyé par joel.drigo

Je ne suis pas sûr qu'il y ait des classes en Processing

Si si, tu peux en faire ;)
15/03/2016, 14h25
joel.drigo

Citation:

Envoyé par nico vdl

une drn question tu peux me dire a quoi ressemble un fill en java vu que bcp de code java correspondent a processing ca pourrait ptetre m aider :D

Une file, pas un fil. On oppose les files et les piles : ils s'agit tout d'abord de listes. Dans le cas d'une pile, la liste est dite LIFO (Last In First Out = le dernier dedans, le premier dehors), alors que pour une file, la liste est dite FIFO (First In First Out = le premier dedans, le premier dehors). Dans le fonctionnement général, un processsus (ou des processus) produisent des éléments et les mettent dans la file (ou la pile le cas échéant). Un autre processus (ou plusieurs) va chercher les éléments dans la file et les traite. Dans le cas d'une file, donc, les éléments sont traités dans l'ordre d'ajout.
Donc en résumé, il s'agit d'une liste associée à au moins un processus indépendant qui traite les éléments dans la liste dans l'ordre dans lequel ils ont été ajoutés dans la liste.
Une file évènementielle contient des évènements. En Java, il y a la classe java.awt.EventQueue, mais il est plutôt prévu pour ne traiter que les évènements d'IHM (après tu dois pouvoir produire un évènement qui correspond à l'écoulement du temps avec un Timer qui produit des ActionEvent), mais je développerais plutôt ma propre classe personnellement (principalement pour contrôler le temps).

Si tu veux plus d'informations sur le concept, cherche dans ton moteur de recherche préféré : "gaming eventqueue".
15/03/2016, 19h37
nico vdl

du genre
file FIFO(){
timer = 2 sec
pour cree une notion de temps ?
16/03/2016, 12h44
joel.drigo
Je ne connais pas Processing, mais ça m'étonnerait qu'il suffise de taper juste çà pour faire la file.

Le principe général, c'est qu'au lieu de traiter directement les évènements dans des écouteurs, on les envoie dans la file, éventuellement en les convertissant.

Par exemple, on a un écouteur du clavier, qui traite des KeyEvent, et un timer (javax.swing.Timer) qui produit des ActionEvent, qui servent de base temporelle.

Chaque fois que l'écouteur clavier reçoit un évenement clavier, il le convertit en action de déplacement par exemple (appui sur la touche flêche droite (ou sur D, ou autre...) donne l'action se déplacer vers la droite), ou en action sauter sur une autre touche... et pose cette action dans la file. L'actionListener du timer lui pose des actions "le temps vient de s'écouler de x ms") à intervalle régulier (compromis entre pouvoir faire des actions rapides et fluides, et la puissance de la machine et les contraintes de temps d'exécution...).

Le consommateur de la lfile (un processus parallèle= un Thread en Java par exemple) prend les actions qui sont dans la file...
- s'il voit un évenement "aller à droite", il modifie la direction du personnage pour que lorsqu'on va traiter le déplacement du personnage, il va se déplacer à droite. par exemple, on peut avoir une variable dx, qu'on met à 1 (le personnage se déplace de 1 pixel à droite), ou alors on veut faire un personnage qui va de plus en plus vite, alors on va faire quelque chose dans le genre :
  if ( dx<10 ) dx++ : à chaque fois qu'on va appuyer sur la touche, le perso ira de plus en plus vite.
- s'il voit un évènement "sauter", il modifie l'état de personnage, pour qu'il soit en état de sauter. (un état c'est une variable)
- quand il voit une action "temps", alors il réalise tout ce qu'il faut faire pour "avancer" dans le temps :
  - déplacer le personnage : x = x + dx...
  - traiter les états : si l'état sauter est actif, alors y = y + quelque chose, si y>hauteur max de saut, état sauter devient état "en train de tomber". si l'état est "en train de tomber", et que y> y du sol, alors il faut retomber, donc on fait y-vitesse de chute (qui dépend de si on veut simuler une gravité terrestre réelle, ou lunaire, ou exagérée, ou molle...), et dès qu'on atteint le sol, on passe en état "normal". Ainsi, on peut facilement empêcher le personnage de sauter pendant qu'il tombe, ou s'arranger pour qu'il saute différemment (moins haut, plus haut, peu importe). On peut aussi avoir un état "tomber après saut" et "tomber" différent, selon qu'on veuille gérer ça différemment selon qu'on tombe d'une falaise, ou qu'on retombe après un saut.
  La difficulté et que tous les traitements réalisés sur l'action de temps doivent être fait dans un temps limité : c'est ce temps qui définira le frame rate de ton jeu (s'il tourne en 30FPS, en 60PFS...ou en 2FPS...)... mais ça aura aussi l'avantage de contrôler le temps, quelque soit les performances de la machine (si la machine va 100 fois plus vite que la tienne, un ennemi par exemple ne se déplacera pas 100 fois plus vite heureusement, sinon ce sera injouable).
16/03/2016, 12h55
nico vdl

Merci pour tes explications.

Y aurait-il moyen que tu me montres un de tes scripts où tu utilises ce système ?
04/04/2016, 17h10
joel.drigo

Non, je n'ai pas de script à te montrer (voir plus haut : je ne connais pas processing). Et je n'ai pas le temps en ce moment d'écrire un programme Java pour te montrer comment faire ça en Java (si ça peut être utile même). Je t'ai fourni un lien qui parle du sujet : cela devrait suffire.

En attendant, je t'ai retrouvé cette discussion.
Il n'y a pas de file évènementielle, parce qu'il n'y a que 2 états : on bouge ou on bouge pas. Mais l'idée générale est déjà présente. Tu verras que l'appui sur les touches du clavier ne bouge pas le mobile : elles ne font que positionner des variables qui serviront au timer à bouger le mobile. Ainsi, le mobile se déplace toujours à la même "vitesse" (on peut faire varier l'incrément, mais pas le nombre de fois que l'incrément est appliquée par seconde : ainsi, même si la machine d'exécution est 100 fois plus rapide que la machine de développement, le mobile se déplacera à la vitesse voulu par le développeur).
Maintenant, si on devait ajouter par exemple une touche pour sauter, on pourrait réaliser la même chose : (on suppose qu'on supprime le déplacement vertical et on le remplace par un saut)
on positionne une variable (mettons saut) qui permet de modifier y pour que le mobile monte (par exemple, quand j'appui sur espace, je fais saut = 5)
on doit faire que la valeur de cette variable s'inverse pour que le mobile retombe à un moment donné
pour ça il faudrait encore ajouter des variables et les contrôler en fonction du temps.
le timer par exemple va faire (ici on ne simule pas la gravité, on fait un truc qui ressemble : le mobile monte vite d'abord, de moins en moins vite et quand il atteint une certaine hauteur il retombe de plus en plus vite)
Code:

1 2 3 4 5 6 7 8 9 10 si saut!=0 alors p1.y +=saut si p1.y <sol alors (sol est une variable qui contient la valeur considéré comme le sol : bien sûr on peut complexifier en déterminant cette valeur par rapport à une map) // si on veut on peut ajouter ici un test du genre (si saut<-10 alors mort du personnage : il est tombé beaucoup trop vite et s'écrabouille sur le sol), p1.y =sol saut=0 sinon saut-- fin si fin si
Mais ça commence à faire beaucoup de variables au même endroit : imagine qu'on ajoute une touche pour ouvrir un parachute pour éviter de s'écrabouiller si on retombe trop vite, il faudrait encore une variable de plus pour pouvoir faire que saut ne descende pas en dessous d'une certaine valeur...etc.
La file évènementielle va permettre d'avoir des états (des classes/des instances) qui vont avoir leur propre jeu de variables et isoler chaque type d'action (avancer, sauter, tomber, tirer, etc...), au lieu d'avoir 50 variables au même endroit (et des tests correspondant dans tous les sens en plus). En gros, c'est ça le principe.