Un getter qui ne renvoie qu'une fois les données pas à chaque fois

Bonjour , j'ai un problème , lorsque je fais appelle au getter " getXTete()" et donc en vérifiant à l'aide d'un print je me rend compte que sa valeur n'est renvoyé qu'une fois lors du premier déplacement puis il n'y a plus rien pour mieux comprend je vous met mon code , et le résultat je voudrai qu'en faite ma chenille avant de rencontrer une "pierre" fasse demie tour , où pierre est représenté par un carré la tête de chenille par un oval donc j'en ai déduis que pour éviter que les deux se rencontre il fallait faire demie tour a ma chenille avant qu'elle n'arrive dessus c'est a dire un cercle plus gros que le diamètre de l'oval de centre la rencontre des deux diagonales du carré (=pierre)(schéma ci joint)
Si vous avez une meilleur méthode ou idée pour programmer ceci n'hesitez pas

Cordialement
Merci d'avance

class ellipse

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
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
import java.awt.*;
/**
* Une Ellipse possede un centre dont on connait l'abcisse et l'ordonnee
* Une Ellipse a un petit diametre et un grand diametre
* Une Ellipse peut placer son centre sur une position donnee
* Une Ellipse peut se dessiner
* @author (LOUZOUN PALMIERI) 
* @version (14/12/11)
*/
public class Ellipse {
    public static final int xMax=500; // abscisse maximun de la fenetre
    public static final int yMax=500; // ordonnee maximun de la fenetre
    // l'origine (i.e. (0,0)) represente le coin superieur gauche de la fenetre 
    // instance variables
    private float x ; // abcisse du centre du cercle
    private float y ; // ordonnee du centre du cercle
    private float petitDiametre; // petit diametre du cercle
    private float grandDiametre; // grand diametre du cercle
 
     /**
     * creer une Ellipse au centre de la fenetre
     * en fixant ses deux diametres a la valeur 5
     */
    public Ellipse() {this(5, 5);}
 
     /**
     * creer une Ellipse au centre de la fenetre
     * en fixant son diametre
     * @param dInit diametre du cercle
     */
     public Ellipse(float pdInit, float gdInit) {this(xMax/2,yMax/2,pdInit,gdInit);}
 
     /**
     * creer une Ellipse en fixant sa position initiale et son rayon
     * @param xInit abscisse du centre du cercle
     * @param yInit ordonnee du centre du cercle
     * @param dInit diametre du cercle
     */
     public Ellipse(float xInit, float yInit, float pdInit, float gdInit) {
         this.x=xInit ; this.y=yInit ;
         this.petitDiametre=Math.min(pdInit,gdInit) ;
         this.grandDiametre=Math.max(pdInit,gdInit) ;}
 
     /**
     * obtenir l'abcisse du centre
     * @return abcisse du centre
     */
     public  float getX() {return this.x;}
 
     /**
     * modifier l'abcisse du centre
     * @param x abcisse du centre
     */
     public void setX(float x) {this.x=x;}
 
     /**
     * obtenir l'ordonnee du centre
     * @return ordonnee du centre
     */
     public float getY() {return this.y;}
 
     /**
     * modifier l'ordonnee du centre
     * @param y ordonnee du centre
     */
     public void  setY(float y) {this.y=y;}
 
     /**
     * obtenir le petit diametre
     * @return petitDiametre
     */
     public float getPetitDiametre()  {return this.petitDiametre;}
 
	/**
     * obtenir le grand diametre
     * @return petitDiametre
     */
	public float getGrandDiametre()  {return this.grandDiametre;}
 
     /**
     * modifier le petit diametre
     * @param d diametre
     */
     public void  setPetitDiametre(float d) {this.petitDiametre=d;}
 
	/**
     * modifier le grand diametre
     * @param d diametre
     */
	public void  setGrandDiametre(float d) {this.grandDiametre=d;}
 
     /**
     * modifier la position du centre
     * @param x abcisse
     * @param y ordonnee
     */
     public void placerA(float x, float y){this.setX(x);this.setY(y);}
 
     /**
     * dessiner l'ellipse
     * @param g instance de classe Graphics qui prend en charge la gestion de l'affichage dans la fenetre de dessin
     * @param c instance de la classe Color qui represente la couleur d'affichage du cercle
     */
     public void dessiner(Graphics g, Color c){
         g.setColor(c);
         g.drawOval(Math.round(this.getX()-this.getPetitDiametre()/2),
                    Math.round(this.getY()-this.getGrandDiametre()/2), 
                    Math.round(this.petitDiametre),
                    Math.round(this.grandDiametre));
     }
}

class cercle

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
32
33
34
35
36
37
38
39
40
41
import java.awt.*;
/**
* Un Cercle est une sorte d'Ellipse dont le petit diametre est égale au grand diametre
* @author (LOUZOUN PALMIERI) 
* @version (14/12/11)
*/
public class Cercle extends Ellipse {
     /**
     * creer un Cercle au centre de la fenetre
     * en fixant son diametre a la valeur 5
     */
    public Cercle() {this(5);}
 
     /**
     * creer un Cercle au centre de la fenetre
     * en fixant son diametre
     * @param dInit diametre du cercle
     */
     public Cercle(float dInit) {super(dInit,dInit);}
 
     /**
     * creer un Cercle en fixant sa position initiale et son rayon
     * @param xInit abscisse du centre du cercle
     * @param yInit ordonnee du centre du cercle
     * @param dInit diametre du cercle
     */
     public Cercle(float xInit, float yInit, float dInit) {super(xInit,yInit,dInit,dInit);}
 
     /**
     * obtenir le diametre
     * @return diametre
     */
     public float getDiametre()  {return getPetitDiametre();}
 
     /**
     * modifier le diametre
     * @param d diametre
     */
     public void  setDiametre(float d) {if (d<this.getDiametre()) {super.setPetitDiametre(d); super.setGrandDiametre(d);}
		else {super.setGrandDiametre(d); super.setPetitDiametre(d);}}
    	 }

class EllipseAnime

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
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
import java.awt.* ;
import java.util.ArrayList;
/**
 * une EllipseAnime est une sorte de Ellipse qui
 * possede un cap
 * peut uniquement modifier son cap en tournant sur elle-meme
 * sait si, oui ou non, elle est au bord de son espace
 * peut avancer dans la direction de son cap
 * peut se dessiner : elle materialise son cap 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class EllipseAnime extends Ellipse {
    private float cap;
 
    /**
     * creer une EllipseAnime en fixant son angle de vision à 0
     */
    public EllipseAnime() {super(); this.cap=0;}
 
    /**
     * creer une EllipseAnime en fixant son cap initiale
     *@param capInit cap initiale
     */
    public EllipseAnime(float capInit) {this.cap=capInit ;}
 
    /**
     * creer une EllipseAnime en fixant son cap initiale et ses diametres
     *@param pdInit PetitDiametre initiale
     *@param gdInit GrandDiametre initiale
     *@param capInit cap initiale
     */
    public EllipseAnime(float pdInit, float gdInit, float capInit) {super(pdInit, gdInit) ; this.cap=capInit ;}
 
    /**
     * creer une EllipseAnime en fixant son cap initiale ,ses diametres et sa position initiale
     *@param xInit abscisse initiale ellipseAnime
     *@param yInit ordonnee initiale ellipseAnime
     *@param pdInit PetitDiametre initiale
     *@param gdInit GrandDiametre initiale
     *@param capInit cap initiale
     */
    public EllipseAnime(float xInit, float yInit, float pdInit, float gdInit, float capInit)  {super(xInit, yInit, pdInit ,gdInit) ; this.cap=capInit ;}
    /**
     * obtenir le cap
     * @return cap
     */
    public float getCap(){return this.cap ;}
    /**
     * obtenir le Petit Diametre
     * @return PetitDiametre
     */
    public float getPetitDiametre(){return super.getPetitDiametre();}
 
    /**
     * obtenir le Grand Diametre
     * @return GrandDiametre
     */
    public float getGrandDiametre(){return super.getGrandDiametre();}
 
 
 
   /**
   * une EllipseAnime sais s'il est bord de son espace 
   * @param les bords max de l'espace 
   * @return suis-je au bord ?
   */
    public boolean auBord(float xMax, float yMax){
        return (this.getX()+this.getGrandDiametre()>xMax-10 || 
                this.getX()-this.getGrandDiametre()<10      ||
                this.getY()+this.getGrandDiametre()>yMax-10 ||
                this.getY()-this.getGrandDiametre()<10);
    }
 
    /**
    * une EllipseAnime peut tourner d'un certain angle 
    * @param increment du cap
    */
    public void tourner(float deltaC){this.cap=this.cap + deltaC ;}
 
    /**
    * une EllipseAnime peut avancer selon son cap
    * s'il est au bord de son espace, il fait demi-tour
    * @param longueur du deplacement
    */
    public void avancer(float longueur){
        if (this.auBord(xMax, yMax)) this.tourner(180);
        float capEnRadian=this.cap*(float)(Math.PI/180); // conversion degre2radian
 
float x=longueur* (float) Math.cos(capEnRadian) ;
float y=longueur* (float) Math.sin(capEnRadian) ;
        this.setX(this.getX()+x);
        this.setY(this.getY()+y);
    }
 
 
    /**
    * une EllipseAnime peut dessiner son cap 
    * le cap est represente par un "petit" segment de droite issu du centre
    * @param le contexte graphique
    * @param la couleur
    */
    private void dessinerCap(Graphics g, Color c){
        float capEnRadian=this.cap*(float)(Math.PI/180);
        g.drawLine(Math.round(this.getX()),
                   Math.round(this.getY()),
                   Math.round(this.getX()+this.getPetitDiametre()*(float)Math.cos(capEnRadian)),
                   Math.round(this.getY()+this.getPetitDiametre()*(float)Math.sin(capEnRadian))
                   );
    }
 
    /**
    * une EllipseAnime peut se dessiner
    * @param le contexte graphique
    * @param la couleur
    */
    public void dessiner(Graphics g, Color c){
        super.dessiner(g,c) ;// dessiner ellipse
        this.dessinerCap(g,c) ; // dessiner cap
    }
}

class TeteDeChenille

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
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
96
97
98
99
100
101
102
103
104
105
106
import java.awt.* ;
/**
 * une TeteDeChenille est une sorte d EllipseAnime.
 ** elle possède un angle de vision
 ** elle peut se déplacer : elle avance alors dans une direction qui dévie aléatoirement
 **    par rapport à son cap sans toutefois aller au dela de la zone couverte par son angle de vision
 ** elle peut se dessiner et matérialiser son angle de vision 
 ** @author (your name) 
 ** @version (a version number or a date)
 */
public class TeteDeChenille extends EllipseAnime
{
    private float angleDeVision ;
 
    /**
     * creer une tete de chenille
     * en fixant son angle de vision à 0
     * @param
     */
    public TeteDeChenille() {super();this.angleDeVision=0;}
 
    /**
     * creer une tete de chenille
     * en fixant son angle de vision à vision initiale
     * @param angleDeVision
     */
    public TeteDeChenille(float visionInit) {angleDeVision=visionInit ; }
 
    /**
     * creer une tete de chenille
     * en fixant son diametre, son cap initiale et sa vision initiale
     * @param pdInit petit diametre
     * @param gdInit Grand diametre
     * @param capInit cap initiale
     */
    public TeteDeChenille(float pdInit, float gdInit, float capInit, float visionInit) {super(pdInit, gdInit,capInit) ; angleDeVision=visionInit ;}
 
    /**
     * creer une tete de chenille
     * en fixant son diametre, son cap initiale et sa vision initiale
     * @param pdInit petit diametre
     * @param gdInit Grand diametre
     * @param capInit cap initiale
     * @param visionInit vision initiale
     */
    public TeteDeChenille(float xInit, float yInit, float pdInit, float gdInit, float capInit, float visionInit) {super(xInit, yInit, pdInit,gdInit , capInit) ; angleDeVision=visionInit ;}
 
    /**
     * obtenir l'angle de vision
     * @return AngleDeVision
     */
    public float getAngleDeVision() {return this.angleDeVision ;}
 
    /**
     * modifier l'angle de vision
     * @param AngleDeVision
     */
    public void setAngleDeVision(float a) {this.angleDeVision=a ;}
 
    /**
     * obtenir le petit diamètre de la tête de chenille
     * @return PetitDiametre
     */
    public float getPetitDiametre() {return super.getPetitDiametre() ;}//ajout
 
    /**
     * obtenir le grand diamètre de la tête de chenille
     * @return GrandDiametre
     */
    public float getGrandDiametre() {return super.getGrandDiametre() ;}//ajout
 
 
    /**
         * une TeteDeChenille peut se déplacer ; elle avance alors dans une direction qui dévie aléatoirement
         * par rapport à son cap sans toutefois aller au dela de la zone couverte par son angle de vision
     */
     public void deplacer(){
	    double aleatoire=Math.random() ;
if ((int)(aleatoire*100)%2==0)
{ this.tourner((float)(aleatoire*angleDeVision/2)) ; }
else { this.tourner((float)(-aleatoire*angleDeVision/2)) ;}
            this.avancer(this.getGrandDiametre()/2);
    }
 
    /**
         * une TeteDeChenille peut dessiner son angle de vision
         * l'angleDeVision est représenté par deux "petits" segment de droites issues de son centre
         * @param le contexte graphique
    */
    private void dessinerAngleDeVision(Graphics g){
        g.setColor(Color.red);
        float capEnRadian=getCap()*(float)(Math.PI/180) ;
        float angleDeVisionEnRadian=this.angleDeVision*(float)(Math.PI/180) ;
        g.drawLine((int)super.getX(),(int)(this.getY()),(int)(super.getX()+getGrandDiametre()*Math.cos(capEnRadian+angleDeVisionEnRadian/2)),(int)(super.getY()+getGrandDiametre()*Math.sin(capEnRadian+angleDeVisionEnRadian/2)));
        g.drawLine((int) super.getX(),(int)(super.getY()),(int)(super.getX()+getGrandDiametre()*Math.cos(capEnRadian-angleDeVisionEnRadian/2)),(int)(super.getY()+getGrandDiametre()*Math.sin(capEnRadian-angleDeVisionEnRadian/2)));}
 
    /**
         * une TeteDeChenille peut se dessiner
         * @param le contexte graphique
         * @param la couleur
         */
    public void dessiner(Graphics g, Color c){
        super.dessiner(g,c) ;
        this.dessinerAngleDeVision(g);
    }
}

class Chenille

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
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
import java.awt.Color ;
/**
 * une Chenille possede une epaisseur, une longueur, une couleur, un angleDeVision, elle
 * est constituee d'une tete et d'un corps :
 * * son angleDeVision est celui de sa tete
 * * le corps est constitue d'anneaux (cercle qui se chevauchent)
 * * sa longueur correspond au nombre d'anneaux dans le corps
 * peut se deplacer
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Chenille
{   private float          epaisseur; // epaisseur de la chenille
    private int            longueur; // longueur du corps en nombre d'anneaux
    private Color          couleur ;
    private TeteDeChenille tete;
    private Cercle []      corps; // tableau de cercles
 
    /**
     * Constructor for objects of class Chenille
     */
 
    /**
     * creer une Chenille en fixant sa longueur son epaisseur son angle de vision et sa coueleur
     * @param longeur longueur de la chenille
     * @param epaisseur epaisseur de la chenille
     * @param angleVision angle de vision de la chenille
     * @param c couleur de la chenille
     */
    public Chenille(int longueur, float epaisseur, float angleVision, Color c){
        this.longueur      = longueur; // longueur du corps
        this.epaisseur     = epaisseur;
        this.couleur       = c;
        this.tete          = new TeteDeChenille(this.epaisseur, this.epaisseur*2, 0, angleVision);
        this.corps       = new Cercle[this.longueur];
        for(int i=0 ; i<this.longueur ; i++){corps[i]=new Cercle(tete.getX()-(i+1)*epaisseur/2*(float)Math.cos(tete.getCap()),tete.getY()-(i+1)*epaisseur/2*(float)Math.sin(tete.getCap()),epaisseur);
 
        }}
    /**
     * obtenir l'angle de vision
     * @return AngleDeVision
     */
    public float getAngleDeVision()  {return tete.getAngleDeVision();}
 
    /**
     * modifier l'angle de vision
     * @param AngleDeVision
     */
    public void setAngleDeVision(float a) {tete.setAngleDeVision(a);}
    /**
     * modifier longueur Chenille
     * @param longueur
     */
    public void setLongeur(int a){longueur= a;}
 
    /**
     * obtenir l'epaisseur de la chenille
     * @return epaisseur
     */
    public float getEpaisseur() {		return this.epaisseur;	}
 
    /**
     * obtenir l'abscisse X de la tete de la chenille
     * @return tete.getX
     */
    public float getXTete(){return tete.getX();}
 
    /**
     * obtenir l'ordonnee Y de la tete de la chenille
     * @return tete.getY
     */
    public float getYTete(){return tete.getY();}
 
    /**
     * obtenir le petit diamètre de la tête de chenille
     * @return PetitDiametre
     */
public float getPetitDiametreTete() {return this.tete.getPetitDiametre() ;}//ajout
 
/**
 * obtenir le grand diamètre de la tête de chenille
 * @return GrandDiametre
 */
    public float getGrandDiametreTete() {return this.tete.getGrandDiametre() ;}//ajout
 
 
 
    /** une Chenille peut se deplacer :
    *  son deplacement est determine par celui de sa tete
    *  lors du deplacement, l'ensemble de son corps suit le mouvement de sa tete
    */
    public void deplacer(){
        this.tete.deplacer();
        //this.predateur.deplacer();//PREDATEUR **************
 
float tx=tete.getX() ;
 
float ty=tete.getY() ;
for(int i=0 ; i<this.longueur ; i++) {
 
float cx=corps[i].getX() ;
 
float cy=corps[i].getY() ;
corps[i].placerA(tx,ty) ;
tx=cx ;
ty=cy ; 
        }
    }
 
 
 
    /** une Chenille peut se dessiner :
    *  en dessinant chaque partie de son corps
    *  et en dessinant sa tete
    *  @param le contexte graphique
    */
    public void dessiner(java.awt.Graphics g){
        this.tete.dessiner(g,couleur) ;// dessiner la tete
for(int i=0 ; i<this.longueur ; i++){
this.corps[i].dessiner(g,couleur) ;}// dessiner le corp
 
 
    }
 
}

Class maClasse

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
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
/** 
 * Un rectangle est caractérise par sa largeur et sa hauteur
 * la largeur et la hauteur sont des entiers positifs 
 * @author 
 */
import java.awt.Color;
import java.awt.Graphics;
 
public class Maclasse {
	private int largeur;
	private int hauteur;
	private int x; // abcisse du coté du rectangle
	private int y; // ordonnee du coté du rectangle
	private Color color;
	 /**
     * creer carré au bord de l'axe au nord ouest
     * en fixant sa longeur et sa hauteur a 10
     */
	public Maclasse() {
		this(0, 0, 10, 10);
	}
 
	/**
     * creer carré en fixant sa largeur, sa hauteur et ses coordonnées initiales
     *@param x abscisse rectangle
     *@param y ordonnée rectangle
     *@param l largeur du rectangle
     *@param h hauteur du rectangle
     */
	public Maclasse(int x, int y, int l, int h) {
		this.largeur = l;
		this.hauteur = h;
		this.x = x;
		this.y = y;
	}
 
	/**
         * Obtenir l'ordonnée du Rectangle
         * 
         * @return l'ordonnée du coté en haut a gauche
         */
 
	/**
         * Obtenir l'abscisse du Rectangle
         * 
         * @return l'abscisse du coté en haut a gauche
         */
	public int getX() {
		return this.x;
	}
 
	/**
         * fixer l'abscisse du Rectangle
         * 
         * @param l
         *            'abscisse du coté en haut a gauche
         */
	public void setX(int x) {
		this.x = x;
	}
 
	/**
         * Obtenir l'ordonnée du Rectangle
         * 
         * @return l'ordonnée du coté en haut a gauche
         */
	public int getY() {
		return this.y;
	}
 
	/**
         * fixer l'ordonnée du Rectangle
         * 
         * @param l
         *            'ordonneé du coté en haut a gauche
         */
	public void setY(int y) {
		this.y = y;
	}
 
	/**
         * Obtenir la largeur du Rectangle
         * 
         * @return la largeur
         */
	public int getLargeur() {
		return this.largeur;
	}
 
	/**
         * Obtenir la hauteur du Rectangle
         * 
         * @return la hauteur
         */
	public int getHauteur() {
		return this.hauteur;
	}
 
	/**
         * fixer la largeur du Rectangle
         * 
         * @param la
         *            largeur
         */
	public void setLargeur(int l) {
		this.largeur = l;
	}
 
	/**
         * fixer la hauteur du Rectangle
         * 
         * @param la
         *            hauteur
         */
	public void setHauteur(int h) {
		this.hauteur = h;
	}
 
 
	public void dessiner(Graphics g) {
		g.setColor(getColor());
		g.drawRect(getX(), getY(), getLargeur(), getHauteur());
	}
 
	public Color getColor() {
		return color;
	}
 
	public void setColor(Color color) {
		this.color = color;
	}}

Class TestMaClasse

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
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JPanel;
 
public class TestMaclasse extends JApplet {
	private JPanel panelDeBoutons;
	private JButton augmenterPierre;
	private JButton reduireAngle;
	private JButton augmenterAngle;
	private JButton deplacerVite;
	private JButton deplacer;
	private JButton deplacerTresVite;
	private JPanel canvas;
	private ArrayList<Maclasse> listRectangles;
	 private Chenille maChenille  ;
	 boolean a;
	 int tailleRectangle=2;
	 int k=-tailleRectangle;
	 boolean [] tab = new boolean[tailleRectangle];
 
	private class Canvas extends JPanel {
		public Canvas() {
			super();
		}
 
		@Override
		public void paintComponent(Graphics g) {
			super.paintComponent(g); // Pour avoir le background de la couleur qu'on souhaite
			maChenille.dessiner(g);
			for (Maclasse pierre : listRectangles) {
				pierre.dessiner(g);
			}
		}
	}
 
	public TestMaclasse() {
		listRectangles = new ArrayList<Maclasse>();
		
			}//float capEnRadian=this.cap*(float)(Math.PI/180);
	public boolean IsRencontre(){
										for(Maclasse pierre : listRectangles){
											for(int i=0;i<360;i++){
												while(k<tailleRectangle){System.out.print(maChenille.getXTete());	
													if(pierre.getX()+k==maChenille.getXTete()+maChenille.getGrandDiametreTete()*Math.cos(i*Math.PI/180)&&
														pierre.getY()+k==maChenille.getYTete()+maChenille.getGrandDiametreTete()*Math.sin(i*Math.PI/180)){System.out.print("X chenille " +maChenille.getGrandDiametreTete());System.out.print("diametre grand"+maChenille.getGrandDiametreTete());
													
														a=true;}
	else{a=false;}k++;System.out.print("i="+i+"\n");System.out.println("MA chenille"+maChenille.getYTete());}}
									}
	return a;}
    
	       
	 
		
	
 
	@Override
	public void init() {
		setSize(500, 500);
		setLayout(new BorderLayout());
		panelDeBoutons = new JPanel();
		panelDeBoutons.setLayout(new FlowLayout(FlowLayout.CENTER));
		 maChenille = new Chenille(15,10,45,Color.blue);
		 
		 
		augmenterPierre = new JButton("+ Pierre");
		augmenterPierre.addActionListener(new ActionListener(){
			@Override
			public void actionPerformed(ActionEvent e) {
														Maclasse rect = new Maclasse();
														rect.setX((int) (Math.random() * 500));
														rect.setY((int) (Math.random() * 500));
														rect.setHauteur(2);
														rect.setLargeur(2);
														rect.setColor(Color.BLACK);
														listRectangles.add(rect);
														canvas.repaint();}
									                          }
	                                                 );
		
 
		panelDeBoutons.add(augmenterPierre);
		reduireAngle = new JButton("-");
		reduireAngle.addActionListener(new ActionListener(){
@Override
				public void actionPerformed(ActionEvent e) {if(maChenille.getAngleDeVision()>0) {maChenille.setAngleDeVision((maChenille.getAngleDeVision())-5) ; canvas.repaint();}}}

		
		);
panelDeBoutons.add(reduireAngle);
		
		;
		
		augmenterAngle = new JButton("+");
		augmenterAngle.addActionListener(new ActionListener()         {
																public void actionPerformed(ActionEvent e) {
																	if (maChenille.getAngleDeVision()<180){maChenille.setAngleDeVision((maChenille.getAngleDeVision())+5) ;
			                                                                             repaint();}
																	                                       }
							            });
		panelDeBoutons.add(augmenterAngle);
		deplacer = new JButton("GO");
		deplacer.addActionListener(new ActionListener()    {
														      	public void actionPerformed(ActionEvent e) {	
														      		maChenille.deplacer();if(true==IsRencontre()){
														      			maChenille.setAngleDeVision(maChenille.getAngleDeVision()+90);} canvas.repaint() ;}
		});
		panelDeBoutons.add(deplacer);
		deplacerVite = new JButton("GOO");
		deplacerVite.addActionListener(new ActionListener()       {
																	public void actionPerformed(ActionEvent e)            
																	      {for(int i=0 ; i<5 ; i++) {
																	    	  maChenille.deplacer();if(true==IsRencontre()){
																	    		  maChenille.setAngleDeVision(maChenille.getAngleDeVision()+90);}canvas.repaint() ;}}
		});
		panelDeBoutons.add(deplacerVite);
		deplacerTresVite = new JButton("GOO");
		deplacerTresVite.addActionListener(new ActionListener()  {
																	public void actionPerformed(ActionEvent e) 
																	      {for(int i=0 ; i<10 ; i++) {
																	    	  maChenille.deplacer();if(true==IsRencontre()){
																	    		  maChenille.setAngleDeVision(maChenille.getAngleDeVision()+90);}canvas.repaint() ;}}
		});
		panelDeBoutons.add(deplacerTresVite);
	     
		{
 
		canvas = new Canvas();
		canvas.setBackground(Color.WHITE);
		add(panelDeBoutons, BorderLayout.NORTH);
		add(canvas, BorderLayout.CENTER);
		invalidate();
		validate();
	
	}}
	}

ps: je rappelle l'equation parametrique d'une ellipse : x=u+cos t
y=v +sin t
t =[0;2PI] , u et v representent respectivement le petit diametre et le grand diametre