Un objet qui ne s'affiche pas

**tonytrua** · 12/12/2011, 22h32

Bonjour ,
Je voudrai comparé deux objets , un provenant d'une arraylist qui en la parcourant récupérerait un entier et comparer celui-ci avec un autre entier ,
Mais je n'arrive pas à obtenir correctement cette entier grâce à mon getteur/setteur , je ne comprend pas l'erreur. En faite je voudrai tester ces valeurs si ce sont les même alors la méthode boolean renverrai true (Dans TestMaclasse , normalement tout est bon ailleur)
Et j'ai une erreur de compilation dans cette même classe à la ligne 91 dont je ne comprend pas l'origine
Cordialement
Merci d'avance

**Robin56** · 13/12/2011, 00h23

Envoyé par tonytrua

Bonjour ,
Je voudrai comparé deux objets , un provenant d'une arraylist qui en la parcourant récupérerait un entier et comparer celui-ci avec un autre entier ,
Mais je n'arrive pas à obtenir correctement cette entier grâce à mon getteur/setteur , je ne comprend pas l'erreur. En faite je voudrai tester ces valeurs si ce sont les même alors la méthode boolean renverrai true (Dans TestMaclasse , normalement tout est bon ailleur)
Et j'ai une erreur de compilation dans cette même classe à la ligne 91 dont je ne comprend pas l'origine
Cordialement
Merci d'avance

Je suis désolé mais j'ai quelque peu la flemme de mettre en place ton code Java. Pourrais tu afficher l'erreur de compilation que ton compilateur t'affiche et cibler le code compromettant en le citant ici avec les balises [code] ?

**tonytrua** · 13/12/2011, 09h52

Bonjour,
En faite j'ai réussis a corriger toutes les erreurs de compilations mais maintenant maChenille ne se dessine plus :/
Et quelques précision en faite si ma chenille rencontre une pierre c'est a dire que rencontre()=true alors elle ferait demie tour

voila mon code
Cordialement
Merci d'avance

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
96
97
98
import java.awt.BorderLayout;
 
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;
 
	private class Canvas extends JPanel {
 
	public TestMaclasse() {
		listRectangles = new ArrayList<Maclasse>();
 
			}
	public boolean Rencontre(){for(Maclasse pierre : listRectangles){if(pierre.getX()==maChenille.getXTete()&&pierre.getY()==maChenille.getYTete()){a=true;}
	else{a=false;}}
	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(3);
				rect.setLargeur(3);
				rect.setColor(Color.BLUE);
				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) ;
			canvas.repaint();}}}
		);
		panelDeBoutons.add(augmenterAngle);
		deplacer = new JButton("GO");
		deplacer.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent e) {maChenille.deplacer();
			if(true==Rencontre()){maChenille.setAngleDeVision(-maChenille.getAngleDeVision());}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==Rencontre()){maChenille.setAngleDeVision(-maChenille.getAngleDeVision());}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==Rencontre()){maChenille.setAngleDeVision(-maChenille.getAngleDeVision());}canvas.repaint() ;}}
		});
		panelDeBoutons.add(deplacerTresVite);
	     {
 
		canvas = new Canvas();
		canvas.setBackground(Color.WHITE);
		add(panelDeBoutons, BorderLayout.NORTH);
		add(canvas, BorderLayout.CENTER);
		invalidate();
		validate();
	}}}

**kolodz** · 13/12/2011, 13h39

J'avoue ne pas savoir comment vous avez réussie à compiler le code que vous nous montré.

Vous déclarez le constructeur de la classe "TestMaclasse" dans une classe interne à celle-ci, par exemple.
Certaines de vos variables sont obscure :

Code :

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

	boolean a;

Je vois que la variable est utilisé dans "Rencontre". je suppose donc que son petit nom devrait être "isRencontre" "isDead".
Mais je reste convaincu que le la fonction rencontre ne devait pas directement setter la propriété.

Voici deux code identiques :

Code :

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

1
2
3
4
		deplacerVite.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent e) {for(int i=0 ; i<5 ; i++) {maChenille.deplacer();
			if(true==Rencontre()){maChenille.setAngleDeVision(-maChenille.getAngleDeVision());}canvas.repaint() ;}}
		});

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
		deplacerVite.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent e)
			{
				for(int i=0 ; i<5 ; i++)
				{
					maChenille.deplacer();
				}
				if(true==Rencontre())
				{
					maChenille.setAngleDeVision(-maChenille.getAngleDeVision());
				}
				canvas.repaint();
			}
		});

Je vous laisse décider du plus lisible.
D'ailleurs, on constat qu'on vérifie si il y a rencontre qu'après 5 déplacements.
(je passe sous silence le "5" placer en dur et non avec un variable type "NOMBRE_DEPLACEMENT_POUR_DEPLACE_VITE")

Sinon Cavans n'a pas besoin d'être une classe interne à votre Apple.
Et non n'avons pas les classes "Maclasse" et "Chenille".
Du coup, pour vous aider avec votre code, ce n'est pas simple.

Cordialement,
Patrick Kolodziejczyk.

**tonytrua** · 13/12/2011, 16h31

Bonjour,
Je ne comprend pas votre je laisse sous silence le 5 ?
Sachant que je l'ai bien fait vérifier à chaque fois dans mon code je l'ai intégrer a la boucle for.
Et mon code était plus haut dans le dossier zip vu qu'il y avait plusieurs classe et qui marchaient toutes sans erreurs c'était pour ne pas vous encombrer ..
Cordialement
La j'ai juste une erreur que je ne comprend pas c'est pourquoi ma chenille ne se créer pas ?
Cordialement

**Robin56** · 13/12/2011, 16h47

Envoyé par tonytrua

Bonjour,
Je ne comprend pas votre je laisse sous silence le 5 ?
Sachant que je l'ai bien fait vérifier à chaque fois dans mon code je l'ai intégrer a la boucle for.

Il faut plutôt passer par une constante. Elle permettra de cibler l'endroit à modifier lors d'une possible évolution (toujours penser au futur).

Envoyé par tonytrua

Et mon code était plus haut dans le dossier zip vu qu'il y avait plusieurs classe et qui marchaient toutes sans erreurs c'était pour ne pas vous encombrer ..

Sauf que tu nous indiques que le problème vient de Chenille mais que tu ne le fournis pas ce code.

Envoyé par tonytrua

La j'ai juste une erreur que je ne comprend pas c'est pourquoi ma chenille ne se créer pas ?

Où est l'erreur ? Code de l'exception ? Code d'erreur ?

**tonytrua** · 13/12/2011, 17h09

Il n'y a aucune erreur de compilation seulement la chenille qui n'apparait pas

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
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);}}
    	 }

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
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));
     }
}

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
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;
 
    public EllipseAnime() {super(); this.cap=0;}
 
    public EllipseAnime(float capInit) {this.cap=capInit ;}
 
    public EllipseAnime(float pdInit, float gdInit, float capInit) {super(pdInit, gdInit) ; this.cap=capInit ;}
 
    public EllipseAnime(float xInit, float yInit, float pdInit, float gdInit, float capInit)  {super(xInit, yInit, pdInit ,gdInit) ; this.cap=capInit ;}
 
    public float getCap(){return this.cap ;}
 
 
   /**
   * 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
    }
}

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
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 ;
 
    public TeteDeChenille() {super();this.angleDeVision=0;}//???
 
    public TeteDeChenille(float visionInit) {angleDeVision=visionInit ; }
 
    public TeteDeChenille(float pdInit, float gdInit, float capInit, float visionInit) {super(pdInit, gdInit,capInit) ; angleDeVision=visionInit ;}
 
    public TeteDeChenille(float xInit, float yInit, float pdInit, float gdInit, float capInit, float visionInit) {super(xInit, yInit, pdInit,gdInit , capInit) ; angleDeVision=visionInit ;}
 
    public float getAngleDeVision() {return this.angleDeVision ;}
 
    public void setAngleDeVision(float a) {this.angleDeVision=a ;}
 
    /**
         * 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);
    }
}

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
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
     */
 
    public float getXTete(){return tete.getX();}
    public float getYTete(){return tete.getY();}
 
    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);
 
        }}
 
    public float getAngleDeVision()  {return tete.getAngleDeVision();}
    public void setAngleDeVision(float a) {tete.setAngleDeVision(a);}
    public float getLongeur(){return longueur;}
    public void setLongeur(int a){longueur= a;}
 
    /** 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 ; // deplacer le corps
        }
    }
 
    /**
     * La taille d'une chenille diminue si elle rencontre un prédateur mais grandit toutes les 5 secondes 
     * 
     * 
     * 
     */
    /*public void rencontre(){if(tete.getX()==predateur.getX() && tete.getY()==predateur.getY()){longueur=longueur-1; //PREDATEUR Rencontre Chenille
    	
    }
		}
		*/
 
    /** 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
 
 
    }
}

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
import java.applet.Applet;
import java.awt.*;
import java.awt.event.* ;
 
public class TestChenille extends Applet implements ActionListener {
  private Button reduireAngle = new Button("-") ; 
  private Button deplacer = new Button("GO") ; 
  private Button deplacerVite = new Button("GOO") ; 
  private Button deplacerTresVite = new Button("GOOO") ; 
  private Button augmenterAngle = new Button("+") ; 
  private Chenille maChenille  ;
 
   public void init(){
      this.add(reduireAngle);
      this.add(deplacer);
      this.add(deplacerVite);
      this.add(deplacerTresVite);
      this.add(augmenterAngle);
      reduireAngle.addActionListener(this) ;
      deplacer.addActionListener(this) ;
      deplacerVite.addActionListener(this) ;
      deplacerTresVite.addActionListener(this) ;
      augmenterAngle.addActionListener(this) ;
      maChenille = new Chenille(15,10,45,Color.blue);
}
 
 
 
 
   public void actionPerformed(ActionEvent e){
      if(e.getActionCommand() == "-") {if (maChenille.getAngleDeVision()>0) {maChenille.setAngleDeVision((maChenille.getAngleDeVision())-5) ; repaint();}}
      else if(e.getActionCommand() == "+") {if (maChenille.getAngleDeVision()<180){maChenille.setAngleDeVision((maChenille.getAngleDeVision())+5) ; repaint();}}
      else if(e.getActionCommand() == "GO") {maChenille.deplacer(); repaint() ;}
      else if(e.getActionCommand() == "GOO") {for(int i=0 ; i<5 ; i++) {maChenille.deplacer(); repaint() ;}}
      else if(e.getActionCommand() == "GOOO") {for(int i=0 ; i<10 ; i++) {maChenille.deplacer(); repaint() ;}}
   }
 
   public void paint(Graphics g) {  
      g.drawRect(5,5,Cercle.xMax-5,Cercle.yMax-5);
      setBackground(Color.green);
      maChenille.dessiner(g) ;
   }
 
}

alors que testChenille marche très bien lui , en faite j'ai rajouté la classe rectangle dans laquelle on pouvait rajouter des rectangles avec un bouton et je voudrai que cette chenille évites les rectangles en faisant demie tour
Cordialement

**Mathieu.J** · 15/12/2011, 10h09

Si tu veux savoir ce qui ne se passe pas correctement utilise le debugger et suit le parcours de ton programme. Si tu n'as pas de debugger, des bons vieux System.out.println(...) dans tes fonctions d'affichage devraient t'aider à comprendre.

Par ailleurs, le

Code :

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