Пример #1
0
void DrawObject3DAmbient ( std::string name, vec2 centre, float scale, float angle, float bank )
{
	Object3D* obj = GetObject3D(name);
	EnableTexturing();
	DisableBlending();
	obj->BindTextures();
	//glUniform3f(UniformLocation("Ambient"), ambient.red(), ambient.green(), ambient.blue());
	SetShader("3DBase");
	glUniform1f(UniformLocation("specularScale"), obj->SpecularScale());
	glUniform1f(UniformLocation("shininess"), obj->Shininess());
	Matrices::SetViewMatrix(matrix2x3::Translate(centre));
	obj->Draw(scale, angle, bank);
}
Пример #2
0
int Game::playTrack(Track& track){
	
	bool raceFinished = false;
	unsigned int timeElapsed = 0;

	//Interface
	Program prog2D;
	prog2D = loadProgram("../shaders/tex2D.vs.glsl", "../shaders/tex2D.fs.glsl");
	prog2D.use();
	
	
	//Carre qui affiche les pouvoirs
	Object2D powerquad;
	powerquad.setVertices(0.7, 0.9, -0.9, -0.64);
	powerquad.build();
	
	//Carre qui affiche la position
	Object2D positionQuad;
	positionQuad.setVertices(-0.9,-0.7,0.64,0.9);
	positionQuad.build();

	//Surfaces pour afficher le classement final (à optimiser)
	Object2D positionQuad1;
	positionQuad1.setVertices(-0.2,-0.1,0.8,0.9);
	positionQuad1.build();
	Object2D positionQuad2;
	positionQuad2.setVertices(-0.2,-0.1,0.6,0.7);
	positionQuad2.build();
	Object2D positionQuad3;
	positionQuad3.setVertices(-0.2,-0.1,0.4,0.5);
	positionQuad3.build();
	Object2D positionQuad4;
	positionQuad4.setVertices(-0.2,-0.1,0.2,0.3);
	positionQuad4.build();
	Object2D positionQuad5;
	positionQuad5.setVertices(-0.2,-0.1,0.0,0.1);
	positionQuad5.build();
	Object2D positionQuad6;
	positionQuad6.setVertices(-0.2,-0.1,-0.2,-0.1);
	positionQuad6.build();
	Object2D positionQuad7;
	positionQuad7.setVertices(-0.2,-0.1,-0.4,-0.3);
	positionQuad7.build();
	Object2D positionQuad8;
	positionQuad8.setVertices(-0.2,-0.1,-0.6,-0.5);
	positionQuad8.build();

	Object2D persoQuad1;
	persoQuad1.setVertices(0.1,0.2,0.8,0.9);
	persoQuad1.build();
	Object2D persoQuad2;
	persoQuad2.setVertices(0.1,0.2,0.6,0.7);
	persoQuad2.build();
	Object2D persoQuad3;
	persoQuad3.setVertices(0.1,0.2,0.4,0.5);
	persoQuad3.build();
	Object2D persoQuad4;
	persoQuad4.setVertices(0.1,0.2,0.2,0.3);
	persoQuad4.build();
	Object2D persoQuad5;
	persoQuad5.setVertices(0.1,0.2,0.0,0.1);
	persoQuad5.build();
	Object2D persoQuad6;
	persoQuad6.setVertices(0.1,0.2,-0.2,-0.1);
	persoQuad6.build();
	Object2D persoQuad7;
	persoQuad7.setVertices(0.1,0.2,-0.4,-0.3);
	persoQuad7.build();
	Object2D persoQuad8;
	persoQuad8.setVertices(0.1,0.2,-0.6,-0.5);
	persoQuad8.build();

	
	GLint locVarTexture;
	locVarTexture= glGetUniformLocation(prog2D.getGLId(), "uTexture");
	GLuint* texturepower=PowerTexture();
	GLuint* textureRank=RankTexture();
	GLuint* texturePerso=PersoTexture();
	
	Program prog;
	prog = loadProgram("../shaders/3D.vs.glsl","../shaders/tex3D.fs.glsl");
	prog.use();
	
	GLuint uMVPMatrix=glGetUniformLocation(prog.getGLId(),"uMVPMatrix");
	GLuint uMVMatrix=glGetUniformLocation(prog.getGLId(),"uMVMatrix");
	GLuint uNormalMatrix=glGetUniformLocation(prog.getGLId(),"uNormalMatrix");
	GLuint uTex=glGetUniformLocation(prog.getGLId(),"uTexture");
	
	GLuint uKd=glGetUniformLocation(prog.getGLId(),"uKd");
	GLuint uKs=glGetUniformLocation(prog.getGLId(),"uKs");
	GLuint uShininess=glGetUniformLocation(prog.getGLId(),"uShininess");
	GLuint uLightDir_vs=glGetUniformLocation(prog.getGLId(),"uLightDir_vs");
	GLuint uLightIntensity=glGetUniformLocation(prog.getGLId(),"uLightIntensity");
	
	glEnable(GL_DEPTH_TEST);
	
	glm::mat4 ViewMatrix;
		
	TrackballCamera camera;
	
	// Les power qu'on peut ramasser, a enlever car ils seront inclus dans powObject
	PowerObject boost(BOOST,10000);
	PowerObject atk_back(ATK_BACK,10000);
	PowerObject trap(TRAP,10000);
	PowerObject shield(SHIELD, 10000);
	PowerObject atk_all(ATK_ALL, 10000);
	PowerObject atk_front(ATK_FRONT, 10000);
	
	//Ciel
	Object3D sky;
	sky.sphere(1,32,16);
	sky.setScale(glm::vec3(80,80,80));
	sky.setHitbox(glm::vec3(0));
	sky.build();
	sky.LoadTexture("../textures/sky.jpg");
	
	PowerObject *obj=NULL;
	bool done=false;
	bool ready=false;
	int sortie=0;
	
	std::cout << "Lecture du fichier Map" << std::endl;
	//Lecture du fichier Map
	track.insertElt();

	//Nodes

	unsigned int rank = 8;
	//On donne le prochain noeud pour que les IA s'y dirigent
	for (std::vector<Kart*>::iterator it = Karts.begin() ; it != Karts.end(); ++it){
		(*it)->setNodeTo(track.getNodeStart()->next);
		(*it)->setRank(rank);
		rank--;
	}
	
		 Node* currentNode = track.getNodeStart();
		 Object3D* node;
	 // while(1){
		 // node = new Object3D();
		 // node->sphere(1,32,16);
		 // node->setScale(glm::vec3(1,1,1));
		 // node->setHitbox(glm::vec3(0));
		 // node->setPosition(currentNode->getPosition());
		 // node->build();
		 // if(currentNode==track.getNodeStart())
		 // node->LoadTexture("../textures/Maison.jpg");
		 // else
		 // node->LoadTexture("../textures/CCTex.jpg");
		 // track.push_back(*node);
		 // currentNode = currentNode->next;
		 // if(currentNode==track.getNodeStart())
			 // break;
	 // }

	placementKart(track.getNodeStart());

	 //Rotation pour la caméra
	std::queue<std::pair<float,Uint32>> anglefile;
	anglefile.push(std::pair<float,Uint32>(Karts[0]->getAngle(),0));
	
	glUniform3f(uKd, 1, 1, 1);
	glUniform3f(uKs, 1, 1, 1);
	glUniform1f(uShininess, 2);

	glUniform3f(uLightIntensity, 1, 1, 1);
		
	timeElapsed=0;
	while(!done) {

		Uint32 tStart = SDL_GetTicks();
		
		if(timeElapsed >= FPS && timeElapsed < 2*FPS)
			std::cout << "3 ..." << std::endl;
		if(timeElapsed >= 2*FPS && timeElapsed < 3*FPS)
			std::cout << "2 ..." << std::endl;
		if(timeElapsed >= 3*FPS && timeElapsed < 4*FPS)
			std::cout << "1 ..." << std::endl;

		if(timeElapsed >= 4*FPS && timeElapsed < 5*FPS){
			std::cout << "PINAAAAAAAAAAGE !!!" << std::endl;
			ready=true;
		}
		
		
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		prog2D.use();
		//affichage des pouvoirs
		 powerquad.initDraw();
		if (Players[0]->getPower()==NULL){
			powerquad.bindTex(texturepower[6]);
		}
		else{
			switch(Players[0]->getPower()->getType()){
				case BOOST:
					powerquad.bindTex(texturepower[0]);
					break;
				case ATK_FRONT:
					powerquad.bindTex(texturepower[1]);
					break;
				case ATK_BACK: 
					powerquad.bindTex(texturepower[2]);
					break;
				case ATK_ALL:
					powerquad.bindTex(texturepower[3]);
					break;
				case SHIELD:
					powerquad.bindTex(texturepower[4]);
					break;
				case TRAP:
					powerquad.bindTex(texturepower[5]);
					break;
			}
		}
		powerquad.Draw(locVarTexture);

		//Gestion du classement
		if( !raceFinished ){
			ranking(Karts);
			positionQuad.initDraw();		
			positionQuad.bindTex(textureRank[Karts[0]->getRank()-1]);
			positionQuad.Draw(locVarTexture);
		}
		else{
			getFinalRanking(Players);

			positionQuad1.initDraw();		
			positionQuad1.bindTex(textureRank[0]);
			positionQuad1.Draw(locVarTexture);
			positionQuad2.initDraw();		
			positionQuad2.bindTex(textureRank[1]);
			positionQuad2.Draw(locVarTexture);
			positionQuad3.initDraw();		
			positionQuad3.bindTex(textureRank[2]);
			positionQuad3.Draw(locVarTexture);
			positionQuad4.initDraw();		
			positionQuad4.bindTex(textureRank[3]);
			positionQuad4.Draw(locVarTexture);
			positionQuad5.initDraw();		
			positionQuad5.bindTex(textureRank[4]);
			positionQuad5.Draw(locVarTexture);
			positionQuad6.initDraw();		
			positionQuad6.bindTex(textureRank[5]);
			positionQuad6.Draw(locVarTexture);
			positionQuad7.initDraw();		
			positionQuad7.bindTex(textureRank[6]);
			positionQuad7.Draw(locVarTexture);
			positionQuad8.initDraw();		
			positionQuad8.bindTex(textureRank[7]);
			positionQuad8.Draw(locVarTexture);

			persoQuad1.initDraw();		
			persoQuad1.bindTex(texturePerso[getIdPersoByRank(Players, 1)]);
			persoQuad1.Draw(locVarTexture);
			persoQuad2.initDraw();		
			persoQuad2.bindTex(texturePerso[getIdPersoByRank(Players, 2)]);
			persoQuad2.Draw(locVarTexture);
			persoQuad3.initDraw();		
			persoQuad3.bindTex(texturePerso[getIdPersoByRank(Players, 3)]);
			persoQuad3.Draw(locVarTexture);
			persoQuad4.initDraw();		
			persoQuad4.bindTex(texturePerso[getIdPersoByRank(Players, 4)]);
			persoQuad4.Draw(locVarTexture);
			persoQuad5.initDraw();		
			persoQuad5.bindTex(texturePerso[getIdPersoByRank(Players, 5)]);
			persoQuad5.Draw(locVarTexture);
			persoQuad6.initDraw();		
			persoQuad6.bindTex(texturePerso[getIdPersoByRank(Players, 6)]);
			persoQuad6.Draw(locVarTexture);
			persoQuad7.initDraw();		
			persoQuad7.bindTex(texturePerso[getIdPersoByRank(Players, 7)]);
			persoQuad7.Draw(locVarTexture);
			persoQuad8.initDraw();		
			persoQuad8.bindTex(texturePerso[getIdPersoByRank(Players, 8)]);
			persoQuad8.Draw(locVarTexture);
		} 

		prog.use();
			
		//Decalage camera
		if(tStart-anglefile.front().second>330){
			if(anglefile.size()>1)
				anglefile.pop();
		}
		//Camera
		ViewMatrix=camera.getViewMatrix(Karts[0]->getPosition(), anglefile.front().first,Karts[0]->back);
		
		glUniform3fv(uLightDir_vs, 1, glm::value_ptr(glm::rotate(ViewMatrix,Karts[0]->getAngle()+90, glm::vec3(0,1,0))));
		
		//Kart (boucle sur tous les karts)
		for (int id=0;id<8;++id){
			 if((id!=0 && ready) || raceFinished ){

				//Deplacement IA
				int sortie=Karts[id]->moveIA(track.getMapObjects(),track.getPowObjects(), Karts,Players[id]->getPower(),
				Players[id]->getCharacter().getHero(), Players[id]->getCharacter().isPowerReady(tStart));
					if(sortie==1)
						Players[id]->usePower(Karts,id,tStart,track.getMapObjects());
					else if(sortie==2)
						Players[id]->getCharacter().useSuperPower(tStart,*Karts[id],track.getMapObjects());
			 }else{
			 	Karts[id]->crossANode();
			 }
				
			Karts[id]->getVAO().bind();		//Bind du VAO
			Karts[id]->TransfoMatrix(ViewMatrix,Karts[id]->getPosition()); //Transformations (View, Translation, anglerotation,scale)
			Karts[id]->MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT); //Envoi des matrices au shader
			Karts[id]->Draw(uTex);	//Draw de l'objet
			
			//Pouvoirs Classiques
			if(Players[id]->getPower()){
				if(Players[id]->getPower()->isLaunched() && Players[id]->getPower()->withKart()){
					Players[id]->getPower()->getVAO().bind();		//Bind du VAO
					Players[id]->getPower()->TransfoMatrix(ViewMatrix, Players[id]->getKart().getPosition()); //Transformations (View, Translation, anglerotation,scale)
					Players[id]->getPower()->MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT); //Envoi des matrices au shader
					Players[id]->getPower()->Draw(uTex);	//Draw de l'objet
				}
				
				if(Players[id]->getPower()->isLaunched() && Players[id]->getPower()->isPerimed(tStart)){
					Players[id]->stopPower(Karts,id);
				}			
			}
			//Pouvoirs Speciaux
			if(Players[id]->getCharacter().isLaunched()){
				if(Players[id]->getCharacter().isPerimed(tStart)){
					Players[id]->getCharacter().useSuperPowerBack(Players[id]->getKart());
					Players[id]->getCharacter().hitSuperPowerBack(Karts);
				}
				else {
					Players[id]->getCharacter().continuousHitSuperPower(Karts,Players[id]->getKart());
				}
			}
		}
		
		//Dessin des objets de la map
		for(int id=0;id<track.getMapObjects().size();++id){
			if(track.getMapObjects()[id]->isVisible()){
				track.getMapObjects()[id]->getVAO().bind();	
				track.getMapObjects()[id]->movePower();
				track.getMapObjects()[id]->TransfoMatrix(ViewMatrix, track.getMapObjects()[id]->getPosition());
				track.getMapObjects()[id]->MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT);
				track.getMapObjects()[id]->Draw(uTex);
				
			}
			if(track.getMapObjects()[id]->tooFar()){
					delete(track.getMapObjects()[id]);
					track.getMapObjects().erase(track.getMapObjects().begin()+id);	
					id--;
			}
			else if(track.getMapObjects()[id]->isPerimed(tStart)){
					track.getMapObjects()[id]->hitKartBack(Karts);
					delete(track.getMapObjects()[id]);
					track.getMapObjects().erase(track.getMapObjects().begin()+id);	
					id--;
			}
		}
		
		//Dessin des pouvoirs de la map
		for (std::vector<PowerObject*>::iterator it = track.getPowObjects().begin() ; it != track.getPowObjects().end(); ++it){
			if((*it)->isVisible()){
				(*it)->getVAO().bind();		
				(*it)->rotateObj();
				(*it)->TransfoMatrix(ViewMatrix, (*it)->getPosition());
				(*it)->MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT);
				(*it)->Draw(uTex);
			}
			if((*it)->isPerimed(tStart)){
					(*it)->visible=true;
			}
		}

		//Gestion des collisions
		for (int idkart=0;idkart<8;++idkart){	// Boucle sur tous les karts
			//Collision avec les autres objets de la map
			for (std::vector<Object3D*>::iterator it_mapObjects = track.getMapObjects().begin() ; it_mapObjects != track.getMapObjects().end(); ++it_mapObjects){	// Boucle sur tous les objets de la map
				if(Karts[idkart]->isInCollision( **it_mapObjects )){
					
					if(((*it_mapObjects)->hitKart(*Karts[idkart],idkart, tStart))==0){
						Karts[idkart]->avoidCollision( **it_mapObjects );
						Karts[idkart]->move(-1); // Fais ralentir le kart quand il est en collision
					}
				}
			}
		
			//Collision avec les pouvoirs ramassables de la map
			for (std::vector<PowerObject*>::iterator it_powObjects = track.getPowObjects().begin() ; it_powObjects != track.getPowObjects().end(); ++it_powObjects){	// Boucle sur tous les objets de la map
				if(Karts[idkart]->isInCollision( **it_powObjects )){
					Players[idkart]->pickPower(**it_powObjects,tStart);
					(*it_powObjects)->visible=false;
				}
			}
			
			//Collision avec les autres Karts
			//>>>>>>>>>>>>>>>>>>>>> Boucle sur le reste des karts, permet d'éviter de tester 2 fois la même collision (kart1/kart2 et kart2/kart1 par exemple)
			for (int idotherkart = idkart+1 ; idotherkart <8; ++idotherkart){  // Boucle sur le reste des karts
				if(Karts[idkart]->intouchable || Karts[idotherkart]->intouchable)
					continue;
					
		        if(Karts[idkart]->isInCollision( *Karts[idotherkart] )){
		        	Karts[idkart]->avoidCollision( *Karts[idotherkart] );
					Karts[idkart]->move(-1); // Fais ralentir le kart quand il est en collision
					
					Players[idkart]->getCharacter().hitSuperPower(tStart, Karts, idotherkart, *Karts[idkart]); //Pouvoir spécial kart1 sur kart2
					Players[idotherkart]->getCharacter().hitSuperPower(tStart, Karts, idkart, *Karts[idotherkart]); //Pouvoir spécial kart2 sur kart1
				}
			}

			//Collision avec les bords de la map
			Karts[idkart]->collisionWithMap(track.getLargeur(), track.getLongueur());
		
		}


/*		for(int i=0; i<8; ++i){
			finalRankQuad[i].initDraw();		
			finalRankQuad[i].bindTex(textureRank[i]);
			finalRankQuad[i].Draw(locVarTexture);
		}
*/		
		//getFinalRanking(Players, textSurfaces, font);

		// showRankSurfaces(rankSurfaces, screen, positionSurfaces);

		// std::cout << "Votre classement : " << Karts[0]->getRank() << std::endl;
		//std::cout << "NbNodesPassed : " << Karts[0]->getNbNodesPassed() << std::endl;

		if((float)Karts[0]->getNbNodesPassed()/track.getNbNodes() == track.getNbLaps() ){
			raceFinished = true;
		}
		
		//Sky
		sky.getVAO().bind();		
		sky.setAngle(tStart*0.001f);
		sky.TransfoMatrix(ViewMatrix,Karts[0]->getPosition());
		sky.MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT);
		sky.Draw(uTex);
		
		VAO::debind();
		
	
		
		SDL_Event e;
		while(SDL_PollEvent(&e)) {
			switch(e.type) {			
				case SDL_QUIT:
					done = true;
					sortie=-1;
					break;
				case SDL_KEYDOWN:
					switch(e.key.keysym.sym){
						case 'n':
							std::cout << "You pick an Attack_Front" << std::endl;
							Players[0]->pickPower(atk_front,tStart);
							obj=Players[0]->getPower();
							break;
						case 'b':
							std::cout << "You pick a Boost" << std::endl;
							Players[0]->pickPower(boost,tStart);
							break;
						case 'v':
							std::cout << "You pick an Attack_back" << std::endl;
							Players[0]->pickPower(atk_back,tStart);
							obj=Players[0]->getPower();
							break;
						case 'c':
							std::cout << "You pick a Trap" << std::endl;
							Players[0]->pickPower(trap,tStart);
							obj=Players[0]->getPower();
							break;
						case 'x':
							std::cout << "You pick a Shield" << std::endl;
							Players[0]->pickPower(shield,tStart);
							break;
						case 'z':
							std::cout << "You pick an Attack_All" << std::endl;
							Players[0]->pickPower(atk_all,tStart);
							break;
						case 'm':
							std::cout << "You have been hit" << std::endl;
							if(obj)
							obj->hitKart(*Karts[0], 0, tStart);
							break;
						case SDLK_SPACE:
							if(ready)
								Players[0]->usePower(Karts,0,tStart,track.getMapObjects());
							break;
						case SDLK_ESCAPE:
							sortie=0;
							done=true;
							break;
						case 'p':
							sortie = redirectionPause();
							if(sortie==-1)
								done = true;
							std::cout << sortie << std::endl;
							break;
						case 'q':
							if(ready){
								if(!Players[0]->getCharacter().isPowerReady(tStart))
									break;
								switch(Players[0]->getCharacter().getHero()){
									case JOHN :
										son = Mix_LoadWAV("../sounds/John.wav");
										Mix_VolumeChunk(son, MIX_MAX_VOLUME);
										Mix_PlayChannel(-1, son, 0);
									break;
									case KLAUS :
										son = Mix_LoadWAV("../sounds/Klaus.wav");
										Mix_VolumeChunk(son, MIX_MAX_VOLUME);
										Mix_PlayChannel(-1, son, 0);
									break;
									case DOUG :
										son = Mix_LoadWAV("../sounds/Doug.wav");
										Mix_VolumeChunk(son, MIX_MAX_VOLUME);
										Mix_PlayChannel(-1, son, 0);
									break;
									case CANADA :
										son = Mix_LoadWAV("../sounds/Captain.wav");
										Mix_VolumeChunk(son, MIX_MAX_VOLUME);
										Mix_PlayChannel(-1, son, 0);
									break;
									case BURT :
										son = Mix_LoadWAV("../sounds/Burt.wav");
										Mix_VolumeChunk(son, MIX_MAX_VOLUME);
										Mix_PlayChannel(-1, son, 0);
									break;
									case MCKORMACK :
										son = Mix_LoadWAV("../sounds/Mac.wav");
										Mix_VolumeChunk(son, MIX_MAX_VOLUME);
										Mix_PlayChannel(-1, son, 0);
									break;
									case STEVE :
										son = Mix_LoadWAV("../sounds/Steve.wav");
										Mix_VolumeChunk(son, MIX_MAX_VOLUME);
										Mix_PlayChannel(-1, son, 0);
									break;
									case STAN :
										son = Mix_LoadWAV("../sounds/Stan.wav");
										Mix_VolumeChunk(son, MIX_MAX_VOLUME);
										Mix_PlayChannel(-1, son, 0);
									break;
									case JENNIFER :
										son = Mix_LoadWAV("../sounds/Jennifer.wav");
										Mix_VolumeChunk(son, MIX_MAX_VOLUME);
										Mix_PlayChannel(-1, son, 0);
									break;
								}
								Players[0]->getCharacter().useSuperPower(tStart,*Karts[0],track.getMapObjects());
							}
							break;
					}
					break;
				default:
					break;
				
			}
		}
		
		Uint8 *keystate = SDL_GetKeyState(NULL);
		if(ready && !raceFinished){
			if ( keystate[SDLK_UP] ) Karts[0]->move(1);
			if ( keystate[SDLK_DOWN] ) Karts[0]->move(-1);
			if (!keystate[SDLK_UP] && !keystate[SDLK_UP]) Karts[0]->move(0);
			
			if ( keystate[SDLK_LEFT] ){ Karts[0]->rotate(1); anglefile.push(std::pair<float,Uint32>(Karts[0]->getAngle(),tStart));}
			if ( keystate[SDLK_RIGHT] ){ Karts[0]->rotate(-1); anglefile.push(std::pair<float,Uint32>(Karts[0]->getAngle(),tStart));}
		}
		// Mise à jour de la fenêtre (synchronisation implicite avec OpenGL)
		SDL_GL_SwapBuffers();

		Uint32 tEnd = SDL_GetTicks();
		Uint32 d = tEnd - tStart;
		if(d < FRAME_DURATION) {
			SDL_Delay(FRAME_DURATION - d);
		}
		
		timeElapsed++;
	}
	std::cout << "Nettoyage" << std::endl;
	CleanObjects(track);
	
	return sortie;
}