Exemple #1
0
void World::renderWorld() {

    int indexPlayerI = convertToIndex(_team1.p->getPos().x, 100);
    int indexPlayerJ = convertToIndex(_team1.p->getPos().y, 100);

    /* Les nombre en dessous permettent de déterminer la distance ou lon affiche la map autour du héro */

    float visionI = zoneAffichable, visionJ = zoneAffichable;

    int idPImoins = indexPlayerI - visionI;
    int idPIplus = indexPlayerI + visionI;
    int idPJmoins = indexPlayerJ - visionJ;
    int idPJplus = indexPlayerJ + visionJ;

    if(idPImoins < 0)
        idPImoins = 0;

    if(idPIplus > 20)
        idPIplus = 20;

    if(idPJmoins < 0)
        idPJmoins = 0;

    if(idPJplus > 20)
        idPJplus = 20;

    for(int j=idPJmoins; j<idPJplus; j++)
            for(int i=idPImoins; i<idPIplus; i++)
                    g_core->getApp()->draw(_matrice[i][j].spr);

}
Exemple #2
0
void dfree(void* ptr) {

	metadata_t* myHead   = (metadata_t*) (((void*)(ptr)) - METADATA_T_ALIGNED); //front of header
	foot_t*     myFoot   = (foot_t*) 		 (((void*)(ptr)) + myHead->size);//footer

	metadata_t* prevHead = NULL;
	foot_t*     prevFoot = (foot_t*)     (((void*)(ptr)) - FOOT_T_ALIGNED - METADATA_T_ALIGNED);

	metadata_t* nextHead = (metadata_t*) (((void*)(myFoot)) + FOOT_T_ALIGNED);
	foot_t*     nextFoot = NULL;

	bool prevFree = false;
	bool nextFree = false;

	//Check if prev block can be coalesced
	if(prevFoot >= (foot_t*) slabStart){
		prevHead = (metadata_t*) (((void*)(ptr)) - FOOT_T_ALIGNED  - prevFoot->size - 2*METADATA_T_ALIGNED);
		if(prevHead->next != (void*) -1){ 					//If prev is free
			prevFree = true;
			removeFromList(prevHead,convertToIndex(prevHead->size));
		}
	}
	//Check if next block can be coalesced
	if(nextHead < (metadata_t*) slabEnd){
		nextFoot = (foot_t*) (((void*)(nextHead)) + nextHead->size + METADATA_T_ALIGNED);
		if(nextHead->next != (void*) -1){					//If next is free
			nextFree = true;
			removeFromList(nextHead,convertToIndex(nextHead->size));
		}
	}

	//Start coalescing prev
	if(prevFree){
		prevHead->size = prevHead->size + myHead->size + METADATA_T_ALIGNED + FOOT_T_ALIGNED;
		myFoot->size = prevHead->size;
		myHead = prevHead;
	}
	//Start coalescing next
	if(nextFree){
		myHead->size = myHead->size + nextHead->size + METADATA_T_ALIGNED + FOOT_T_ALIGNED;
		nextFoot->size = myHead->size;
	}
	//Put into appropriate freelist block
	int index = convertToIndex(myHead->size);
	myHead->next = blocks[index];
	blocks[index] = myHead;
	myHead->prev = NULL;

	if(myHead->next != NULL){
		myHead->next->prev = myHead;
	}

}
Exemple #3
0
void* dmalloc(size_t numbytes) {
	numbytes = ALIGN(numbytes);

	if(unallocated) { 			//Initialize through sbrk call first time
		unallocated = false;
		if(!dmalloc_init())
			return NULL;
	}

	assert(numbytes > 0);

	//Find the first block that is of sufficient size.
	metadata_t* freeBlock = (metadata_t*) firstFitblock(numbytes,convertToIndex(numbytes));
	if(freeBlock == NULL){return NULL;}

	//Check if we shouldn't split the block - used 8 so we at worst the split has a leftover block of size 8
	if(freeBlock->size < numbytes + METADATA_T_ALIGNED + FOOT_T_ALIGNED + 16){//Consider expanding this size requirement
			freeBlock->next = (void*) -1;
			freeBlock->prev = (void*) -1;
			return ((void*)freeBlock) + METADATA_T_ALIGNED;
	}

	//Otherwise Split the Block - the retBlock: return block and the leftover is freeBlock
	metadata_t* retBlock = freeBlock;

	//Make freeBlock the leftover block and put it back in blocks
	freeBlock = (metadata_t*)(((void*)(freeBlock)) +  METADATA_T_ALIGNED + numbytes + FOOT_T_ALIGNED); //Move its address to front of metadata
	freeBlock->size = retBlock->size - numbytes - METADATA_T_ALIGNED - FOOT_T_ALIGNED; 								 // adjust size

	int i = convertToIndex(freeBlock->size);
	freeBlock->next = blocks[i];
	freeBlock->prev = NULL;
	foot_t* fbFoot = (foot_t*) (((void*) freeBlock) + METADATA_T_ALIGNED + freeBlock->size);
	fbFoot->size = freeBlock->size;

	//Adjust pointers at front of block
	if(blocks[i] != NULL){
			blocks[i]->prev = freeBlock;
	}
	blocks[i] = freeBlock;	//make blocks point to freeblock

	//Adjust return metadata/footer
	retBlock->size = numbytes;
	retBlock->next = (void*) - 1;
	retBlock->prev = (void*) - 1;
	foot_t* retFoot = (foot_t*)(((void*)(retBlock)) + retBlock->size + METADATA_T_ALIGNED);
	retFoot->size = retBlock->size;

	return (((void*)(retBlock)) + METADATA_T_ALIGNED);
}
Exemple #4
0
int main()
{

    // On aura TOUJOURS comme première fichier map "Map1.tmx" puis un nombre de map a définir

    string etatMap = "start";
    int nbMap = 20;

    // Tableau des différentes Maps
    vector<string> Maps;

    for(int i = 1; i < (nbMap + 1); i++)
    {
        string nomMap = "map/Map";
        nomMap.append(int_to_string(i));
        nomMap.append(".tmx");

        Maps.push_back(nomMap);

        //cout << "la map " << nomMap << " a ete pushe" << endl;
    }

    string Map_EnCours = Maps[0];


    unsigned int Map_Actuelle = 0;

    tile** Matrice;
    //tile** MatriceTest;



    //int LARGEUR_MAP = NbColonnes * LARGEUR_TILE;
    //int HAUTEUR_MAP = NbLignes * HAUTEUR_TILE;

    bool debugMode = true;



    // Fenêtre
    RenderWindow app(VideoMode((int)WINDOW_SIZE.x, (int)WINDOW_SIZE.y, 32), "Another : Beta v0.2");

	// Frames Per Second (FPS)
    //app.setFramerateLimit(60); // limite la fenêtre à 60 images par seconde

    // NE PAS mettre les deux en meme temps

    app.setVerticalSyncEnabled(true);

	Texture myTile, myEchelle, myBullet, myEnnemi, myEnnemi2, myPlayer, myPlayer2, lifeBonus,
	myEndBlock, tileSet1, myInterrupteur, myDoor, myCheckpoint, reward;

	if (!myBullet.loadFromFile(SPRITES_FILE_PATH_BULLET)) // Si le chargement a échoué
    {
        cerr<<"Erreur durant le chargement de l'image"<<endl;
    }
    else
    {
        //myBullet.SetSmooth(false);
    }

	if (!myEnnemi.loadFromFile(SPRITES_FILE_PATH_ENNEMI)) // Si le chargement a échoué
    {
        cerr<<"Erreur durant le chargement de l'image"<<endl;
    }
    else
    {
        //myEnnemi.SetSmooth(false);
    }

	if (!myEnnemi2.loadFromFile(SPRITES_FILE_PATH_ENNEMI_2)) // Si le chargement a échoué
    {
        cerr<<"Erreur durant le chargement de l'image"<<endl;
    }
    else
    {
        //myEnnemi2.SetSmooth(false);
    }

	if (!myPlayer.loadFromFile(SPRITES_FILE_PATH_PLAYER)) // Si le chargement a échoué
    {
        cerr<<"Erreur durant le chargement de l'image"<<endl;
    }
    else
    {
        //myPlayer.SetSmooth(false);
    }

	if (!lifeBonus.loadFromFile(SPRITES_FILE_PATH_LIFEBONUS)) // Si le chargement a échoué
    {
        cerr<<"Erreur durant le chargement de l'image"<<endl;
    }
    else
    {
        //lifeBonus.SetSmooth(false);
    }

	if (!myTile.loadFromFile("images/blocTerre.png")) // Si le chargement a échoué
	{
		cerr<<"Erreur durant le chargement de l'image"<<endl;
	}
    else
    {
        //myTile.SetSmooth(false);
    }

	if (!myEchelle.loadFromFile("images/blocEchelle.png")) // Si le chargement a échoué
	{
		cerr<<"Erreur durant le chargement de l'image"<<endl;
	}
    else
    {
        //myEchelle.SetSmooth(false);
    }

	if (!myEndBlock.loadFromFile("images/blocFin.png")) // Si le chargement a échoué
	{
		cerr<<"Erreur durant le chargement de l'image"<<endl;
	}
    else
    {
        //myEndBlock.SetSmooth(false);
    }

    if (!tileSet1.loadFromFile("map/tileset1.png")) // Si le chargement a échoué
    {
        cerr<<"Erreur durant le chargement de l'image"<<endl;
    }
    else
    {
        //tileSet1.SetSmooth(false);
    }

    if (!myInterrupteur.loadFromFile("images/interrupteur.png")) // Si le chargement a échoué
	{
		cerr<<"Erreur durant le chargement de l'image"<<endl;
	}
    else
    {
        //myInterrupteur.SetSmooth(false);
    }

    if (!myDoor.loadFromFile("images/porteCoulissante.png")) // Si le chargement a échoué
	{
		cerr<<"Erreur durant le chargement de l'image"<<endl;
	}
    else
    {
        //myDoor.SetSmooth(false);
    }

	if (!myCheckpoint.loadFromFile("images/checkpoint.png")) // Si le chargement a échoué
	{
		cerr<<"Erreur durant le chargement de l'image"<<endl;
	}
    else
    {
        //myCheckpoint.SetSmooth(false);
    }

    if (!reward.loadFromFile("images/reward.png")) // Si le chargement a échoué
	{
		cerr<<"Erreur durant le chargement de l'image"<<endl;
	}
    else
    {
        //reward.SetSmooth(false);
    }

    vector<Bullet> vectorBullet;
	vector<Character> vectorCharacter;
	vector<Object*> vectorObject;




	// ====== Variable importante !! =======

//	int x = 150;
//	int y = 150;
	int controleSaut = false; /* Booléen qui va permettre de ne pas relancer un second saut avant d'avoir relaché la touche */
	float transparence = 0;
	float transparenceInverse = 255;
	Clock clockTempsMap;
	Clock clockFrame;
	bool startGame = false;
	bool changementDeMap = false;

	/*string etatMap = "start";

	// Tableau des différentes Maps
    vector<string> Maps;



    for(int i = 1; i < (nbMap + 1); i++)
    {
        string nomMap = "map/Map";
        nomMap.append(int_to_string(i));
        nomMap.append(".tmx");

        Maps.push_back(nomMap);

        //cout << "la map " << nomMap << " a ete pushe" << endl;
    }*/

	// =====================================
	// =====================================




	// Création et positionnement du joueur au lancement du jeu



	// =========================


	// Création d'une vue qui suivra les déplacements du joueur

	View vue = app.getDefaultView();
	View hud;

	// =========================================================

	// Création des barres de vie et d'énergie du joueur et du rectangle de fondu

    sf::RectangleShape hud1;
    hud1.setSize(sf::Vector2f(150, 140));
    hud1.setFillColor(sf::Color(190, 200, 200));
    hud1.setOutlineColor(sf::Color::Black);
    hud1.setOutlineThickness(1);

    sf::RectangleShape barLife;
    barLife.setSize(sf::Vector2f(50, 10));
    barLife.setFillColor(sf::Color::Red);
    barLife.setOutlineColor(sf::Color::Black);
    barLife.setOutlineThickness(1);

    sf::RectangleShape barPower;
    barPower.setSize(sf::Vector2f(50, 10));
    barPower.setFillColor(sf::Color(0, 150, 255));
    barPower.setOutlineColor(sf::Color::Black);
    barPower.setOutlineThickness(1);

    sf::RectangleShape fondu;
    fondu.setSize(sf::Vector2f(WINDOW_SIZE.x, WINDOW_SIZE.y));

	// ===============================================================
	// Menu

    menu(app, false, changementDeMap, hud, WINDOW_SIZE, startGame, Maps, Map_EnCours, Map_Actuelle);

    createMap(Map_EnCours, &Matrice, tileSet1, myInterrupteur, myDoor, myCheckpoint, reward, vectorObject);

    int NbColonnes = nbColonnesMap(Map_EnCours);
    int NbLignes = nbLignesMap(Map_EnCours);

    int LARGEUR_TILE = largeurTileMap(Map_EnCours);
    int HAUTEUR_TILE = largeurTileMap(Map_EnCours);

    Player player(myPlayer, 0, 0, PLAYER_SPEED, "bleu", "normal");
	PlayerPosition(player, &Matrice, NbColonnes, NbLignes, LARGEUR_TILE, "depart");

	clockTempsMap.restart();

    cout << "Map en cours avant main" << Map_EnCours << endl;
    cout << "Map Actuelle avant main" << Map_Actuelle << endl;

    // Boucle principale
    while (app.isOpen())
    {
		// Remplissage de l'écran (couleur noire par défaut)
        app.clear();

        //vue.setSize(WINDOW_SIZE.x, WINDOW_SIZE.y);
        app.setView(vue);
        hud = app.getDefaultView();


        // On récupère le temps de rafraichissement entre chaque frame pour ajuster la vitesse du jeu
        float frameTime = clockFrame.restart().asSeconds();

        bool actionElement = false;

        // On modifier la valeur du temps de la map

        /*if(clockTempsMap.getElapsedTime().asSeconds() > 0.1f)
        {
            tempsMap += 0.1f;
            clockTempsMap.restart();
        }*/


		/* Gestion de l'affichage d'un certain nombre de tile autour du player, et non toute la map */

		int indexPlayerI = convertToIndex(player.getLeftSide(), LARGEUR_TILE);
		int indexPlayerJ = convertToIndex(player.getBottomSide(), LARGEUR_TILE);

		/* Les nombre en dessous permettent de déterminer la distance ou lon affiche la map autour du héro */

		float visionI = 20, visionJ = 10;

		int idPImoins = indexPlayerI - visionI;
		int idPIplus = indexPlayerI + visionI;
		int idPJmoins = indexPlayerJ - visionJ;
		int idPJplus = indexPlayerJ + visionJ;

		if(idPImoins < 0)
			idPImoins = 0;

		if(idPIplus > NbColonnes)
			idPIplus = NbColonnes;

		if(idPJmoins < 0)
			idPJmoins = 0;

		if(idPJplus > NbLignes)
			idPJplus = NbLignes;

        for(int j=idPJmoins; j<idPJplus; j++)
                for(int i=idPImoins; i<idPIplus; i++)
                    if(Matrice[i][j].spr != 0)
                        app.draw(*Matrice[i][j].spr);


		//=================================================



		/* REGENERATION du POWER */

		player.setPower(player.getPower() + 0.2f);

		if(player.getPower() > 100.0f)
			player.setPower(100.0f);

		if(player.getPower() < 0)
			player.setPower(0);

		if(player.getPower() > 50.0f)
			player.setSurchauffe(false);

		/* ===================== */



		/* == LIFE == */

		if(player.getLife() <= 100)
			player.upLife(0.05f);

		if(player.getLife() > 200.0f)
			player.setLife(200.0f);

		if(player.getLife() < 0)
			player.setLife(0);

		/* ===================== */



		// Dès que la vitesse descend en dessous de 0 alors le joueur n'est plus en saut

		if(player.getSpeedY() < 0)
			player.setEnSaut(false);

		/* ===================== */


		/* GRAVITE : On diminue la vitesse verticale si pas sur Terre */

		if(!player.surTerre()){

			player.setSpeedY(player.getSpeedY() - 30.0f);

			/* Effet de resistance de l'air */
			if((CollisionDecorLateralSide(LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, player, Matrice, vectorObject) == 1)
                || (CollisionDecorLateralSide(LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, player, Matrice, vectorObject) == 2)
            )
            {
                if(player.getSpeedY() < -400.0f)
                    player.setSpeedY(-400.0f);
            }
            else
            {
               if(player.getSpeedY() < -800.0f)
                    player.setSpeedY(-800.0f);
            }


		}

		/* ===================== */



		/* On enleve la GRAVITE lorsque l'on est au sol */

		if(player.surTerre()){
			player.setSpeedY(0);
		}

		/* ===================== */


		/* CLOCK du freeze Time */

		if(player.getFreeze()){

			if(player.getClockFreeze() > 1.5f){
				player.setFreeze(false);
				player.setSpeedY(0);
			}
		}

		// ======================

		Event event;

        while (app.pollEvent(event))
        {

			if(event.type == sf::Event::KeyReleased && event.key.code == Keyboard::Space){

				//player.setEnSaut(false);
				controleSaut = false;
			}

			if(event.type == sf::Event::KeyReleased && event.key.code == Keyboard::Down){

				player.setDescendre(false);
			}

			if(event.type == sf::Event::KeyReleased && event.key.code == Keyboard::Right){

				player.setDeplacement(false);
				player.setMouvementDroite(false);
			}

			if(event.type == sf::Event::KeyReleased && event.key.code == Keyboard::Left){

				player.setDeplacement(false);
				player.setMouvementGauche(false);
			}
			if(event.type == sf::Event::KeyReleased && event.key.code == Keyboard::LShift){

				player.notShooting();
			}


            switch(event.type)
			{
				case Event::Closed : // Croix de fermeture
					app.close();
					break;

				case Event::KeyPressed : // Appui sur une touche
				{
					switch(event.key.code)
					{
						case Keyboard::Escape : // Touche echap

                            if(player.surTerre())
                            {
                                startGame = false;
                                menu(app, true, changementDeMap, hud, WINDOW_SIZE, startGame, Maps, Map_EnCours, Map_Actuelle);

                                if(changementDeMap)
                                {
                                    clockTempsMap.restart();
                                    player.setScore(0);

                                    deleteMatrice(&Matrice, NbColonnes, NbLignes, vectorObject);

                                    createMap(Map_EnCours, &Matrice, tileSet1, myInterrupteur, myDoor, myCheckpoint, reward, vectorObject);

                                    NbColonnes = nbColonnesMap(Map_EnCours);
                                    NbLignes = nbLignesMap(Map_EnCours);

                                    PlayerPosition(player, &Matrice, NbColonnes, NbLignes, LARGEUR_TILE, "depart");


                                    changementDeMap = false;
                                }
                            }
                            else
                            {
                                cout << "Vous devez etre sur terre pour aller dans le menu. (En cas de probleme, sautez !)" << endl;
                            }
							break;

                        default:
                            break;
					}
				}



				default:
                    break;
			}


        }



        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
        {
            if(!player.getMouvementDroite()){

                player.setMouvementGauche(true);

                if(!player.getFreeze()){
                //	if(!Matrice[mxGauche][myGauche].solid){
                        if(!player.getFreeze())
                            //if(player.getSpeed() > -15.0f)
                                player.deplacementGaucheX();

                //	}

                    player.setDeplacement(true);
                }

                player.setDirectionGauche();
            }
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
        {
            if(!player.getMouvementGauche()){

                player.setMouvementDroite(true);

                if(!player.getFreeze()){
                    //if(!Matrice[mxDroite][myDroite].solid){
                        if(!player.getFreeze())
                            //if(player.getSpeed() < 15.0f)
                                player.deplacementDroiteX();

                    //}

                    player.setDeplacement(true);
                }

                player.setDirectionDroite();
		    }
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Space))
        {
            if(!controleSaut && !player.getFreeze() && player.surTerre()){
					player.setSpeedY(650.0f);
					player.setEnSaut(true);
					controleSaut = true;
            }

            if(!controleSaut && !player.getFreeze() && !player.surTerre())
            {
                if(CollisionDecorLateralSide(LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, player, Matrice, vectorObject) == 1)
                {
                    player.setSpeedY(850.0f);
                    player.setSpeed(700.0f);
					player.setEnSaut(true);
					controleSaut = true;
                    //cout << "saut gauche" << endl;
                }
                else if(CollisionDecorLateralSide(LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, player, Matrice, vectorObject) == 2)
                {
                    player.setSpeedY(850.0f);
                    player.setSpeed(-700.0f);
					player.setEnSaut(true);
					controleSaut = true;
                    //cout << "saut droite" << endl;
                }
            }
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
        {
            if(!player.getSurchauffe()){
				player.teleport();
				player.setFreeze(false);
			}
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::E))
        {
            actionElement = true;
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::P))
        {
            etatMap = "end";
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Z))
        {
            if(!player.getFreeze())
				player.freezeTime();
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::LShift))
        {
            if(player.getClockBullet() > 0.2f){
				if(player.getDirection() == "droite"){
					vectorBullet.push_back(Bullet(myBullet, (player.getRightSide() - 10), (player.getTopSide() + 12.0f), (BULLET_SPEED * frameTime), player.getDirection(), player.getEquipe(), "ball"));
				}else if(player.getDirection() == "gauche"){
					vectorBullet.push_back(Bullet(myBullet, (player.getLeftSide() - 20), (player.getTopSide() + 12.0f), (BULLET_SPEED * frameTime), player.getDirection(), player.getEquipe(), "ball"));
				}

				player.resetClockBullet();
			}

            player.shootAnimation();
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
        {
            player.setDescendre(true);
        }



		//	===================================================
		//  =============== AFFICHAGE DES TESTS ===============
		//	===================================================

		/*if(CollisionDecorPlafond(LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, player, Matrice))
			cout << " COLLISION PLAFOND  " << endl;
		else
			cout << " PAS COLLISION PLAFOND  " << endl;

		if(CollisionDecorSol(LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, player, Matrice))
			cout << " COLLISION SOL  " << endl;
		else
			cout << " PAS COLLISION SOL  " << endl;	*/


		/*if(player.surTerre())
			cout << " SUR TERRE  " << endl;
		else
			cout << " PAS SUR TERRE  " << endl;
*/
		//cout << player.getSpeed() << endl;
		/*
			cout << vectorCharacter.size() << endl;
			cout << vectorBullet.size() << endl;
			cout << vectorObject.size() << endl;*/


      // cout << "speed y :" << player.getSpeedY() << endl;



		//	===================================================


	//	===================================================


		/* Friction / Ralentissement de la vitesse latérale */

		if(!player.getDeplacement()){

			if(player.getSpeed() > 1500.0f){
				player.setSpeed(player.getSpeed() - 500.0f);
			}else if(player.getSpeed() < -1500.0f){
				player.setSpeed(player.getSpeed() + 500.0f);
			}

			if(player.getSpeed() > 0){
				if(player.getSpeed() < 150.00f){
					player.setSpeed(0);
				}
				else{
					player.setSpeed(player.getSpeed() - 50.00f);
				}

			}else if(player.getSpeed() < 0){
				if(player.getSpeed() > -150.0f){
					player.setSpeed(0);
				}
				else{
					player.setSpeed(player.getSpeed() + 50.00f);
				}
			}

		}

		/* Lorsque le joueur n'est pas Freeze on effectue les essai de mouvement sur X et Y pour on application la nouvelle position */

		if(!player.getFreeze()){

			EssaiDeplacementX(Matrice, frameTime, player, player.getSpeed(), LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, vectorObject);

			if(EssaiDeplacementY(Matrice, frameTime, player, player.getSpeedY(), LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, vectorObject)){

				// Si true, alors le joueur est en contact avec un bloc de fin de niveau
                cout << "ERREUR" << endl;
                cout << Map_Actuelle << " " << Map_EnCours << endl;
				etatMap = "end";
			}



			player.setPosition();

		}







		//	===========================================================================
		//  =========== Double boucle testant chaque balles si elle est en  ===========
		//	===========	collision avec un ennemi, un player, un mur ou rien ===========
		//	===========================================================================


		for(int unsigned i = 0; i < vectorBullet.size(); i++){

			if(CollisionBulletDecor(LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, vectorBullet[i], Matrice)){
					vectorBullet[i].kill();
				}

			if(vectorBullet[i].getDirection() == "droite"){
				vectorBullet[i].deplacementDroiteX();
			}else if(vectorBullet[i].getDirection() == "gauche"){
				vectorBullet[i].deplacementGaucheX();
			}

			vectorBullet[i].drawBullet(app);

			// Collision des balles et des ennemis
			for(int unsigned j = 0; j < vectorCharacter.size(); j++){

				float degatDeal;

				// On test si l'équipe de la balle est la meme que celle du character, si non, on peut tester la collision
				if(vectorBullet[i].getEquipe() != vectorCharacter[j].getEquipe()){
					if(!vectorBullet[i].isKilled()){
						if(CollisionBulletCharacter(vectorBullet[i], vectorCharacter[j])){

							degatDeal = vectorBullet[i].getDegat();
							vectorCharacter[j].downLife(degatDeal);

							vectorBullet[i].kill();
						}
					}
				}

			}

			// Collision des balles et des objet

            for(int unsigned j = 0; j < vectorObject.size(); j++){

                if(vectorObject[j]->getSolid()){

                    if(CollisionObjectBullet(vectorObject[j], vectorBullet[i])){
                        vectorBullet[i].kill();

                        if(vectorObject[j]->getBreakable()){
                           vectorObject[j]->kill();
                        }
                    }
                }
            }

			// Collision des balles et du joueur

			if(vectorBullet[i].getEquipe() != player.getEquipe()){
				if(!vectorBullet[i].isKilled()){
					if(CollisionBulletCharacter(vectorBullet[i], player)){

						float degatDeal = vectorBullet[i].getDegat();
						player.downLife(degatDeal);

						vectorBullet[i].kill();
					}
				}
			}

		}

		//	===========================================================================



		//	===================================================
		//  ============== Boucle sur les objets ==============
		//	===================================================

		for(int unsigned i = 0; i < vectorObject.size(); i++){

			for(int unsigned j = 0; j < vectorCharacter.size(); j++){

				if(CollisionObjectCharacter(vectorObject[i], vectorCharacter[j])){

					float life = vectorObject[i]->getLife();
					vectorCharacter[j].upLife(life);

					vectorObject[i]->kill();
				}

			}

			if(CollisionObjectCharacter(vectorObject[i], player)){

                if(vectorObject[i]->getType() == "lifeBonus"){
                    float life = vectorObject[i]->getLife();
                    player.upLife(life);

                    vectorObject[i]->kill();
                }
                else if(vectorObject[i]->getType() == "interrupteur"){

                    if(actionElement){
                        if(vectorObject[i]->getEstActive() == false){
                            vectorObject[i]->setActive();
                            vectorObject[i]->resetClockInt();
                        }
                    }

                }
                else if(vectorObject[i]->getType() == "tilePique"){

                    if(vectorObject[i]->getDeadly()){
                        player.kill();
                    }

                }
                else if(vectorObject[i]->getType() == "checkpoint"){

                    if(!vectorObject[i]->getActive()){
                        vectorObject[i]->setActive(true);

                        player.setInitialPosition(vectorObject[i]->getX(), vectorObject[i]->getY());

                        for(int unsigned j = 0; j < vectorObject.size(); j++){

                            if(vectorObject[j]->getType() == "checkpoint"){
                                if(j != i)
                                {
                                    if(vectorObject[j]->getActive()){
                                        vectorObject[j]->setActive(false);
                                    }
                                }
                            }
                        }

                    }
                }
                else if(vectorObject[i]->getType() == "blockPique"){

                    if(vectorObject[i]->getDeadly()){
                        player.kill();
                    }

                }
                else if(vectorObject[i]->getType() == "reward"){
                    int val = vectorObject[i]->getValeur();
                    player.setScore(player.getScore() + val);

                    vectorObject[i]->kill();
                }
			}

            //cout << "test 1030 et taille de  : " << vectorObject.size() << endl;


			if((vectorObject[i]->getType() == "interrupteur") && (vectorObject[i]->getEstActive())){

                if(vectorObject[i]->getClockInt() > vectorObject[i]->getDelai()){

                    vectorObject[i]->setNotActive();
                }

			}
			else if(vectorObject[i]->getType() == "door"){

                if(vectorObject[i]->buttonIsActive()){

                    vectorObject[i]->setOpen(true);
                }
                else{

                    if(!CollisionObjectCharacter(vectorObject[i], player))
                        vectorObject[i]->setOpen(false);
                }

			}
			else if(vectorObject[i]->getType() == "launcher"){

                if(!vectorObject[i]->getIsReady()){
                    if(vectorObject[i]->getClock() > vectorObject[i]->getDecallage()){

                        vectorObject[i]->resetClock();
                        vectorObject[i]->setReady(true);

                    }
                }
                else{
                    if(vectorObject[i]->getClock() > vectorObject[i]->getInterval()){

                        vectorObject[i]->resetClock();

                        float x, y;

                        if(vectorObject[i]->getDirection() == "gauche")
                        {
                            x = (vectorObject[i]->getLeftSide()) - 5.0f;
                            y = (vectorObject[i]->getTopSide()) + 15.0f;

                            vectorBullet.push_back(Bullet(myBullet, x, y, (BULLET_SPEED * frameTime), vectorObject[i]->getDirection(), vectorObject[i]->getEquipe(), vectorObject[i]->getAmmoType()));
                        }
                        else if(vectorObject[i]->getDirection() == "droite")
                        {
                            x = (vectorObject[i]->getRightSide()) - 15.0f;
                            y = (vectorObject[i]->getTopSide()) + 15.0f;

                            vectorBullet.push_back(Bullet(myBullet, x, y, (BULLET_SPEED * frameTime), vectorObject[i]->getDirection(), vectorObject[i]->getEquipe(), vectorObject[i]->getAmmoType()));
                        }



                    }

                }

			}
			else if(vectorObject[i]->getType() == "blockPique"){

               // if(EssaiDeplacementY(Matrice, app, player, player.getSpeedY(), LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, vectorObject)){

                if(CollisionObjectDecor(LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, i, vectorObject, Matrice))
                {

                    if(vectorObject[i]->getDirection() == "gauche"){

                        vectorObject[i]->setDirection("droite");
                    }
                    else if(vectorObject[i]->getDirection() == "droite"){

                        vectorObject[i]->setDirection("gauche");
                    }
                    else if(vectorObject[i]->getDirection() == "haut"){

                        vectorObject[i]->setDirection("bas");
                    }
                    else if(vectorObject[i]->getDirection() == "bas"){

                        vectorObject[i]->setDirection("haut");
                    }
                }

                if(vectorObject[i]->getDirection() == "gauche"){

                    vectorObject[i]->deplacementGaucheX();
                }
                else if(vectorObject[i]->getDirection() == "droite"){

                    vectorObject[i]->deplacementDroiteX();
                }
                else if(vectorObject[i]->getDirection() == "haut"){

                    vectorObject[i]->deplacementHautY();
                }
                else if(vectorObject[i]->getDirection() == "bas"){

                    vectorObject[i]->deplacementBasY();
                }

			}
			else if(vectorObject[i]->getType() == "reward"){

                if(CollisionObjectDecor(LARGEUR_TILE, HAUTEUR_TILE, NbColonnes, NbLignes, i, vectorObject, Matrice))
                {
                    vectorObject[i]->deplacement(true, frameTime);

                }
                else
                {
                    vectorObject[i]->deplacement(false, frameTime);

                }



			}

			vectorObject[i]->drawObject(app);
		}


        /** A AJUSTER */

		vue.setCenter((int)(player.getX() + (player.GetSprite().getLocalBounds().width)/2), (int)(player.getY() + (player.GetSprite().getLocalBounds().height)/2));


        player.drawPlayer(app);

		// == Boucle permettant de supprimer du Vector les balles qui sont "killed" après une collision

		for(int unsigned i = 0; i < vectorBullet.size();){
			if(vectorBullet[i].isKilled())
				vectorBullet.erase(vectorBullet.begin()+i);
			else
				i++;
		}

		// == Boucle permettant de supprimer du Vector les Ennemis qui sont "killed" lorsqu'il n'ont plus de points de vie

/*		// == Ou plutot de faire respawn le Character

		for(int unsigned i = 0; i < vectorCharacter.size();){
			if(vectorCharacter[i].isKilled()){

				vectorCharacter[i].setX(vectorCharacter[i].getInitialX());
				vectorCharacter[i].setY(vectorCharacter[i].getInitialY());
				vectorCharacter[i].setLife(vectorCharacter[i].getInitialLife());
				vectorCharacter[i].setSpeed(vectorCharacter[i].getInitialSpeed());
				vectorCharacter[i].setEnSaut(vectorCharacter[i].enSautInitial());
				vectorCharacter[i].setSurTerre(vectorCharacter[i].surTerreInitial());

				vectorCharacter[i].setPosition();

			//	vectorCharacter.erase(vectorCharacter.begin()+i);
			}else
				i++;
		}*/

		// == Boucle permettant de supprimer du Vector les objets qui sont "killed" lorsqu'ils ont été utilisés

		for(int unsigned i = 0; i < vectorObject.size();){
			if(vectorObject[i]->isKilled())
				vectorObject.erase(vectorObject.begin()+i);
			else
				i++;
		}



		// == Test permettant de voir si le player est Killed, et de le faire respawn en conséquence

		// systeme de CHECKPOINT ici

		if(player.isKilled()){

				player.setX(player.getInitialX());
				player.setY(player.getInitialY());
				player.setLife(player.getInitialLife());
				player.setSpeed(player.getInitialSpeed());
				player.setEnSaut(player.enSautInitial());
				player.setSurTerre(player.surTerreInitial());
				player.revive();

				player.setPosition();

			//	vectorCharacter.erase(vectorCharacter.begin()+i);
		}



        app.setView(hud); // IMPORTANT <<

        // On affiche le block hud1

        hud1.setPosition((hud.getCenter().x - (hud.getSize().x / 2)), (hud.getCenter().y - (hud.getSize().y / 2)));
        app.draw(hud1);

        // Permet d'afficher les FPS en mode debug

		if(debugMode){
			sf::Text fpsMessage;
			int FPS;
			ostringstream oss;

			FPS = 1 / frameTime;
			oss << "FPS : " << FPS;

            fpsMessage.setPosition((hud.getCenter().x - (hud.getSize().x / 2) + 20.0f), (hud.getCenter().y - (hud.getSize().y / 2) + 110.0f));
            fpsMessage.setColor(Color(255,0,0,255));
            fpsMessage.setString(oss.str());
            fpsMessage.setCharacterSize(14);

			app.draw(fpsMessage);
		}

        // On Affiche le Score

        sf::Text score;
        ostringstream oss2;

        oss2 << "Score : " << player.getScore();

        score.setColor(Color(0,0,0,255));
        score.setPosition((hud.getCenter().x - (hud.getSize().x / 2) + 20.0f), (hud.getCenter().y - (hud.getSize().y / 2) + 90.0f));
        score.setCharacterSize(14);
        score.setString(oss2.str());

        app.draw(score);

        // On Affiche le temps

        sf::Text tpsMaps;
        ostringstream oss3;

        oss3 << "Temps : " << clockTempsMap.getElapsedTime().asSeconds();

        tpsMaps.setColor(Color(0,0,0,255));
        tpsMaps.setPosition((hud.getCenter().x - (hud.getSize().x / 2) + 20.0f), (hud.getCenter().y - (hud.getSize().y / 2) + 70.0f));
        tpsMaps.setCharacterSize(14);
        tpsMaps.setString(oss3.str());


        app.draw(tpsMaps);


		// Affichage d'un message "surcharge" si l'energie est basse

		sf::Text txtSurcharge;

		txtSurcharge.setString("Overheating !");
		txtSurcharge.setColor(Color(255,0,0,255));
		txtSurcharge.setCharacterSize(14);
		txtSurcharge.setPosition((hud.getCenter().x - (hud.getSize().x / 2) + 20.0f), (hud.getCenter().y - (hud.getSize().y / 2) + 50.0f));

		if(player.getSurchauffe())
			app.draw(txtSurcharge);

		// Variations des barres de vies et de power

		barLife.setSize(sf::Vector2f(player.getLife(), 10.0f));
		barPower.setSize(sf::Vector2f(player.getPower(), 10.0f));

		barLife.setPosition((hud.getCenter().x - (hud.getSize().x / 2) + 20.0f), (hud.getCenter().y - (hud.getSize().y / 2) + 10.0f));
		barPower.setPosition((hud.getCenter().x - (hud.getSize().x / 2) + 20.0f), (hud.getCenter().y - (hud.getSize().y / 2) + 30.0f));

		if(player.getSurchauffe()){

			barPower.setFillColor(sf::Color(0, 25, 100));
		}
		else{

			barPower.setFillColor(sf::Color(0, 150, 255));
		}

        app.draw(barLife);
		app.draw(barPower);

        //cout << "x now :" << player.getX() << endl;
        //cout << "speed Y :" << player.getSpeedY() << endl;


		if(etatMap == "end"){


			/* Systeme de fondu pour fin de niveau // Le rectangle suit le joueur pour éviter tout problème visuel */

			fondu.setPosition((hud.getCenter().x - (hud.getSize().x / 2)), (hud.getCenter().y - (hud.getSize().y / 2)));
			fondu.setFillColor(sf::Color(0,0,0,transparence));

			app.draw(fondu);

			// La transparence s'effectue a 0.5 par frame ( a modifier si besoin !)

			if(transparence < 255){
				transparence += 1.0f;
			}


			if(transparence >= 255){

                save((Map_Actuelle + 2), player.getScore(), clockTempsMap.getElapsedTime().asSeconds());
                // MapActuelle + 2 car pour le niveau 1 mapActuelle = 0 et que l'on veux save le dernier niveau que l'on
                //a atteint donc fin du 1 = 0 + 2 = 2

                clockTempsMap.restart();
                player.setScore(0);

                deleteMatrice(&Matrice, NbColonnes, NbLignes, vectorObject);

                GoToNextMap(Map_EnCours, Map_Actuelle, Maps);

                createMap(Map_EnCours, &Matrice, tileSet1, myInterrupteur, myDoor, myCheckpoint, reward, vectorObject);

                NbColonnes = nbColonnesMap(Map_EnCours);
                NbLignes = nbLignesMap(Map_EnCours);


				// On repositionne le joueur en fonction des valeurs initiales

				// =========
// IMPORTANT	// Les valeurs "initiales" varieront en fonction des checkpoint et des changement de niveau
				// =========



				// ========================

                PlayerPosition(player, &Matrice, NbColonnes, NbLignes, LARGEUR_TILE, "depart");




				// =================================

				etatMap = "transition"; // TEMPORAIRE
				transparence = 0;

			}

		}

		if(etatMap == "transition"){

			// On réalise un fondu (inverse) pour réafficher le jeu

			fondu.setPosition((hud.getCenter().x - (hud.getSize().x / 2)), (hud.getCenter().y - (hud.getSize().y / 2)));
			fondu.setFillColor(sf::Color(0,0,0,transparenceInverse));

			app.draw(fondu);

			if(transparenceInverse > 0){
				transparenceInverse -= 2.0f;
			}


			if(transparenceInverse <= 0)
			{
			    etatMap = "start";
			    transparenceInverse = 255;
			}

		}

        // Affichage de la fenêtre à l'écran
        app.display();
    }

	deleteMatrice(&Matrice, NbColonnes, NbLignes, vectorObject);

    return EXIT_SUCCESS;


}