//calcul vitesse de l'ordi util
ladate=new Date();
annee=ladate.getYear();
mois=ladate.getMonth();
jour=ladate.getDay();
heure=ladate.getHours();
minute=ladate.getMinutes();
seconde=ladate.getSeconds();
mili=ladate.getMilliseconds();
//a.innerHTML="essai : "+jour+"/"+mois+"/"+annee+" ---- "+heure+":"+minute+":"+seconde+":"+mili;

//----------- calcul temps ecoule ------------
var compt=0;
while (compt<800000)
      {compt++;
	  }
sadate= new Date();
secondefin=sadate.getSeconds();
milifin=sadate.getMilliseconds();
resumili=milifin-mili;
if (resumili<0) resumili=1000+resumili;
var ratio;
ratio=650/resumili;
ratio=Math.round(50*ratio);
//**********************************************************************************

//---------------------------------  tableau des valeurs pour IMGC1---------------------------
var imgc1=new Array(30);                    // tableu compremant 12 lignes
for (var i=0; i<imgc1.length; i++)         
         {imgc1[i]= new Array(26);              //et 10 colones(nbr images modifiables ensemble)
		  imgc1[i][0]=0;                        // QUI         quelle image ecran?
		  imgc1[i][1]=10;                       // DUREE       compteur decompte de temps
		  imgc1[i][2]=60;                       // PROVDUREE   espace de temps entre 2 changement image
		  imgc1[i][3]=0;                        // NUM         quelle image SOURCE (tableau Images[])?
		  imgc1[i][4]=0;                        // BASE        
		  imgc1[i][5]=0;                        // LARG        compteur changement de taille
		  imgc1[i][6]=0;                        // HAUT        
		  imgc1[i][7]=0;                        // PROVLARG    taille maxi de l'image 
		  imgc1[i][8]=0;                        // PROVHAUT    
		  imgc1[i][9]=6;                        // COMBIEN     
		  imgc1[i][10]=10;                      // VIT         vitesse de reduction et agrandissement
		  imgc1[i][11]=0;                       // BUSY
//----------------------------- deplace tableau -------------------------------------------------------
		  imgc1[i][12]=0;                       // MVT     l'objet est t'il en mouvement
		  imgc1[i][13]=0;                       // QUIBOUGE    quelle image ecran bouge?
		  imgc1[i][14]=0;                       // VITESSE quelle vitesse 
		  imgc1[i][15]=0;                       // xa pos arrivee
		  imgc1[i][16]=0;                       // ya pos arrivee	
		  imgc1[i][17]=1;                       // BOUCLE duree du deplacement
		  imgc1[i][18]=0;                       // AVX avancement de l'objet pour X
		  imgc1[i][19]=0;                       // AVY avancement de l'objet pour Y  
          imgc1[i][20]=0;                       //X position r&eacute;ele de l'objet
		  imgc1[i][21]=0;                       //Y position r&eacute;ele de l'objet
//------------------------------ courbe tableau---------------------------------------------------------		
		  imgc1[i][22]=0;                       // COURBE l'image doit elle aller droit ou en courbe
		                                        //si courbe=0 dep droit, courbe=1 dep courbe, courbe =2 dep+courbe
		  imgc1[i][23]=0;                       // AMPLITUDE de la courbe
		  imgc1[i][24]=0;                       // PERIODE de la courbe (nbr de bosse dans courbe) 
		  imgc1[i][25]=0;                       //PAS de la boucle Periode
		  imgc1[i][26]=0;                       //FORMULEX quel type de courbe pour x
		  imgc1[i][27]=0;                       //FORMULEY quel type de courbe pour y
		  imgc1[i][28]=1;                       //Formule quelle type de courbe 
		  imgc1[i][29]=0;                       //decalage 
		 }
var base;		 

//imgc1[1][11]=1;   //busy img ecran 2
//imgc1[1][0]=2;    //change img ecran num2
//imgc1[1][10]=15;   // vitesse de reduction et agrandissement img ecran 2
//------------------------------------- fin de definition des variables du tableau IMGC1 ------------------
//**************************************  FIN VARIABLES EN TABLEAU ******************************************


//************************************** variable fct IMGCHANGE1 ***************************************		 
var courbe,ampli,perio,formulex,formuley,pas,formule;
var provhaut,provlarg;
var num,qui,flagchange;
var duree,provduree;
var busy,combien;
var haut,larg;
var i;
//************************************** fct IMGCHANGE1 ***************************************
//  cette fonction permet de changer n'inporte quelle image de l'ecran par une
//  transition sympa de diminution/augmentation de la taille de l'image
//   10 IMAGES A L'ECRAN peuvent changer en meme temps
//   les differentes variables doivent figurer dans le tableau IMGC1
//*********************************************************************************************
function imgchangeinstant()
  {for (i=0; i<imgc1.length; i++)                //verifier toutes les images du tableau 
     {deplace();
	  tabcharge();                                   //charger les valeurs contenues dans IMGC1 pour chaque image
	  if (busy==1)                                   //effectuer un passage de la routine  si il le faut
	             {if(duree==0)
		                    {document.images[qui].width=Images[base+num].width;      //enregistre taille image max
						     document.images[qui].height=Images[base+num].height;	    
						     document.images[qui].src=Images[base+num++].src;        //change de source image
		                     duree=provduree;
							 if (num>combien-1)
							     {//controle();
								  num=base;                           // combien d'images a faire defiler?     
							     }
							                                    // re initialise la duree
						    }
				  duree--;                                      //decremente la duree
	        	 }  
      tabdecharge();                                //replacer les variables de cette image dans le tableau IMGC1    
	 }
   }
//---------------------------------- fin fct imgchange1 ----------------------------------------

//                 ************ charge et decharge IMGC1 **********
function tabcharge()                                  //charger les valeurs contenues dans IMGC1 pour chaque image
         {qui=imgc1[i][0];                    // QUI         quelle image ecran?
		  duree=imgc1[i][1];                  // DUREE       compteur decompte de temps
		  provduree=imgc1[i][2];              // PROVDUREE   espace de temps entre 2 changement image
		  num=imgc1[i][3];                    // NUM         quelle image SOURCE (tableau Images[])?
		  base=imgc1[i][4];             // FLAGCHANGE  quelle action? attente/reduire/augmenter            
		  larg=imgc1[i][5];                   // LARG        compteur changement de taille
		  haut=imgc1[i][6];                   // HAUT        
		  provlarg=imgc1[i][7];               // PROVLARG    taille maxi de l'image 
		  provhaut=imgc1[i][8];               // PROVHAUT    
		  combien=imgc1[i][9];                // COMBIEN     
		  vit=imgc1[i][10];                   // VIT         vitesse de reduction et agrandissement
		  busy=imgc1[i][11];                  // BUSY
		 }
		  
function tabdecharge()
          {imgc1[i][0]=qui;                    // QUI         quelle image ecran?
		   imgc1[i][1]=duree;                  // DUREE       compteur decompte de temps
		   imgc1[i][2]=provduree;              // PROVDUREE   espace de temps entre 2 changement image
		   imgc1[i][3]=num;                    // NUM         quelle image SOURCE (tableau Images[])?
		   imgc1[i][4]=base;             // FLAGCHANGE  quelle action? attente/reduire/augmenter            
		   imgc1[i][5]=larg;                   // LARG        compteur changement de taille
		   imgc1[i][6]=haut;                   // HAUT        
		   imgc1[i][7]=provlarg;               // PROVLARG    taille maxi de l'image 
		   imgc1[i][8]=provhaut;               // PROVHAUT    
		   imgc1[i][9]=combien;                // COMBIEN     
		   imgc1[i][10]=vit;                   // VIT         vitesse de reduction et agrandissement
		   imgc1[i][11]=busy;                  // BUSY
		 }
    
//***********************************************************************************************		 
		 
//****************************************Fonction CALCUL *************************************
//* calcul de la pente entre A(xd,yd) et B(xa,ya) 
//* avec comme resultat de sortie: avx,avy,boucle 
//* ainsi la formule pour le calcul des nouvelles coordonn&eacute;es de l'objet en mouvement devient:
//*              X= X+avx*vitesse  et Y= Y+avy*vitesse
//********************************************************************************************** 

//......................variables utilis&eacute;es dans calcul................
var xa,ya,xd,yd;
var diffx,diffy;
 
 var r,boucle;
 var sensx,sensy;
 var avx,avy;   
var quibougeprov,quibouge,vitesse; 
//***********************************************************************************************
 function calcul(xd,yd,xa,ya,vitesse,quibouge,courbe,perio,decalage,ampli,formule)
           {diffx= xd-xa;
		    diffy= yd-ya;
		    if (diffx>0)                      //x dans quel sens - ou +
			    {sensx=-1;}                    
            if (diffx<0)                      //diffx<0: diffx devient positif 
			    {sensx=1;
				 diffx=-diffx;}
		    if (diffx==0)
			    {avx=0;
				 avy=1;
				 sensx=0;
                 if (diffy<0)
				     {boucle=-diffy;}
				 else{boucle=diffy;} 
                }                             //fin de test de valeur de diffx
             
		     if (diffy>0)
		       {sensy=-1;}                     //y dans quel sens
		     if (diffy<0)
		       {sensy=1;
			    diffy=-diffy;}                 //diffy passe en positif
		     if (diffy==0)
		       {avx=1;
			    avy=0;
				sensy=0;
				if(diffx<0)
				   {boucle=-diffx;}
				else{boucle=diffx;}
                diffy=1;
			   }                               //fin de test de valeur de diffy
     
	 	 
	 
	  r=diffx/diffy;                           //rapport de pente positif
	  if (r>=1)
	      {avy=1/r;
		   avx=1;
		   boucle=diffx;}
      if (r<1)
          {avx=r;
		   avy=1;
		   boucle=diffy}                           //rapport tjs 0<r<1
	  if (r==0)
	      {avx=0;
		   avy=1;}
	 avx=avx*sensx;                             //diffx positif ou negatif
	 avy=avy*sensy;                             //diffy positif ou negatif
	 boucle=Math.round(boucle/vitesse);
	 pas=perio/boucle;              //defini le PAS de la boucle periode
	 if (pas<0)pas=-pas;                  
	 imgc1[quibouge][13]=quibouge;               // QUIBOUGE        quelle image ecran doit bouger? restitution de donnee
	 imgc1[quibouge][12]=1;                      // metre MVT a 1 pour acceder a DEPLACE// BOUCLE   combien de points de deplacement total?
	 imgc1[quibouge][14]=vitesse;                // VITESSE de deplacement de l'objet
	 imgc1[quibouge][18]=avx;                    // AVX  
	 imgc1[quibouge][19]=avy;                    // AVY             
	 imgc1[quibouge][17]=boucle;                 // charger la boucle BOUCLE    tabchargecal();
	 imgc1[quibouge][20]=xd;                     //X position r&eacute;ele de l'objet
     imgc1[quibouge][21]=yd;                     //Y position r&eacute;ele de l'objet
    imgc1[quibouge][15]=xa; 
	imgc1[quibouge][16]=ya;                      //XA et YA
	imgc1[quibouge][25]=pas;                     
	imgc1[quibouge][24]=perio;
	imgc1[quibouge][23]=ampli;
	imgc1[quibouge][22]=courbe;
	imgc1[quibouge][26]=formulex; 
	imgc1[quibouge][27]=formuley; 
	imgc1[quibouge][28]=formule;           //Formule quelle type de courbe 
	imgc1[quibouge][29]=decalage;           //DECALAGE pour rotation
	}
//......................fin de fonction calcul..........................

//*********************************** DEPLACE**************************************************
var decalage;
var mvt,x,y; 
var nom="gauche";

function deplace()
         {quibouge=imgc1[i][13];                   // QUIBOUGE        quelle image ecran doit bouger?
		           mvt=imgc1[i][12];               // metre MVT a 1 pour acceder a DEPLACE
		           vitesse=imgc1[i][14];           // VITESSE de deplacement de l'objet
		           avx=imgc1[i][18];               // AVX  
		           avy=imgc1[i][19];               // AVY             
		           boucle=imgc1[i][17];            // charger la boucle BOUCLE combien de points de deplacement reste t'il      
				   x=imgc1[i][20];                 //X position r&eacute;ele de l'objet
                   y=imgc1[i][21];                 //Y position r&eacute;ele de l'objet
				   ampli=imgc1[i][23];             //defini l'amplitude de la courbure                    
				   courbe=imgc1[i][22];            //defini le type de deplacement
				   perio=imgc1[i][24];             //defini la periode de la courbe
				   pas=imgc1[i][25];               //defini le pas pour la periode
				   formulex=imgc1[i][26];          // forme de la courbe en x
				   formuley=imgc1[i][27];          // forme de la courbe en y
				   formule=imgc1[i][28];           //Formule quelle type de courbe 
				   decalage=imgc1[i][29]           //DECALAGE
				   if (mvt==1)
				      {switch(quibouge)
					                   {case 0:nom="a";
										break;
									   case 1:nom="b";
										break;
										case 2:nom="c";
										break;
										case 3:nom="d";
										break;
										case 4:nom="e";
										break;
										case 5:nom="f";
										break;
										case 6:nom="g";
										break;
										case 7:nom="h";
										break;
										case 8:nom="i";
										break;
										case 9:nom="j";
										break;
										case 10:nom="k";
										break;
										case 11:nom="l";
										break;
										case 12:nom="m";
										break;
										case 13:nom="n";
										break;
										case 14:nom="o";
										break;
										case 15:nom="p";
										break;
										case 16:nom="q";
										break;
									   }
					  switch(formule)
					                   {case 1:formulex=Math.round(ampli*Math.cos(perio+decalage));//cercle
									           formuley=Math.round(ampli*Math.sin(perio+decalage));
									    break;
									    case 0:formulex=Math.round(ampli*Math.cos(perio+decalage));//cos
										        formuley=0;
										break;		
									    case 2:formulex=0;
										        formuley=Math.round(ampli*Math.sin(perio+decalage));//sin
										break;		
									    case 3:formulex=Math.round(1.3*ampli*Math.cos(perio+decalage));//elipse
									           formuley=Math.round(ampli*Math.sin(perio+decalage));
									    break;
									   }
									   
					  if (courbe==2)                             // courbe uniquement              
						  {x=imgc1[i][15]+formulex;         // nouvelle valeur de x
					       y=imgc1[i][16]+formuley;        // nouvelle valeur de y 
						  }
					  else                                       //deplacement incorpore
					      {x=x+Math.round(avx*vitesse);          // nouvelle valeur de x
					       y=y+Math.round(avy*vitesse);          // nouvelle valeur de y 
						  }	   
					  // x=Math.round(Math.cos(boucle/10)*180+330);               // nouvelle valeur de x
					  // y=Math.round(Math.sin(boucle/10)*130+250);               // nouvelle valeur de y 
					   perio=perio-pas;				   
					   boucle--;                                          //decrementer la boucle pour duree dep
					   if (boucle<0)                                      //si boucle =0 alors stop 
					               {mvt=0;
								    if (courbe!=2)
									    {x=imgc1[i][15];                             //
									     y=imgc1[i][16];                             //positionne l'objet a sa pos d'arrivee
								        }
								   }
					  //document.write("formule="+formule+"formulex="+formulex+" formuley="+formuley); 
					  switch (courbe)
					           {case 0:document.all[nom].style.left=x ;                // nouvelle valeur de x (deplacement)affecte a image quibouge
					                   document.all[nom].style.top=y ;                 // nouvelle valeur de y (deplacement)		   					              	 
				                break;       
				                case 1:document.all[nom].style.left=x+formulex;        // nouvelle valeur de x (dep+courbe)affecte a image quibouge
					                   document.all[nom].style.top=y+formuley;         // nouvelle valeur de y (dep+courbe)	
				                break;
								case 2:document.all[nom].style.left=x ;                // nouvelle valeur de x (courbe)affecte a image quibouge
					                   document.all[nom].style.top=y ;                 // nouvelle valeur de y (courbe)	
							    break;
							   }
				   	
					  imgc1[i][12]=mvt;                             // sauver MVT  pour deplacement ou non
		              imgc1[i][17]=boucle;                          // sauver la boucle BOUCLE combien de points de deplacement reste t'il  dechargedep();                                      
				      imgc1[i][20]=x;                               //X position r&eacute;ele de l'objet
                      imgc1[i][21]=y;                               //Y position r&eacute;ele de l'objet
					  imgc1[i][24]=perio;             //defini la periode de la courbe
				      imgc1[i][25]=pas;               //defini le pas pour la periode
					  imgc1[i][29]=decalage;               //
			    	               }
		}
//*****************************************************************
function cligno(e)
         {n++;
		  if (n==20)
		      {document.all[e].style.color="#ff2222";}
		  if (n==28)
		      {document.all[e].style.color="#ebe2ad";}
		  if (n==36)
		      {document.all[e].style.color="#ddd39b";}
		  if (n==44)
		      {document.all[e].style.color="#f3ecc7";
			   n=0;
			  }	  
		 }
		 


         


//******************************************* DEMARAGE ***********************************
function init()
         {window.setInterval("imgchangeinstant()",ratio);
		  
		  //window.setInterval("chargeur()",50);
		  }
init();