import java.awt.* ;
import java.io.Console;
/**
 * 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;
    private float capEnRadian;

    public EllipseAnime() {
    	super(5,5);
    	this.cap=0;
    	}

    public EllipseAnime(float capInit) {
    	this(xMax/2,yMax/2,5,5,capInit);
    }

    public EllipseAnime(float pdInit, float gdInit, float capInit) {
    	this(xMax/2,yMax/2,pdInit,gdInit,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);
         capEnRadian=this.cap*(float)(Math.PI/180); // conversion degre2radian
         this.setX(getX()+longueur*(float)Math.cos(capEnRadian));
         this.setY(getY()+longueur*(float)Math.sin(capEnRadian));
    }

    /**
    * 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){
        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){
    	g.setColor(c);
    	//g.drawOval(Math.round(this.getX()-this.getPetitDiametre()/2), Math.round(this.getY()-this.getGrandDiametre()/2),  Math.round(this.getPetitDiametre()),  Math.round(this.getGrandDiametre() ));
    	super.dessiner(g, c);
        dessinerCap(g,c);
    }
}