Avance avan;
Tortue tortu;
Vecteur posi,angl;

/////////////////////////////////////////////////////////////////////////////////////
//SETUP
/////////////////////////////////////////////////////////////////////////////////////

void setup(){
        size(750,600);
        background(255);
         lights();
         fill(255,255,255);noStroke();
         tortu=new Tortue();  
   
push();
}
/////////////////////////////////////////////////////////////////////////////////////
//LOOP
/////////////////////////////////////////////////////////////////////////////////////
void loop(){ 
      push();  
            rotateX(-0.8);
            tortu.moteur();
      pop();

}

/////////////////////////////////////////////////////////////////////////////////////
//CLASSE INSTRUCTION
/////////////////////////////////////////////////////////////////////////////////////

abstract class Instruction{   
public abstract void executer();
}
/////////////////////////////////////////////////////////////////////////////////////
//CLASSE AVANCE
/////////////////////////////////////////////////////////////////////////////////////

class Avance extends Instruction{
     
        public String  nom;
        float inc,but,pos;
        int compteur,compteur0;       
        Tortue latortue;
        
        //-----------------------------------------------------   
             
        public Avance(Tortue latortue,float but){
               this.latortue=latortue;
               this.but=but;
               this.pos=0;
               this.nom="avance";     
               this.compteur0=(int)Math.ceil(but/8);
               if(compteur0>0)  this.inc=but/compteur0;
               this.compteur=compteur0;
        }
         //-----------------------------------------------------       
     
        public void executer(){ println(nom);
            latortue.dessiner();     
                if(  --compteur<=0){
                          latortue.instFin=true;          
                           translate(but/2,0,0);
                        lights();
                          box(but,66,22); 
                          translate(but/2,0,0);
                          latortue.pile.addElement(new Vecteur(but,0,0,1)); 
                          compteur=compteur0;
                          pos=0;//remise en etat                         
                   }
               else{ 
                      pos+=inc;               
                       push(); 
                           translate(pos/2,0,0);
                           fill(255,255,255);noStroke();lights();
                            box(pos,66,22); 
                           translate(pos/2,-118+33,0);
                           noLights();fill(181,180,211);stroke(250,250,250);
                           box(22,-236,22); 
                                            fill(255,255,255); noStroke();
                            latortue.lacamera.lookx=objectX(0,0,0);
                            latortue.lacamera.looky=objectY(0,0,0);
                            latortue.lacamera.lookz=objectZ(0,0,0);
                            latortue.lacamera.posx=objectX(414,-902,0);
                            latortue.lacamera.posy=objectY(414,-902,0);
                            latortue.lacamera.posz=objectZ(414,-902,0);
                             latortue.lacamera.placercamera();
                       pop();          
                  }   
 
        }
        //-----------------------------------------------------  
}
/////////////////////////////////////////////////////////////////////////////////////
//CLASSE TOURNE
/////////////////////////////////////////////////////////////////////////////////////

class Tourne extends Instruction{
        public  String  nom;
        float incy,incz,butz,posz,buty,posy;
        int compteur,compteur0;
        Tortue latortue;
        
        //-----------------------------------------------------        
        public Tourne(Tortue latortue,float angly,float anglz){
                 this.latortue=latortue;
                 this.buty=angly;
                 this.posy=0;
                 this.butz=anglz;
                 this.posz=0;
                 this.nom="tourne";
                 this.compteur=(int)Math.ceil(dist(0,0,buty,butz)/0.15);
                 this.compteur0=compteur;
                  if(compteur0>0)  {this.incy=buty/compteur0;this.incz=butz/compteur0;};
        }    
        //-----------------------------------------------------
        public void executer(){ println(nom);          
              float d;  
              
               latortue.dessiner();
                if(  --compteur<=0){
                    latortue.instFin=true;  
                rotateZ(butz);
               rotateY(buty);
                     latortue.pile.addElement(new Vecteur(0,buty/2,butz/2,0)); 
                   latortue.pile.addElement(new Vecteur(0,22,0,1)); 
                    latortue.pile.addElement(new Vecteur(0,buty/2,butz/2,0)); 
                     compteur=compteur0;
                     posy=0;//remise en etat       
                   }
               else{ 
                      posy+=incy;
                      posz+=incz;  
                       push(); 
                            rotateZ(posz);
                           rotateY(posy);
                            translate(0,-118+33,0);
                            noLights();fill(181,180,211);
                            stroke(250,250,250);
                            box(22,-236,22); 
                            fill(255,255,255);
                             noStroke();
                            latortue.lacamera.posx=objectX(414,-902,0);
                            latortue.lacamera.posy=objectY(414,-902,0);
                            latortue.lacamera.posz=objectZ(414,-902,0);
                            latortue.lacamera.placercamera();
                       pop();                                 
                  }                
        }
        //-----------------------------------------------------  
}

/////////////////////////////////////////////////////////////////////////////////////
//CLASSE ARRET
/////////////////////////////////////////////////////////////////////////////////////

class Arret extends Instruction{   
  
        Tortue latortue;
        String nom;        
        public Arret(Tortue latortue){
        this.latortue=latortue;     
        this.nom="arret";
        }
        
        public void executer(){println(nom);
              latortue.termine=true;
              latortue.instFin=true;}
          
        }
/////////////////////////////////////////////////////////////////////////////////////
//CLASSE REPETE
/////////////////////////////////////////////////////////////////////////////////////

class Repete extends Instruction{
         String nom="repete";
        int compteur,compteur0;
        Tortue latortue;
        //-----------------------------------------------------        
        public Repete(Tortue latortue,int compteur){
                 this.latortue=latortue;            
                 this.compteur=compteur;
                  this.compteur0=compteur;             
                 this.nom="repete";
        }
      
        //-----------------------------------------------------
        public void executer(){ println(nom); 
            if(compteur==0){//la boucle est finie
                int bee=0;
                int clos=0;
                int lign= latortue.ligne;
                do{
                       lign++;      
                       if(latortue.listing[lign] instanceof Ouvre) bee++;
                       if(latortue.listing[lign] instanceof   Ferme) clos++;
                 }while(bee != clos);
                   latortue.ligne=lign;
                   compteur=compteur0;//remise en etat
               }else{
               compteur--;
                    }
 latortue.instFin=true; 
 }  
   }   
/////////////////////////////////////////////////////////////////////////////////////
//CLASSE FERME
/////////////////////////////////////////////////////////////////////////////////////

class Ferme extends Instruction{
       String nom;
  
        Tortue latortue;
        //-----------------------------------------------------        
        public Ferme(Tortue latortue){
                 this.latortue=latortue;
                 this.nom="ferme";            
              
        }
      
        //-----------------------------------------------------
        public void executer(){ println(nom); 
        String lnom;         
           
                int bee=0;
                int clos=1;
                int lign= latortue.ligne;
                do{
                      lign--;
                       if(latortue.listing[lign] instanceof Ouvre) bee++;
                       if(latortue.listing[lign] instanceof   Ferme) clos++;
                       }while(bee != clos);
               latortue.ligne=lign-1;           
               latortue.instFin=false; 
   } 
 }
/////////////////////////////////////////////////////////////////////////////////////
//CLASSE OUVRE
/////////////////////////////////////////////////////////////////////////////////////

class Ouvre extends Instruction{ 
        String nom;
        Tortue latortue;
     
        public Ouvre(Tortue latortue){
        this.latortue=latortue;
        this.nom="ouvre"; 
        }
        
        public void executer(){println(nom);
   
          latortue.instFin=true;}
          
        }  
              
/////////////////////////////////////////////////////////////////////////////////////
//CLASSE VAEN
/////////////////////////////////////////////////////////////////////////////////////

class VaEn extends Instruction{ 
   String nom;
        Tortue latortue;
        int lign;
        public VaEn(Tortue latortue,int lign){
        this.latortue=latortue;
        this.lign=lign;
        this.nom="vaen";    
        }
        
        public void executer(){println(nom);
          latortue.ligne=lign-1;
          latortue.instFin=true;}
          
        }  
        
                    
/////////////////////////////////////////////////////////////////////////////////////
//CLASSE  TORTUE
/////////////////////////////////////////////////////////////////////////////////////
class Tortue{
          Camera lacamera;
          boolean instFin,termine;
          Vector pile;
          int ligne;
           Instruction[]  listing={
                          new Avance(this,50),
                           new  Repete(this,12),
                                new Ouvre(this),
                                                                                         
                                      new Tourne(this,0,PI/2),
                                     new  Avance(this,300), 
                                        new Tourne(this,0,-PI/2),
                                       
                                    new Repete(this,6),
                                            new Ouvre(this),
                                                 new  Avance(this,100),              
                                                  new Tourne(this,PI/3,0),
                                           new Ferme(this),
                                           
                                          new Tourne(this,0,-PI/2),
                                     new  Avance(this,300),   
                                        new Tourne(this,0,PI/2),
                                        
                                          new  Tourne(this,-PI/6,0),
                                           new Avance(this,170),
                                 new Ferme(this),
                           new Arret(this)
                           };                       
            
        //-----------------------------------------------------
public Tortue(){
         pile=new Vector();
         instFin=false;
         termine=false;
        this.ligne=0;
       this.listing=listing;
        this. lacamera=new Camera();     
}
 
        //-----------------------------------------------------
 void dessiner(){
    clear();
    Iterator ite=pile.iterator();
        while(ite.hasNext()){
              Vecteur v=(Vecteur)ite.next();
              if(v.t!=0){
                    if(v.x!=0){
                      translate(v.x/2,0,0);
                     fill(255,255,255);noStroke();lights();
                      box(v.x,66,22);
                      translate(v.x/2,0,0);}
                      else{
                      noLights();fill(181,180,211);stroke(250,250,250);
                      translate(0,-17,0);
                       box(22,66+34,22);
                          translate(0,17,0);                  
                       }
              }else{
                      rotateZ(v.z);
                      rotateY(v.y);
                      rotateX(v.x);
                }
         }    
    }
    //--------------------------------------------------------------
     void moteur(){
           if(!termine){
                 if(instFin){
                              if(ligne<listing.length-1){
                                            instFin=false;
                                            ligne++;      
                                            listing[ligne].executer();
                                     }
                                   else{
                                             termine=true;
                                     }
                  }   
                   else{
                             listing[ligne].executer();
                            }
                   }
             }
   }
/////////////////////////////////////////////////////////////////////////////////////
//CLASSE VECTEUR
/////////////////////////////////////////////////////////////////////////////////////

 class Vecteur{

		  float x,y,z,t;
		  

	public   Vecteur(float x1,float y1,float z1){
	    this.x=x1;
	    this.y=y1;
	    this.z=z1;
	    this.t=0;
  }

        public  Vecteur(){
	    x=0;
	    y=0;
	    z=0;
            t=0;
  }
	public   Vecteur(float x1,float y1,float z1,float t){
	    this.x=x1;
	    this.y=y1;
	    this.z=z1;
	    this.t=t;
  }


  void normer(){
	  float lg=longueur();
	  if(lg!=0) {
		  x/=lg;
		  y/=lg;
		  z/=lg;}
  }

  Vecteur anguler(){
    float alfa=atan2(y,x);
    float beta=atan2(z,dist(0,0,x,y));
    return (new Vecteur(0,beta,alfa));
  }

  float produitscalaire(Vecteur v){
	  return x*v.x+y*v.y+z*v.z;}

  Vecteur produitvectoriel(Vecteur w){
	    Vecteur p=new Vecteur(0,0,0);
	    p.x=y*w.z-w.y*z;
	    p.y=z*w.x-w.z*x;
	    p.z=x*w.y-w.x*y;
    return p;
  }
  float distance(Vecteur v){
	    float dis=ajouter(v,-1).longueur();
    return dis;
  }

  float longueur(){
	  return dist(0,0,0,x,y,z);
  }

  void multiplier(float m){
	    x*=m;
	    y*=m;
	    z*=m;
  }
  Vecteur multiplie(float m){
	   return new Vecteur(x*m,y*m,z*m);
  }
   void ajoute(Vecteur v,float m){
		x+=v.x*m; y+=v.y*m;z+=v.z*m;
    
  }
  Vecteur ajouter(Vecteur v,float m){
		Vecteur res=new Vecteur(x+v.x*m, y+v.y*m,z+v.z*m);
    return res;
  }
  Vecteur composantesAbs(){
	    float xx=objectX(x,y,z);
	    float yy=objectY(x,y,z);
	    float zz=objectZ(x,y,z);
	return new Vecteur(xx,yy,zz);
  }

}
////////////////////////////////////////////////////
//CLASSE CAMERA
////////////////////////////////////////////////////
class Camera {
	float fov,   nearDist, farDist, aspect;
	float posx,posy,posz,lookx,looky,lookz;

public Camera(){

		
		fov = 70;
		nearDist = 400 / 1000.0f;
		farDist = 400 * 10000.0f;
		aspect = (float)width/ (float)height;
}

  void placercamera(){
    beginCamera();
            perspective(fov, aspect, nearDist, farDist);
            lookat(posx,posy,posz,lookx,looky,lookz,0,1,0);
          
    endCamera();
   }
   }