Problème d'animation d'une chenille

**DarkSeiryu** · 18/10/2009, 13h40

Bonjour tout le monde !

Voilà mon souci. Je dois réaliser ce TP. Pour ceux qui n'auraient pas envie de lire (c'est long quand même), il s'agit de créer une chenille sous forme d'anneau et de la faire se déplacer selon un cap.
Avec mon code actuel, j'arrive à afficher la chenille dans une fenêtre, mais elle ne se déplace pas.
Voici mon code :
Classe Anneau

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
32
33
34
35
36
37
import java.awt.*;
 
public class Anneau {
 
	// Attributs.
	protected int xInit; // Abcisse du centre de l'anneau.
	protected int yInit; // Ordonnée du centre de l'anneau.
	protected double r; // Rayon de l'anneau.
 
	// Constructeurs.
	public Anneau(int xInit, int yInit, double r) {
		this.xInit = xInit;
		this.yInit = yInit;
		this.r = r;
	}
 
	// Getteur de x.
	public int getX() {
		return this.xInit;
	}
 
	// Getteur de y.
	public int getY() {
		return this.yInit;
	}
 
	// Positionne le centre de l'anneau en un point donné.
	public void placerA(int px, int py) {
		this.xInit = px;
		this.yInit = py;
	}
 
	// Affiche l’anneau en le matérialisant par un cercle noir.
	public void dessiner(Graphics g) {
		g.drawOval(this.getX(), this.getY(), 50, 50);
	}
}

Classe Tete

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
32
33
34
35
36
37
import java.awt.*;
 
public class Tete extends Anneau {
 
	// Attributs.
	private double cap;
 
	// Constructeurs.	
	public Tete(int xInit, int yInit, int r, double unCap) {
		super(xInit, yInit, r);
		this.cap = unCap;
	}
 
	// Affiche l’anneau en le matérialisant par un cercle noir.
	public void dessiner(Graphics g) {
		g.fillOval(this.getX(), this.getY(), 50, 50);
	}
 
	// Modifier le cap de la tête en lui ajoutant la déviation définie par le paramètre deltaC.
	public void devierCap(double deltaC) {
		this.cap += deltaC;
	}
 
	// Retourne true si le centre de la tête est à une distance <= R de l’un des bords de la fenêtre de taille xMax, yMax.
	// False sinon.
	public boolean atteintBord(int xMax, int yMax) {
		return ((this.getX() + this.r) <= xMax || (this.getY() + this.r) <= yMax);
	}
 
	// Modifie le centre de la tête en lui appliquant un déplacement de longueur R dans la direction définie par le cap.
	public void deplacerSelonCap() {
		int x = this.getX();
		int y = this.getY();
		x = (int) (x + (this.r * Math.cos(this.cap)));
		y = (int) (y + (this.r * Math.sin(this.cap)));
	}
}

Classe Chenille

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
32
33
34
35
36
37
38
39
40
41
42
43
import java.awt.*;
 
public class Chenille {
 
	// Attributs.
	private Tete t;
	private Anneau[] listeA;
	private Dessin d;
 
	// Constructeur.
	public Chenille(Tete uneTete, Anneau[] desAnneaux, Dessin unDessin) {
		this.t = uneTete;
		this.listeA = desAnneaux;
		this.d = unDessin;
	}
 
	// Dessine la chenille.
	public void dessiner(Graphics g) {
		t.dessiner(g);
		for (Anneau a : this.listeA) {
			a.dessiner(g);
			a.placerA(a.getX(), a.getY());
		}
	}
 
	// Fait se déplacer la chenille.
	public void deplacer() {
		if (this.t.atteintBord(d.getLargeur(), d.getHauteur())) {
			this.t.devierCap(90);
			this.t.deplacerSelonCap();
		}
		else {
			double dev = (Math.random() * 30) - (Math.random() * -30);
			this.t.devierCap(dev);
			this.t.deplacerSelonCap();
		}
	}
 
	// Fixe le dessin dans lequel la chenille se déplace.
	public void setDessin(Dessin d) {
		this.d = d;
	}
}

Classe AppliVisage1 : en vrai c'est AppliChenille mais j'ai oublié de changer le nom

C'est marqué en commentaires ce que ça fait

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import javax.swing.JFrame;
import javax.swing.WindowConstants;
 
 
/**
* Animation d'une chenille dans une fenêtre graphique.
* Une chenille est dessiné à l'intérieur d'une fenêtre et se déplace. Chaque fois
* que l'un des bords est atteint, la chenille change de direction.
* @author Philippe Genoud
* @version
*/
 
public class AppliVisage1  {
 
   public static void main(String[] args) {
 
       // La fenêtre graphique.
       JFrame laFenetre = new JFrame("Chenille animée");
       laFenetre.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
       laFenetre.setSize(512,512);
 
       // Créé la zone de dessin et la place dans la fenêtre.
       Dessin d = new Dessin();
       laFenetre.add(d);
 
       // Affiche la fenêtre.
       laFenetre.setVisible(true);
 
       // Création d'un objet Chenille.
       int tx = d.getLargeur() / 2; // Position en x de la tête.
       int ty = d.getHauteur() / 2; // Position en y de la tête.
       Tete t = new Tete(tx, ty, 25, 20);
 
       Anneau[] listeA = new Anneau[4];
	   int ax = d.getLargeur() / 2; // Position en x de l'anneau.
	   int ay = d.getHauteur() / 2; // Position en y de l'anneau.
       for (int i = 0; i < listeA.length; i++) {
    	   ax -= 25;
    	   Anneau a = new Anneau(ax, ay, 25);
    	   listeA[i] = a;
       }
 
       Chenille c1 = new Chenille(t, listeA, d);
 
       // On rajoute cet objet à la zône de dessin.
       d.ajouterObjet(c1);
 
       // La boucle d'animation.
       // C'est une boucle infinie, le programme devra être interrompu
       // par CTRL-C ou en cliquant dans le cas de fermeture de la fenêtre.
       while (true) {
           // La chenille effectue un déplacement élémentaire.
           c1.deplacer();
 
           // La zone de dessin se réaffiche.
           d.repaint();
 
           // Un temps de pause pour avoir le temps de voir le nouveau dessin.
           d.pause(50);
       }
   }   
} // AppliChenille

Classe Dessin : c'est marqué en commentaires ce que ça fait

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import javax.swing.JPanel;
 
/**
 * Defini le contenu de la fenêtre de l'application d'animation des Chenille. Une zone
 * de dessin est un JPanel qui gère un liste d'objets Chenille. Lorsqu'il se réaffiche
 * l'objet Dessin redessinne les différents objets Chenille contenus dans cette liste.
 *
 * @author Philippe Genoud
 * @version
 */
public class Dessin extends JPanel {
    /**
     * stocke la liste des Chenille ayant été ajoutées à cette zone de
     * dessin.
     */
    private List<Chenille> listeDesChenilles = new ArrayList<Chenille>();
 
    /**
     * retourne la largeur de la zone de dessin.
     * @return la largeur.
     */
    public int getLargeur() {
        return getWidth();
    }
 
    /**
     * retourne la hauteur de la zone de dessin.
     * @return la hauteur.
     */
    public int getHauteur() {
        return getHeight();
    }
 
    /**
     * ajoute un Chenille à la zone de dessin.
     * @param c la Chenille à ajouter au Dessin
     * @see Chenille
     */
    public void ajouterObjet(Chenille v) {
 
        if (!listeDesChenilles.contains(v)) {
            // l'objet n'est pas déjà dans la liste
            // on le rajoute a la liste des objets du dessin
            listeDesChenilles.add(v);
			// fixe le dessin associé au visage rond v : c'est CE dessin
            v.setDessin(this);
            // le dessin se réaffiche
            repaint();
        }
    }
 
    /**
     * temporisation de l'animation.
     * @param durée delai de temporisation en ms.
     */
    public void pause(int duree) {
        try {
            Thread.sleep(duree);
        } catch (Exception e) {}
    }
 
    /**
     * affiche la zone de dessin et son contenu
     * @param g le contexte graphique
     */
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        dessinerLesChenilles(g);
    }
 
    /**
     * Parcourt la liste des Chenille pour afficher chacune d'elle.
     * @param g le contexte graphique
     */
    private void dessinerLesChenilles(Graphics g) {
        Iterator<Chenille> lesObjets = listeDesChenilles.iterator();
 
        while (lesObjets.hasNext()) {
            Chenille objCour = lesObjets.next();
            objCour.dessiner(g);
        }
    }    
} // Dessin

Mon problème vient surement de la méthode Chenille.deplacer() mais peut-être pas uniquement de là...

Merci d'avance pour vos conseils

**visiwi** · 19/10/2009, 01h27

Salut,

Un problème dans la méthode deplacerSelonCap() de Tete. En effet tu ne modifie en rien les valeurs de xInit et yInit puisque tu travail sur des types primitif et non sur des objets. Il faut (en l'état) des manipulateurs de ces attributs dans la classe Anneau.
Je te souhaite bon courage (sacré exo).

**DarkSeiryu** · 20/10/2009, 09h47

Merci de ta réponse.
Effectivement, je n'avais pas fait gaffe que ça ne modifiait en rien les valeurs de xInit et yInit...

Je vais essayer d'y remédier.

**DarkSeiryu** · 21/10/2009, 16h54

Voilà, ça tourne

Je mets le code ici pour ceux qui seraient intéressés

Classe Anneau

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
32
33
34
35
36
37
38
package Chenille;
import java.awt.*;
 
public class Anneau {
 
	// Attributs.
	protected int xInit; // Abcisse du centre de l'anneau.
	protected int yInit; // Ordonnée du centre de l'anneau.
	protected int r; // Rayon de l'anneau.
 
	// Constructeur.
	public Anneau(int xInit, int yInit, int r) {
		this.xInit = xInit;
		this.yInit = yInit;
		this.r = r;
	}
 
	// Getteur de x.
	public int getX() {
		return this.xInit;
	}
 
	// Getteur de y.
	public int getY() {
		return this.yInit;
	}
 
	// Positionne le centre de l'anneau en un point donné.
	public void placerA(int px, int py) {
		this.xInit = px;
		this.yInit = py;
	}
 
	// Affiche l’anneau en le matérialisant par un cercle noir.
	public void dessiner(Graphics g) {
		g.drawOval(this.getX(), this.getY(), this.r, this.r);
	}
}

Classe Tete

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package Chenille;
import java.awt.*;
 
/**
 * Permet de créer un objet Tete (cercle noir) et de le déplacer sur le dessin grâce à son cap.
 * C'est une classe enfant de Anneau.
 * @author Bénès Mickaël
 */
 
public class Tete extends Anneau {
 
	// Attribut.
	private double cap;
 
	// Constructeur.	
	public Tete(int xInit, int yInit, int r, double unCap) {
		super(xInit, yInit, r);
		this.cap = unCap;
	}
 
	// Getteur de r.
	public int getR() {
		return this.r;
	}
 
	// Affiche l’anneau en le matérialisant par un cercle noir.
	public void dessiner(Graphics g) {
		g.fillOval(this.getX(), this.getY(), this.r, this.r);
	}
 
	// Modifier le cap de la tête en lui ajoutant la déviation définie par le paramètre deltaC.
	public void devierCap(double deltaC) {
		this.cap += deltaC;
	}
 
	// Retourne true si le centre de la tête est à une distance <= R de l’un des bords de la fenêtre de taille xMax, yMax.
	// False sinon.
	public boolean atteintBord(int xMax, int yMax) {
		return (this.xInit >= xMax - this.r || this.yInit >= yMax - this.r || this.xInit <= 0 || this.yInit <= 0);
	}
 
	// Modifie le centre de la tête en lui appliquant un déplacement de longueur R dans la direction définie par le cap.
	public void deplacerSelonCap() {
		this.xInit = (int) (this.getX() + (this.r / 2 * Math.cos(this.cap)));
		this.yInit = (int) (this.getY() + (this.r / 2 * Math.sin(this.cap)));
		this.placerA(this.xInit, this.yInit);
	}
}

Classe Chenille

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package Chenille;
import java.awt.*;
 
/**
 * Permet de créer un objet Chenille à partir des classe Anneau et Tête.
 * @author Bénès Mickaël
 */
 
public class Chenille {
 
	// Attributs.
	private Tete t;
	private Anneau[] listeA;
	private Dessin d;
 
	// Constructeur.
	public Chenille(int nbA, Dessin unDessin) {
		this.d = unDessin;
		this.listeA = new Anneau[nbA];
 
		int tx = d.getLargeur() / 2; // Position en x de la Tete.
		int ty = d.getHauteur() / 2; // Position en y de la Tete.
		this.t = new Tete(tx, ty, 50, 0);
 
		int ax = t.getX() - t.getR() / 2;
		int ay = t.getY();
		for (int i = 0; i < nbA; i++) {
			listeA[i] = new Anneau(ax, ay, 50);
			ax = listeA[i].getX() - t.getR() / 2;
		}
	}
 
	// Dessine la chenille.
	public void dessiner(Graphics g) {
		t.dessiner(g);
		for (Anneau a : this.listeA) {
			a.dessiner(g);
		}
	}
 
	// Fait se déplacer la chenille.
	public void deplacer() {
		int aCourant = listeA.length - 1;
		for(int i = aCourant; i > 0; i--) {
			int aPre = i - 1;
        	listeA[i].placerA(listeA[aPre].getX(), listeA[aPre].getY());
        }
		listeA[0].placerA(t.getX(), t.getY());
 
		int dh = d.getLargeur();
		int dl = d.getHauteur();
		if (this.t.atteintBord(dh, dl))
			this.t.devierCap(Math.toRadians(90));
		else {
			double capRdm = (Math.random() * 60) - 30;
			this.t.devierCap(Math.toRadians(capRdm));
		}
		t.deplacerSelonCap();
	}
 
	// Fixe le dessin dans lequel la chenille se déplace.
	public void setDessin(Dessin d) {
		this.d = d;
	}
}

Classe AppliChenille

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package Chenille;
 
/**
*
* AppliVisage1.java
*
*
* Created: Sun Sep 26 13:41:42 1999
*/
 
import javax.swing.JFrame;
import javax.swing.WindowConstants;
 
 
/**
* Animation d'une chenille dans une fenêtre graphique.
* Une chenille est dessiné à l'intérieur d'une fenêtre et se déplace. Chaque fois
* que l'un des bords est atteint, la chenille change de direction.
* @author Philippe Genoud
* @version
*/
 
public class AppliVisage1  {
 
   public static void main(String[] args) {
 
       // La fenêtre graphique.
       JFrame laFenetre = new JFrame("Chenille animée");
       laFenetre.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
       laFenetre.setSize(512, 512);
 
       // Créé la zone de dessin et la place dans la fenêtre.
       Dessin d = new Dessin();
       laFenetre.add(d);
 
       // Affiche la fenêtre.
       laFenetre.setVisible(true);
 
       // Création d'un objet Chenille.
       Chenille c1 = new Chenille(5, d);
 
       // On rajoute cet objet à la zône de dessin.
       d.ajouterObjet(c1);
 
       // La boucle d'animation.
       // C'est une boucle infinie, le programme devra être interrompu
       // par CTRL-C ou en cliquant dans le cas de fermeture de la fenêtre.
       while (true) {
           // La chenille effectue un déplacement élémentaire.
           c1.deplacer();
 
           // La zone de dessin se réaffiche.
           d.repaint();
 
           // Un temps de pause pour avoir le temps de voir le nouveau dessin.
           d.pause(50);
       }
   }   
} // AppliChenille

Classe Dessin

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package Chenille;
 
/**
 * Dessin.java
 */
 
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import javax.swing.JPanel;
 
/**
 * Defini le contenu de la fenêtre de l'application d'animation des Chenille. Une zone
 * de dessin est un JPanel qui gère un liste d'objets Chenille. Lorsqu'il se réaffiche
 * l'objet Dessin redessinne les différents objets Chenille contenus dans cette liste.
 *
 * @author Philippe Genoud
 * @version
 */
public class Dessin extends JPanel {
    /**
     * stocke la liste des Chenille ayant été ajoutées à cette zone de
     * dessin.
     */
    private List<Chenille> listeDesChenilles = new ArrayList<Chenille>();
 
    /**
     * retourne la largeur de la zone de dessin.
     * @return la largeur.
     */
    public int getLargeur() {
        return getWidth();
    }
 
    /**
     * retourne la hauteur de la zone de dessin.
     * @return la hauteur.
     */
    public int getHauteur() {
        return getHeight();
    }
 
    /**
     * ajoute un Chenille à la zone de dessin.
     * @param c la Chenille à ajouter au Dessin
     * @see Chenille
     */
    public void ajouterObjet(Chenille c) {
 
        if (!listeDesChenilles.contains(c)) {
            // l'objet n'est pas déjà dans la liste
            // on le rajoute a la liste des objets du dessin
            listeDesChenilles.add(c);
			// fixe le dessin associé au visage rond v : c'est CE dessin
            c.setDessin(this);
            // le dessin se réaffiche
            repaint();
        }
    }
 
    /**
     * temporisation de l'animation.
     * @param durée delai de temporisation en ms.
     */
    public void pause(int duree) {
        try {
            Thread.sleep(duree);
        } catch (Exception e) {}
    }
 
    /**
     * affiche la zone de dessin et son contenu
     * @param g le contexte graphique
     */
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        dessinerLesChenilles(g);
    }
 
    /**
     * Parcourt la liste des Chenille pour afficher chacune d'elle.
     * @param g le contexte graphique
     */
    private void dessinerLesChenilles(Graphics g) {
        Iterator<Chenille> lesObjets = listeDesChenilles.iterator();
 
        while (lesObjets.hasNext()) {
            Chenille objCour = lesObjets.next();
            objCour.dessiner(g);
        }
    }    
} // Dessin

Problème d'animation d'une chenille

Langage Java

Vue hybride

Discussions similaires

Partager

Partager