Discussion :

[nico vdl]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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 !

__salut !

[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 ?

[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.

[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...

[wax78]

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

Si si, tu peux en faire

[joel.drigo]

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

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".

[nico vdl]

du genre
file FIFO(){
timer = 2 sec
pour cree une notion de temps ?

[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).
  

[nico vdl]

Merci pour tes explications.

Y aurait-il moyen que tu me montres un de tes scripts où tu utilises ce système ?

[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.

[joel.drigo]

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 pseudocode :

  Sélectionner tout - Visualiser dans une fenêtre à part

  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.