/*//////////////////////////////////////////////////////////////
//                 PROGRAMME D'ALUMINERIE                     //
//                      REALISE PAR:                          //
//                                                            //
//                    ANTOINE PELLETIER                       //
//                   PHILLIPE  HENNIGES                       //
//                    MARTIN   GAGNON                         //
//                    FREDERIC RUEL                           //
//                                                            //
//                    AUCUN DROIT RESERVE                     //
//                                                            // 
////////////////////////////WAZO//////////////////////////////*/


#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include <dos.h>
#include <string.h>



//Affaire qui sera utiliser dans la parti 3 du projet
typedef struct FOURNISSEUR_ELEC
{
 unsigned char nom[30];
 double coutkw;
};


/*////////////////////////// CLASSE TIME////////////////////////////////

Pour tout ce qui touche le temps dans toute les classe la classe time 
sera utiliser. Tout les classe qui on besoin d'une référence sur le
temps recoive un pointeur de la variable de temps initialiser dans le 
main. Donc tout les classe connaise le temps qui est avance dans le 
main
///////////////////////////////////////////////////////////////////////*/

const long UNEHEURE = 60L;

class Ttime
{
 private:
 long temps; // Le temps est en minutes et commence le premier Lundi de la simulation a 0h00
 int basetemps;

 public:
	Ttime(int basevoulue)
	{
		temps=0L;
		basetemps=basevoulue;
	};

	~Ttime(){};
	void Avance(void);
	int GetMinute(void) {return (temps%60);};
	int GetHeure(void) {return ((temps%1440)/60);};
	int GetJour(void) {return ((temps%10080)/1440);};
	int GetSemaine(void) {return (temps/10080);};
	long GetTemps(void){return temps;};
	void AfficheHeure(void);
};


void Ttime::Avance(void)
{
	temps+=basetemps;
}

void Ttime::AfficheHeure(void)
{
	printf("Jour: %2d Heure: %2d:%2d\n",GetJour(),GetHeure(),GetMinute());
}



/*///////////////////////////ENTREPOT//////////////////////////


Voici la classe entrepot qui gere l'entrepot. Les fonctions 
font ce que leur nom signifie. 

/////////////////////////////////////////////////////////////*/
class Tentrepot
{
	private:
		int nbrangecabaret;
		int nbrangebenne;
		char derniererreur[100];
		int erreur;
		int nbbennevide;
		int nbbennepleine;
		int nbanodes;
		int nbmegots;
		Ttime *temps;

		typedef struct S_CABARET
		{
		 int nombre;
		 int type; //0=Range vide 1=Anode 2=Megot
		 long temps;
		};

		typedef struct S_BENNE
		{
			int nombre;
			long temps;
		};

		S_CABARET cabaret[2000];
		//S_CABARET *cabaret; //Voir dans le constructeur pourquoi on ne crée plus la variable de meme
		S_BENNE benne[2000];
		//S_BENNE *benne; //Voir dans le constructeur pourquoi on ne crée plus la variable de meme
		Tentrepot(){};  	// Constructeur vide

	public:
		Tentrepot(int nbrcabaret, int nbrbenne, int nbbvide, int nba, int nbm,Ttime &tempsaddr);
    //On initialise avec le nb de rangé de cabaret et benne. Le nombre de benne et de cabaret
    //d'anode et de megot. Et envoyé une reference de la variable de temps 
		~Tentrepot();
		int RecoieCabaretMegots(void); //Echange avec Electrolyse
		int EnvoieCabaretAnodes(void);
		int RecoieBennesPleines(void);
		int EnvoieBennesVides(void);
		int RecoieCabaretAnodes(void); // Echange avec Scellement
		int EnvoieCabaretMegots(void);
		long NombreAnodes(void);
		long NombreMegots(void);
		long NombreBennesVides(void);
		long NombreBennesPleines(void);
		void AfficherMsg(void);
		void SetErrorFlag(char *); //On envoit le message d'erreur et met a 1 le flag d'erreur
		int BitErreur(void){return erreur;}; //Fonction qui nous renvoie l'etat du flag d'erreur

};

long Tentrepot::NombreAnodes(void)//Calcule le nombre d'anode dans les ranges
{
	long nombre=0;
	for (int i=0;i<nbrangecabaret;i++)
	{
	 if (cabaret[i].type==1)//Type 1 signifie que le cabaret a des anodes
		nombre+=cabaret[i].nombre;
	}
	return nombre;
}

long Tentrepot::NombreMegots(void)//Calcule le nombre de megot dans les ranges
{
	long nombre=0;
	for (int i=0;i<nbrangecabaret;i++)//Type 2 signifie que le cabaret a des megot
	{
	 if (cabaret[i].type==2)
		nombre+=cabaret[i].nombre;
	}
	return nombre;
}

long Tentrepot::NombreBennesVides(void)
{
	long nombre=0;
	for (int i=0; i<nbrangebenne; i++)
	{
	 if ((benne[i].temps + 24*UNEHEURE) < temps->GetTemps()) //Apres 24 heures la benne a refroidit est comme par magie vide
		nombre+=benne[i].nombre;
	}
	return nombre;
}

long Tentrepot::NombreBennesPleines(void)
{
	long nombre=0;
	for (int i=0; i<nbrangebenne; i++)
	{
	 if ((benne[i].temps + 24*UNEHEURE) > temps->GetTemps())
		nombre+=benne[i].nombre;
	}
	return nombre;
}

void Tentrepot::AfficherMsg (void)
{
 if (erreur)
	cout<<endl<<derniererreur;
 else
	cout<<"ENTREPOT:"<<NombreAnodes()<<" anodes,"<<NombreMegots()<<" megots,"<<NombreBennesVides()<<" bennes vides et "<<NombreBennesPleines()<<" pleines."<<endl;
}

void Tentrepot::SetErrorFlag(char *data)
{
 erreur=1;
 strcpy(derniererreur,data);
}

Tentrepot::Tentrepot(int nbrcabaret, int nbrbenne, int nbbvide, int nba, int nbm, Ttime &tempsaddr)
{
	nbrangecabaret = nbrcabaret;
	nbrangebenne = nbrbenne;
	nbbennevide = nbbvide;
	nbanodes = nba;
	nbmegots = nbm;
	nbbennepleine = 0;
	erreur=0;
	temps = &tempsaddr;

//La declaration de cabaret et benne na pas ete fait avec de l'allocation dynamique de memoire
//pour faciliter le debogueage. En mettant des tableau il etait plus facile de voir la valeur
//des variable avec la commande de debug inpect dans Turbo C. Mais le programme peut fonctionner
//avec l'allocation dynamique de memoire.


//  cabaret=new S_CABARET [nbrangecabaret]; 
//  benne=new   S_BENNE [nbrangebenne];

//if (!benne)
// exit(1);
//if(!cabaret)
// exit(1);
	int i;
	


	for (i=0;i<nbrcabaret;i++)//Initialiser les variable à 0
	{
	 cabaret[i].type=0;
	 cabaret[i].nombre=0;
	 cabaret[i].temps=0L;
	}
	for (i=0;i<nbrangebenne;i++)//Initialiser les variable à 0
	{
	 benne[i].nombre=0;
	 benne[i].temps=0L;
	}

	//Remplit les ranges avec le nombre de bennes vides definit par l'utilisateur
	for (i=0; i<nbrangebenne && nbbvide; i++)
	{
	 if (nbbvide>14)
	 {
		benne[i].nombre=14;
		benne[i].temps=-24*UNEHEURE;
		nbbvide-=14;
	 }
	 else
	 {
		benne[i].nombre=nbbvide;
		benne[i].temps=-24*UNEHEURE;
		nbbvide=0;

	 }
	}

	if (nbbvide) //Il reste des benne qui ne se place pas dans les rangees
	{
	 cout<<"Il y a trop de benne pour le nombre de rangee";
	}


	//Remplit les ranges de cabaret avec le nombre de cabaret d'anode
	for (i=nbrcabaret-1; nba && i>=0; i--)
	{
	 if (nba>6) //nba pour nombre de cabaret d'anode. Si il y en a assez pour remplir une rangée
	 {
		cabaret[i].nombre=6;
		cabaret[i].type=1;
		nba-=6;
	 }
	 else
	 {
		cabaret[i].nombre=nba;
		cabaret[i].type=1;
		nba=0;
	 }
	}

	if (nba) //Il reste des cabaret qui ne se place pas dans les rangees
	{
	 cout<<"Il y a trop de cabarets d'anode pour le nombre de rangee";
	}

	for (i=nbrcabaret-1; nbm && i>=0 ; i--) //Meme affaire avec le megot
	{
	 if (cabaret[i].type==0)
	 {
		if (nbm>6)
		{
		 cabaret[i].nombre=6;
		 cabaret[i].type=2;
		 cabaret[i].temps=-4*UNEHEURE;//Pour que le temps d'attende de 4 heures soit deja passe quand on calcule
		 nbm-=6;
		}
		else
		{
		 cabaret[i].nombre=nba;
		 cabaret[i].type=2;
		 cabaret[i].temps=-4*UNEHEURE;
		 nbm=0;
		}
	 }
	}

	if (nbm) //Il reste des benne qui ne se place pas dans les rangees
	{
	 cout<<"Il y a trop de cabarets de megot pour le nombre de rangee";
	}

}


Tentrepot::~Tentrepot(void)
{
//	if (benne) delete[] benne ; //Si on aurait fonctionnner avec l'allocation dynamique de memoire
//if (cabaret) delete[] cabaret ;
}


int Tentrepot::RecoieBennesPleines(void)
{
 int i=0;
 while(i<nbrangebenne &&( benne[i].nombre>12//Va a la premiere rangee libre qui a encore 2 place
			 ||  ((benne[i].temps + 24*UNEHEURE) < temps->GetTemps())&&benne[i].nombre>0 ))
			 i++; //le i++ fait un scan des ranges
 if (i==nbrangebenne) //Tout est plein, il manque de place
 {
	SetErrorFlag("Il n'y a plus de places pour les bennes pleines");
	return 0;
 }
 benne[i].nombre+=2;
 benne[i].temps=temps->GetTemps(); //On fait une copie du temps present pour savoir quand la ranges s'est remplit
 return 1;
}


int Tentrepot::EnvoieBennesVides(void) //Les benne voyages par 2 ce qui explique les S 
{
 int i=0;

 while(i<nbrangebenne && (benne[i].nombre<2 //On va a la premiere range avec au moin 2 benne vide
			||((benne[i].temps + 24*UNEHEURE) > temps->GetTemps())))
	 i++;
 if (i==nbrangebenne) //Pas de benne vide
 {
	SetErrorFlag("Il n'y a plus de bennes vide");
	return 0;
 }
 benne[i].nombre-=2;
 if (benne[i].nombre==0) //Si il n'y a plus de benne on reset le temps de la rangé au cas ou un fonction regardant si ca fait plus que 24 heures pense que c'est de bennes vides quand il n'y en a plus
	benne[i].temps=0;
 return 1;
}


int Tentrepot::RecoieCabaretMegots(void)	 // Echange avec Salle de Electrolyse
{
 int i=0;
 while(i<nbrangecabaret && (cabaret[i].nombre==6 || cabaret[i].type==1)) //Cherche une range vide ou range de megot commence
	 i++;
 if (i==nbrangecabaret) //Tout est plein, il manque de place
 {
	SetErrorFlag("Il n'y a plus de place pour les megot");
	return 0;
 }
 cabaret[i].nombre++;
 cabaret[i].type=2;
 cabaret[i].temps=temps->GetTemps(); //On fait une copie du temps present pour savoir quand le dernier megots est arrive
 return 1;
}

int Tentrepot::EnvoieCabaretAnodes(void)
{
 int i=0;
 while(i<nbrangecabaret && (cabaret[i].nombre==0 || cabaret[i].type!=1)) //Cabaret ==1 signifie une rangee de anode
	 i++;
 if (i==nbrangecabaret) //Aucune anode
	return 0;
 cabaret[i].nombre--;
 if (cabaret[i].nombre==0) //Si plus d'anode
	cabaret[i].type=0; //La range n'est plus reserve au anodes
 return 1;
}





int Tentrepot::EnvoieCabaretMegots(void)   // Echange avec Salle de Scellement
{
 int  i=0;
 while(i<nbrangecabaret && (cabaret[i].nombre==0 || cabaret[i].type!=2 //Cabaret ==2 signifie une rangee de megot
			 || ((cabaret[i].temps + 4*UNEHEURE) > temps->GetTemps()))) // Et ca fait au moins 4 heures
	 i++;
 if (i==nbrangecabaret) //Aucune anode trouve dans les rangee
	return 0;
 cabaret[i].nombre--;
 if (cabaret[i].nombre==0) //Si plus d'anode
	cabaret[i].type=0; //La range n'est plus reserve au anodes
 return 1;
}


int Tentrepot::RecoieCabaretAnodes(void)
{
 int i=0;
 while(i<nbrangecabaret && (cabaret[i].nombre==6 || cabaret[i].type==2)) //Cabaret !=2 car 2 signifie une rangee de megot
	 i++;
 if (i==nbrangecabaret) //Tout est plein, il manque de place
 {
	SetErrorFlag("Plus de place pour recevoir un cabaret d'anode");
	return 0;
 }
 cabaret[i].nombre++;
 cabaret[i].type=1;
 return 1;
}




/*///////////////////////////SCELLEMENT/////////////////////////

Voici la classe de scellement qui repare les megots en les 
transformant en anodes. Cette classe a un taux de reparation 
de 67 megots a l'heure. Si on change le pas de production 
contrairement a l'electrolyse le taux sera  le meme a chaque 
heure.


//////////////////////////////////////////////////////////////*/
const double TAUXPRODSCEL = 67;
class Tscellement
{
	private:

		Ttime *temps;
		Tentrepot *entrepot;
		double nbmegots;
		double nbanodes;
		int basetemps;
		char fichiertravail[255];

		int TravailsTu (void);
		void EnvoieAnodes(void);
		void RecoieMegots(void);
		void RepareMegots(void);
		void EnregistreDansFichier(); //Fonction non  ecrite
		Tscellement(){};			//Pour empecher le client de l'appeler

	public:

		// Constructeur de la classe
		Tscellement (int basevoulue, Tentrepot &entrepotaddr,
								 Ttime &tempsaddr, char *fichiertravailaddr);

		~Tscellement(){};

		void Travail(void);
		void AfficherMsg(void);
};


int Tscellement::TravailsTu (void)
{
	return ((temps->GetHeure() % 8)==7? 0:1); //Renvoie 1 si travail, 0 si de 7 . 8, de 13 . 4, de 23 . 24
}


Tscellement::Tscellement (int basevoulue, Tentrepot &entrepotaddr,
													Ttime &tempsaddr,char *fichiertravailaddr)
{
 temps = &tempsaddr;
 entrepot = &entrepotaddr;
 strcpy (fichiertravail , fichiertravailaddr);

 basetemps = basevoulue;
 nbmegots = 0;
 nbanodes = 0;
}




void Tscellement::EnvoieAnodes(void)
{

 int succes=1;
 while( nbanodes>=6 && succes)
 {
	succes = entrepot->RecoieCabaretAnodes();
	if (succes)
	{
		//cout<<"Scellement: Envoie de 6 anodes\n"; //Pour du debug
		nbanodes -= 6;
	}
 }

}


void Tscellement::RecoieMegots(void)
{
 int succes=1;

 while(succes)
 {

	succes = entrepot->EnvoieCabaretMegots();
	if (succes)
	{
		//cout<<"Scellement: Recoie de 6 megots\n"; //Pour du debug
		nbmegots += 6;
	}
 }
}


void Tscellement::RepareMegots(void)
{
 double nombre;
 if (nbmegots<(TAUXPRODSCEL*((1.0*basetemps)/60.0))) //Si on a un pas de 5 min on fait 5/60 de la production de l'heure
	nombre=nbmegots;
 else
	nombre=(TAUXPRODSCEL*((1.0*basetemps)/60.0));
 nbmegots-=nombre;
 nbanodes+=nombre;
}


void Tscellement::Travail(void)
{
	if (TravailsTu()) //Car trois heure pas jour minimum il ne travaille pas
	{
		if (nbmegots)
		 RepareMegots();
		RecoieMegots();

 //if (!nbmegots)
 //		EnregistreDansFichier();
		EnvoieAnodes();
	}


}


void Tscellement::EnregistreDansFichier()
{
// cout<<"Scellement: On enregistre dans le fichier \n";
}

void Tscellement::AfficherMsg(void)
{
 cout<<"Scellement : Anode:"<<nbanodes<<" Megots:"<<nbmegots<<endl;
 if (TravailsTu())
 {
	if (!nbmegots)
		cout<<"Scellement: Travail pour rien \n";

	else
		cout<<"Scellement: On travaille      \n";
 }
 else
	cout<<"Scellement: Pause cafe   \n";
}



/////////////////////////////FONDERIE/////////////////////////////
class Tfonderie
{
	private:
		int *nocreuset; //Contient les numeros des creusets en coule
		int nocreusetrempl[3]; // Contient les numeros des creusets en remplissage
		int nbcoule;//nbcreuset total dans la fonderie
		Tfonderie(){};
	public:
		Tfonderie(int basevoulue);
		void AfficherMsg(void);
		void EchangerCreuset(void) ;  // renvoie le numero du creuset vide
		~Tfonderie();
};



Tfonderie::Tfonderie(int basevoulue)
{
	for (int i=0; i<=2; i++)
	{
		nocreusetrempl[i]=i+1;
	}
	switch (basevoulue)
	{
		case 5 : 	nbcoule=18 	;	break ;
		case 10:  nbcoule=9 	;	break ;
		case 15:	nbcoule=6 	; break ;
		default : nbcoule=6;
	}
	nocreuset=new int [nbcoule];
	for (i=0; i<nbcoule; i++)
	{
		nocreuset[i]=0;
	}
}

Tfonderie::~Tfonderie(void)
{
	if (nocreuset) delete[] nocreuset ;
	if (nocreusetrempl) delete[] nocreusetrempl ;
}


void Tfonderie::AfficherMsg(void)
{
	cout<<"Numero des creusets en coule: {";
	for (int i=0; i<nbcoule; i++)
	{
		cout<<nocreuset[i]<<" ";
	}
	cout<<"}"<<endl;
}

void Tfonderie::EchangerCreuset(void)
{
	static int nocr=0;   //Variable utilise lors de l'indexage de creuset a zero.
	int echg ;
		if (!nocreuset[0])
		{
			nocreuset[0]=nocr+4;
			nocr++;
		}
		echg = nocreusetrempl[0];
		for(int i=0; i<2; i++)
		{
			nocreusetrempl[i]=nocreusetrempl[i+1] ;
		}
		 nocreusetrempl[2]=nocreuset[0];
		for(i=0; i<nbcoule; i++)
		{
			nocreuset[i]=nocreuset[i+1] ;
		}
		nocreuset[nbcoule-1]=echg ;
}

////////////////////////ELECTROLYSE/////////////////////////


const double NBANODESTOTAL = (40*132*2);

const double TAUXPRODMEGOTS = (19.9/4); //taux de production de megots
																						//par pas de simulation
const double TAUXPRODBENNES = (3.5/4); //Taux de remplissage de bennes
																					 // par pas de simulation

class Telectrolyse
{
	private:

		FOURNISSEUR_ELEC electricite;
		Ttime *temps;
		Tentrepot *entrepot;
		Tfonderie *fonderie;
		double nbmegots;
		double nbanodes;
		double nbbennespleines;
		double nbbennesvides;
		char fichierkw[255];
		int basetemps;

		Telectrolyse(){};	//Pour empecher le client de l'appeler
		void EchAnodesMegots(void);
		void EchBennes(void);


	public:

		int Travail(void);

		// Constructeur de la classe
		Telectrolyse(int basevoulue, Tentrepot &entrepotaddr,
								 Tfonderie &fonderieaddr, Ttime &tempsaddr,
								 char *fichierkwaddr);

		void AfficherMsg(void);
		~Telectrolyse(){};
};

Telectrolyse::Telectrolyse (int basevoulue, Tentrepot &entrepotaddr,
														Tfonderie &fonderieaddr, Ttime &tempsaddr,
														char *fichierkwaddr)
{
	temps = &tempsaddr;
	entrepot = &entrepotaddr;
	fonderie = &fonderieaddr;
	strcpy (fichierkw , fichierkwaddr); //implementation dans le futur... a suivre........

	basetemps = basevoulue;
	nbmegots = 13;
	nbanodes = NBANODESTOTAL;
	nbbennespleines = 0;
	if (entrepot->EnvoieBennesVides()) // On prends 4 benne au debut pour faire fonctionnner l'electrolyse avec un roulement
	 nbbennesvides=2;
	if (entrepot->EnvoieBennesVides())
	 nbbennesvides+=2;
}

void Telectrolyse::EchAnodesMegots(void)
{
 int succes=1;
 nbanodes -= TAUXPRODMEGOTS;
 nbmegots += TAUXPRODMEGOTS;

 while( nbmegots>=6 && succes)
 {
	succes = entrepot->RecoieCabaretMegots();
	if (succes)
	{
		//cout<<"Electrolyse: Envoie de 6 megots\n";
		//cout<<"Electrolyse: Reception de 6 anodes\n";
		nbmegots -= 6;
		succes = entrepot->EnvoieCabaretAnodes();
	}
	if (succes)
	 nbanodes += 6;
	else
	 entrepot->SetErrorFlag("L'entrepot ne peut envoyer des anodes a l'electrolyse");  //Elle n'est vraiment pas chanceuse l'electrolyse
 }
}


void Telectrolyse::EchBennes(void)
{
 int succes=1;
 nbbennesvides -= TAUXPRODBENNES;
 nbbennespleines += TAUXPRODBENNES;
 while (nbbennespleines>=2 && succes)
 {
	succes = entrepot->RecoieBennesPleines();
	if (succes) // Si l'entrepot recoie une de nos benne
	{
	 //cout<<"Envoie de 2 bennes pleines\n";
	 //cout<<"Reception de 2 bennes vides\n";
	 nbbennespleines -= 2;
	 succes = entrepot->EnvoieBennesVides(); //On regarde si l'entrepot peux nous envoyer 2 benne...
	 if (succes)                             //...et si il peut...
		nbbennesvides += 2;                    //...bien on en ajoute pas une mais deux!
	}
 }
}


void Telectrolyse::AfficherMsg(void)
{
	cout<<"Electrolyse : Anode:"<<nbanodes<<" Megots:"<<nbmegots<<endl;
	cout<<"Benne Pleine:"<<nbbennespleines<<"Benne Vide:"<<nbbennesvides<<endl;
}


int Telectrolyse::Travail(void)
{
 if (!(temps->GetMinute() % basetemps))  //Verification
 {
	EchAnodesMegots();
	EchBennes();
 }

 return 0;
}

void main(void)
{
 clrscr();
 char choix;
 int basetemps;
 int nbrcabaret, nbrbenne, nbbvide, nba, nbm ;
 cout<< "Entrez le nombre de rangees de cabarets: " <<endl ;
 cin>>nbrcabaret;
 cout<< "Entrez le nombre de rangees de bennes : " <<endl ;
 cin>>nbrbenne;
 cout<< "Entrez le nombre de bennes vide au depart (nombre pair): " <<endl ;
 cin>>nbbvide;
 cout<< "Entrez le nombre de cabarets d'anodes au depart: " <<endl ;
 cin>>nba;
 cout<< "Entrez le nombre de cabarets de megots au depart: " <<endl ;
 cin>>nbm;


 //Choix du mode 5 10 ou 15 minutes
 cout<<" Quelle base de temps: a)5min b)10min c)15min ? \n";
 choix=getch();
 if (choix>=0x40 && choix<=0x42) //Si minuscule mettre majuscule
	choix+=0x20;
 if (choix<0x61 || choix > 0x63)
	choix =0x61;
 basetemps=(choix-0x60)*5;

 Ttime temps(basetemps);
 Tentrepot entrepot(nbrcabaret, nbrbenne, nbbvide, nba, nbm,temps);
 Tfonderie fonderie(basetemps);
 Tscellement scellement(basetemps,entrepot,temps,"Excel.txt");
 Telectrolyse electrolyse(basetemps,entrepot,fonderie,temps,"company.txt");
 cout<<"La simulation s'arrete si:"<<endl;
 cout<<" 1) On appuit sur une touche"<<endl;
 cout<<" 2) On fait une simulation de 50 jours"<<endl;
 cout<<" 3) Si l'entrepot ne peut fournir et provoque une erreur"<<endl<<endl;  
 cout<<"Appuyer sur une touche pour commencer"<<endl;

 getch();

 clrscr();

 do
 {
	clrscr();
	gotoxy(1,1);
	electrolyse.AfficherMsg();
	gotoxy(1,10);
	scellement.AfficherMsg();
	gotoxy(1,18);
	fonderie.AfficherMsg();
	gotoxy(1,23);
	entrepot.AfficherMsg();
	gotoxy(1,20);
	temps.AfficheHeure();
	temps.Avance();
	fonderie.EchangerCreuset();
	electrolyse.Travail();
	scellement.Travail();
	delay(100);
 } while ((temps.GetJour()!=50 && !entrepot.BitErreur() && !kbhit()));
 gotoxy(1,23);
 entrepot.AfficherMsg();
 printf("\a"); //Fait un petit bip
 getch();
 getch();

}