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