Messages

1

Système / [Resolu] Seg Fault [Resolu]

« le: Juin 11, 2016, 10:28:41 am »

Bonjour,
je code actuellement un projet de type Mario 2D et après avoir fait mon premier ennemi, j'ai voulu en créer plusieurs à l'aide d'un vector, cependant lors de la compilation tout marche , c'est lors de l'execution que j'ai un seg fault.  Ne sachant pas d'ou viens l'erreur, je vous poste la classe complete et espere que vous pourrais m'aider.

#ifndef APPLICATION_HPP
#define APPLICATION_HPP

#include <iostream>
#include <fstream>
#include <SFML/Audio.hpp>
#include <SFML/Graphics.hpp>
#include "map.hpp"
#include "personnage.hpp"
#include "ennemi.hpp"

class Application
{
        // Graphique
        sf::RenderWindow                _window;
       
        sf::Texture                             _background;
        sf::Sprite                              _spriteBackground;
       
        sf::FloatRect                   _headboxPerso;
        sf::FloatRect                   _headboxEnnemi;
       
        sf::RectangleShape              _rectangle[19][25];
        sf::FloatRect                   _headboxRect;
       
        // Logique
        TileMap                                 _map;
        Personnage                              _perso;
        vector<Ennemi*>                 _ennemi;
       
        int                                     nbEnnemi = 5;
       
        sf::Font                                _Font;
        sf::Text                                _text;
        bool                                    GameOver=false;
        bool                                    afficherCol=false; // Permet d'afficher ou non les collisions avec la Map (mode test)

        sf::Music                               _music;
       
public:
        Application():
        _window(sf::VideoMode(800, 600), sf::String(L"Projet Mario"))
        {
                for(int i=0;i<nbEnnemi;i++){
                        Ennemi* nouvEnne=new Ennemi();
                        _ennemi[i]=nouvEnne;
                }
               
                if(!_background.loadFromFile("./src/graphics/background.png"))
                        cout << ">> Erreur lors du chargement background.jpg"<<endl;
                _spriteBackground.setTexture(_background);
               
                if(_Font.loadFromFile("./src/polices/policeMario.ttf")==false)
                        cout<<">> Erreur chargement emulogic.ttf"<<endl;
                _text.setFont(_Font);
                _text.setCharacterSize(32);
               
                if (!_music.openFromFile("./src/audio/Music.ogg"))
                        cout<<"Erreur au chargement de music.ogg"<<endl;
                _music.play();
                _music.setLoop(true);

                int level_string[19][25] = { 0 };
                int level[19][25] = { 0 };

                fstream fichier("./src/graphics/map.txt");
                if (!fichier)
                        cout << "niveau inexistant" << endl;
                else
                {
                        int y = 0;
                        string ligne;
                        while (!fichier.eof())
                        {
                                getline(fichier, ligne); // On recupere une ligne dans le fichier sous la forme d'une string
                                for (int x = 0; x<(signed)ligne.length(); x++)
                                {
                                        //ligne[i] renvoit le caractère placer a la i ème position.
                                        level_string[y][x] = ligne[x];
                                }
                                y++;
                        }
                }
                for (int y = 0; y < 19; y++) {
                        for (int x = 0; x < 25; x++) {

                                switch (level_string[y][x]) {
                                case 'X':
                                        _rectangle[y][x].setSize(sf::Vector2f(32,32));
                                        _rectangle[y][x].setPosition(x*32,y*32);
                                        level[y][x] = 0;
                                        break;
                                case 'P':
                                        _rectangle[y][x].setSize((sf::Vector2f(32,32)));
                                        _rectangle[y][x].setPosition(x*32,y*32);
                                        level[y][x] = 2;
                                        break;
                                default :
                                        level[y][x] = 30;
                                }
                        }
                }
                               
                // on crée la tilemap avec le niveau précédemment défini
                if (!_map.load("./src/graphics/tileset.png", sf::Vector2u(32, 32), level, 25, 19))
                        cout<<"erreur chargement tileset"<<endl;
        }

        void run()
        {
                sf::Clock clock;
                while (_window.isOpen())
                {
                        processEvents();
                        update();
                        render();      
                }
        }

protected:
        // Boucle événementielle
        void processEvents()
        {
                sf::Event event;
                while (_window.pollEvent(event))
                {
                        if (event.type == (sf::Event::Closed) || (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)))
                                _window.close();                       
                }
        }

        void update()
        {
                _headboxPerso=_perso.Headbox();
               
                for(int i=0;i<nbEnnemi;i++){
                        _headboxEnnemi=_ennemi[i]->Headbox();
               
                        for(int y=0;y<19;y++){
                                for(int x=0;x<25;x++){
                                        _headboxRect=_rectangle[y][x].getGlobalBounds();
                                        if(_headboxPerso.intersects(_headboxRect)){
                                                if(afficherCol)
                                                        _rectangle[y][x].setFillColor(sf::Color(0,255,0,128)); // Filtre si le personnage rentre en collision
                                                if(_headboxRect.top<_perso.PosY())
                                                                        _perso.setPos(0,1);
                                                                else
                                                                        _perso.setPos(0,0);                            
                                                }
                                        else
                                        {
                                                if(afficherCol)
                                                        _rectangle[y][x].setFillColor(sf::Color(255, 0, 0,128)); // Filtre par defaut
                                                else
                                                        _rectangle[y][x].setFillColor(sf::Color(193, 154, 107,128)); // Filtre par defaut
                                        }
                                        if(_headboxEnnemi.intersects(_headboxRect)){
                                                if(afficherCol)
                                                        _rectangle[y][x].setFillColor(sf::Color(0,0,255,128));
                                                if(_headboxRect.top<_headboxEnnemi.top)
                                                                        _ennemi[i]->setPos(0,1);
                                                                else
                                                                        _ennemi[i]->setPos(0,0);
                                        }
                                }
                        }
                }
        }


        void render()
        {              
                _window.clear();
               
                _window.draw(_spriteBackground);
                _map.draw(_window);

                _perso.update();
                for(int i=0;i<nbEnnemi;i++)
                        _ennemi[i]->update();

                for(int i=0;i<nbEnnemi;i++){
                        _headboxEnnemi.width=_ennemi[i]->Headbox().width-10;
                        if(_headboxPerso.intersects(_headboxEnnemi)){
                                if((_headboxPerso.top<=_headboxEnnemi.top-10) and ( _headboxEnnemi.left<=_headboxPerso.left+20 or _headboxEnnemi.left>_headboxPerso.left )){
                                        for (int i = 0; i < 800; ++i){
                                                _ennemi[i]->move(0,0.2);
                                                sf::sleep(sf::milliseconds(0.01));
                                                _ennemi[i]->setColor();
                                        }
                                }
                                else{
                                        GameOver=true;
                                }
                        }

                        _headboxEnnemi.height=_ennemi[i]->Headbox().height+32;
                        if(_headboxPerso.intersects(_headboxEnnemi) and (_headboxEnnemi.left<=_headboxPerso.left+20 or _headboxEnnemi.left+20>_headboxPerso.left)){
                                if(_headboxPerso.top>=_headboxEnnemi.top){
                                        for (int i = 0; i < 800; ++i){
                                                _ennemi[i]->move(0,0.2);
                                                sf::sleep(sf::milliseconds(0.01));
                                                _ennemi[i]->setColor();
                                        }
                                }
                        }
               
                        _headboxEnnemi.height=_ennemi[i]->Headbox().height;
                        _headboxEnnemi.width=_ennemi[i]->Headbox().width;
                }
               
                if(_perso.PosY()>=700){ // 700 car il y a le saut de rattrapage
                        GameOver=true;
                } // teste si le joueur tombe en dessous du sol
               
                for(int i=0;i<nbEnnemi;i++)
                        if(_ennemi[i]->PosY()>=600){
                                _ennemi[i]->setPos(1,0);
                        }
               
                for(int i=0;i<nbEnnemi;i++)
                        if(_ennemi[i]->Color()==sf::Color(0,0,0,0)){
                                _ennemi[i]->setPos(1,1);
                        }
               
                if(GameOver){
                        _music.stop();
                        _text.setString("Game Over");
                        _text.setPosition(800/2-_text.getGlobalBounds().width/2,600/2-_text.getGlobalBounds().height/2);
                }else{
                        _perso.draw(_window);
                        for(int i=0;i<nbEnnemi;i++)
                                _ennemi[i]->draw(_window);
                }
               
                for(int y=0;y<19;y++){
                        for(int x=0;x<25;x++){
                                _window.draw(_rectangle[y][x]); // Visualiser les collisions avec le systeme de filtre
                        }
                }
        _window.draw(_text);
        _window.display();
        }
};

#endif
 

2

Graphique / Re : Probleme de repositionnement

« le: Juin 05, 2016, 12:21:26 am »

Bonsoir, voilà après debuggage je constate que dans le voir Reposition () le sprite se remet bien à la position, or, lors du update () mon personnage n'as pas bouger et je constate également que si je fait un booléen de sorte à le repositionner autre part que dans la fonction celui ci je cesse de rebasculer en faux même s'il est initialisé à rien et que dans reposition() je le passe à true

3

Graphique / Re : Probleme de repositionnement

« le: Juin 03, 2016, 08:26:32 am »

Les rectangles sont initialisé avec une taille de 32*32, en fait le soucis est que j'arrive à détecter cette fameuse collision en revanche mon sprite ne se positionne pas corectement

4

Graphique / Re : Probleme de repositionnement

« le: Juin 02, 2016, 10:59:18 pm »

Bonsoir et merci de vos réponse , en revanche mon sprite ne se met pas toujours en collision , en fait il teste avec les rectangleShape et ceux ci ne contiennent uniquement que les plateformes et mon sol

5

Graphique / Re : Probleme de repositionnement

« le: Juin 02, 2016, 06:59:11 pm »

Afin de mieux comprendre le soucis, voici le application.hpp

#ifndef APPLICATION_HPP
#define APPLICATION_HPP

#include <iostream>
#include <fstream>
#include <SFML/Graphics.hpp>
#include "scene.hpp"
#include "map.hpp"
#include "personnage.hpp"

class Application
{
        // Graphique
        sf::RenderWindow                _window;
       
        sf::Texture                             _background;
        sf::Sprite                              _spriteBackground;
       
        sf::FloatRect                   _headboxPerso;
       
        sf::RectangleShape              _rectangle[19][26];
        sf::FloatRect                   _headboxRect;
       
        // Logique
        Scene                                   _scene;
        TileMap                                 _map;
        Personnage                              _perso;

public:
        Application():
        _window(sf::VideoMode(800, 600), sf::String(L"Projet Mario")),
        _scene(_window)
        {
                if(!_background.loadFromFile("./src/graphics/background.jpg"))
                        cout << ">> Erreur lors du chargement background.jpg"<<endl;
                _spriteBackground.setTexture(_background);
               
                int level_string[19][26] = { 0 };
                int level[19][26] = { 0 };

                fstream fichier("./src/graphics/map.txt");
                if (!fichier)
                        cout << "niveau inexistant" << endl;
                else
                {
                        int y = 0;
                        string ligne;
                        while (!fichier.eof())
                        {
                                getline(fichier, ligne); // On recupere une ligne dans le fichier sous la forme d'une string
                                for (int x = 0; x<(signed)ligne.length(); x++)
                                {
                                        //ligne[i] renvoit le caractère placer a la i ème position.
                                        level_string[y][x] = ligne[x];
                                }
                                y++;
                        }
                }
                for (int y = 0; y < 19; y++) {
                        for (int x = 0; x < 26; x++) {

                                switch (level_string[y][x]) {
                                case 'X':
                                        _rectangle[y][x].setSize(sf::Vector2f(32,32));
                                        _rectangle[y][x].setPosition(x*32,y*32);
                                        level[y][x] = 0;
                                        break;
                                case 'P':
                                        _rectangle[y][x].setSize((sf::Vector2f(32,32)));
                                        _rectangle[y][x].setPosition(x*32,y*32);
                                        level[y][x] = 2;
                                        break;
                                default :
                                        level[y][x] = 30;
                                }
                        }
                }
                               
                // on crée la tilemap avec le niveau précédemment défini
                if (!_map.load("./src/graphics/tileset.png", sf::Vector2u(32, 32), level, 26, 19))
                        cout<<"erreur chargement tileset"<<endl;
        }

        void run()
        {
                sf::Clock clock;
                while (_window.isOpen())
                {
                        processEvents();
                        update();
                        render();      
                }
        }

protected:
        // Boucle événementielle
        void processEvents()
        {
                sf::Event event;
                while (_window.pollEvent(event))
                {
                        _scene.handleEvent(event);

                        if (event.type == (sf::Event::Closed) || (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)))
                                _window.close();                       
                }
        }

        void update()
        {
                _headboxPerso=_perso.Headbox();
                for(int y=0;y<19;y++){
                        for(int x=0;x<25;x++){
                                _headboxRect=_rectangle[y][x].getGlobalBounds();
                                if(_headboxPerso.intersects(_headboxRect)){
                                        _rectangle[y][x].setFillColor(sf::Color(0,255,0,128)); // Filtre si le personnage rentre en collision
                                        _perso.Reposition();
                                }
                                else
                                {
                                        _rectangle[y][x].setFillColor(sf::Color(255,0,0,128)); // Filtre par defaut
                                }
                        }
                }
                _scene.update();
        }

        void render()
        {              
                _window.clear();
                _window.draw(_spriteBackground);
                _map.draw(_window);
               
                for(int y=0;y<19;y++){
                        for(int x=0;x<25;x++){
                                _window.draw(_rectangle[y][x]); // Visualiser les collisions avec le systeme de filtre
                        }
                }
                _scene.draw();
                _window.display();
        }
};

#endif
 

6

Graphique / Re : Probleme de repositionnement

« le: Juin 02, 2016, 02:55:56 pm »

Je ne vois pas comment contrer les Set/get du fais que je veux remonter mon personnage de 32 pixels,
j'appelle Reposition() dans mon application.hpp comme ceci :

if(_headboxPerso.intersects(_headboxRect)){
        _rectangle[y][x].setFillColor(sf::Color(0,255,0,128)); // Filtre si le personnage rentre en collision
        _perso.Reposition();
}

7

Graphique / Probleme de repositionnement

« le: Juin 02, 2016, 01:41:04 pm »

Bonjour, toujours dans le cadre de mon projet mario, j'arrive désormais à detecter mes collisions avec mon tileset. J'ai donc tenter de repositionner mon sprite de 32 pixels vers le haut via le void Repositionnement() , avec des cout je constate qu'il le prend bien en compte mais n'arrive pas à comprendre pourquoi mon sprite ne se repositionne pas par la suite. C'est pourquoi je viens sur le forum afin de trouver de l'aide. Voici le code de ma classe personnage.hpp .

#ifndef PERSONNAGE_HPP
#define PERSONNAGE_HPP

#include <stdio.h>

using namespace std;

// Objet inerte pour le personnage
class Personnage
{
// Attributs
private:
        sf::Texture _Mario;
        sf::Sprite _spriteMario; //Personnage du joueur
        int blockSize=32; // taille du personnage
        enum Direction{Down,Left,Right,Up};
        sf::Vector2i anim;
        sf::Clock time;
       
        // Acceleration du personnage
        float accX = 0.2f;
        float speedX = 0.f;
        float speedY = 0.f;
       
        // Acceleration maximale
        float maxSpeedX = 5.0f;
        float maxSpeedY = 10.0f;
       
        // Vitesse du saut
        float jumpSpeed = 10.0f;
       
        // Gravité
        float gravity = 0.5f;
       
        bool jumping = false;           //saut initialisé à faux
        bool moveRequest = false;       //Requete de mouvement (si on appui sur une touche) initialisé à faux
       
        sf::FloatRect   _headboxPerso;
       
// Méthodes
public:

        Personnage() :
                _spriteMario()
        {
                if(!_Mario.loadFromFile("./src/graphics/SpriteMario.png"))
                        cout << ">> Erreur lors du chargement SpriteMario.png"<<endl;
                _Mario.setSmooth(true);
                _spriteMario.setTexture(_Mario);
               
                // Initialisation du personnage
                _spriteMario.setPosition(0,0);
               
                anim.x=1;
                anim.y=Right;
        }
       

        ~Personnage()
        {}

        void processEvent(const sf::Event& event)
        {
        }

        void update()
        {
                _spriteMario.move(speedX, speedY);
               
                moveRequest = false;
               
                // Gestion des touches Gauche et Droite
                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)){
                        anim.y=Left;
                        speedX -= accX;
                        moveRequest = true;
                }
                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)){
                        anim.y=Right;
                        speedX += accX;
                        moveRequest = true;
                }
       
                // Gestion de la touche Haut
                if ((sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) && !jumping){
                        speedY = -jumpSpeed;
                        jumping = true;
                }
               
                // Si le _spriteMario arrive au niveau du sol  
                if (_spriteMario.getPosition().y >= 544) {
                        _spriteMario.setPosition(_spriteMario.getPosition().x, 545);
                        jumping = false;
                }
               
                // Blocage de la vitesse maximale du _spriteMario
                if (speedX > maxSpeedX) speedX = maxSpeedX;
                if (speedX < -maxSpeedX) speedX = -maxSpeedX;
                if (speedY < -maxSpeedY) speedY = -maxSpeedY;
               
                // Acceleration de la vitesse pour retomber au sol
                speedY += gravity;
               
                if (!moveRequest){
                        if (speedX<0) speedX += accX;
                        if (speedX>0) speedX -= accX;
                       
                        if (speedX > 0 && speedX < accX) speedX = 0;
                        if (speedX < 0 && speedX > -accX) speedX = 0;
                }
               
               
                if (moveRequest){
                        // Animation du _spriteMario
                        if ((time.getElapsedTime().asMilliseconds())>=50){
                                anim.x++;
                                if(anim.x*blockSize>=(signed)_Mario.getSize().x)
                                        anim.x=0;time.restart();
                        }
                }
               
                if(_spriteMario.getPosition().x+blockSize<0)
                        _spriteMario.setPosition(800,_spriteMario.getPosition().y);
                if(_spriteMario.getPosition().x>800)
                        _spriteMario.setPosition(0-blockSize,_spriteMario.getPosition().y);
       
       
                // Découpage du sprite
                _spriteMario.setTextureRect(sf::IntRect(anim.x*blockSize,anim.y*blockSize,blockSize,blockSize));
               
                _headboxPerso=_spriteMario.getGlobalBounds();
        }
       
        void Reposition()
        {
                _spriteMario.setPosition(_spriteMario.getPosition().x,_spriteMario.getPosition().y-31);
        }
       
        sf::FloatRect Headbox()
        {
                update();
                return _headboxPerso;
        }
       
        void draw(sf::RenderWindow& _window)
        {
                // Affichage du personnage
                _window.draw(_spriteMario);
        }
};

#endif
 

8

Graphique / Re : TileMap et collision avec un sprite

« le: Mai 28, 2016, 12:48:19 pm »

Finalement j'ai reussi à créer des sf::RectangleShape qui arrive à recuperer la position de mes collisons mais quand je test mes headbox rien n'affiche les collisions.
Ce qui teste mes collisions :

for (int y = 0; y < 19; y++){
                        for (int x = 0; x < 25; x++){
                                _headboxRect=_rectangle[y][x].getGlobalBounds(); // _rectangle [y][x] correspond aux rectangles bleu sur l'image
                                if(_headboxPerso.intersects(_headboxRect))
                                {
                                        cout<<"collision"<<endl;
                                }
                        }
}
 

Je ne comprend pas pourquoi cela ne fonctionne pas, si vous pouviez juste m'indiquer une piste à explorer afin de ces intersections puisse fonctionner je vous remercie

9

Graphique / Re : TileMap et collision avec un sprite

« le: Mai 28, 2016, 11:21:06 am »

Oui je suis d'accord cependant dans tout les cas mon personnage doit pouvoir y acceder afin d'appliquer ce test sur la totalité de la map

10

Graphique / Reponse

« le: Mai 28, 2016, 10:52:47 am »

Comme mon tableau _mapping[ 19 ] [26 ] , mon sprite est capable de se déplacer au delà de ses bornes car ma fenêtre fait 800*600 ce qui fait que lorsque mon joueur arrive à  x >=50 ou x<0 (je ne saurais expliquer ces chiffres) un segmentation fault se passe alors que si justement je divise la taille de mon joueur je n'ai plus cette erreur mais du coup la collision n'est pas reconnue

11

Graphique / Re : TileMap et collision avec un sprite

« le: Mai 28, 2016, 10:19:46 am »

En fait je possède un tableau en 2 dimensions avec lequel je voudrais faire des collisions avec mon sprite quand la tuile est différente de 30 (tuile vide). Du coup dans personnage.hpp j'ai les méthodes qui me retourne la position en x et en y de mon joueur et j'ai _masque qui est une copie de level mais lorsque je tente de faire

if(_masque [_perso.PosX ()][_perso.PosY ()]!=30)
{
    cout <<"collision"<<endl;
}

Ce qu'il se passe est que je détecte bien ma collision mais qu'au bout de x temps j'ai un segmentation fault à cause de la taille de mon tableau par rapport à la position du sprite et ne voit pas comment régler ce soucis car en augmentant la taille de celui-ci je ne détecte plus correctement la collision.

12

Graphique / [Résolu]TileMap et collision avec un sprite[Résolu]

« le: Mai 27, 2016, 10:20:18 pm »

Bonjour / Bonsoir à tous,

Je travaille actuellement sur un petit projet de Mario en mode arcade, et pour le moment je possède:
          - Un chargement d'ennemi aléatoire
          - Un personnage
          - Une map générée grâce à un fichier.txt sous la forme de int level[ y ][ x ] (Je commence à parcourir le tableau par les y)
          - Une class Scene.hpp qui se charge d'afficher le personnage ainsi que les ennemis
          - Une class Application.hpp qui permet d'afficher la map ainsi que les éléments de la class Scene

Pour le personnage ainsi que les ennemis je possède une class spécifique. Après avoir recherché des solutions via le site de la SFML ainsi que des vidéos Youtube comme CodingMadeEasy je ne suis pas parvenu à détecter mes collisions. Je vous joint les fichiers en ce qui concerne la map en question, en espérant que vous puissiez m'aider.

13

Graphique / Problème avec les collisions

« le: Janvier 21, 2016, 01:41:30 pm »

Bonjour,
Afin de réaliser un projet de jeu à l'aide de la SFML et du C++ , j'ai chercher à faire des collisions à l'aide de boites englobantes en suivant le tutoriel ci-contre http://www.sfml-dev.org/tutorials/2.1/graphics-transform-fr.php
Cependant lorsque j'utilise cette méthode dans mon code (avec geany) le problème est que ma détection ne fonctionne pas et impossible de comprendre pourquoi , je viens donc sur le forum poster ma question en esperant que vous puissiez m'aider.

Le code en question :

/* Informations pour pouvoir jouer
#########################################
#               JEU-RPG-GEERAERT-QUENTIN                 
#########################################

#################################
#       NECESSITE: SFML 2.0     ET C++   
#################################

#################################################################################################      
#       COMMENT JOUER:                                                                                                                                                                                   #
#                       1)      Aller à l'emplacement où se situe le dossier du jeu                                                                                                    #
#                       2)      g++ -c Jeu.cpp                                                                                                                                                                   #
#                       3)      g++ Jeu.o -o sfml-app -lsfml-graphics -lsfml-window -lsfml-system -lsfml-audio                                                   #
#                       4)      ./sfml-app                                                                                                                                                                               #
#################################################################################################
*/
#ifndef Includes        /* Includes */
#include <iostream>
#include <cmath>
#include <string>
#include <unistd.h>
#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#endif
#ifndef Variables       /* Variables */
int speed = 2;int entree=0;int blockSize=32;int instru=0;int screenW = 800, screenH = 600;int posdep=0;int dialogue=0;
bool updateFPS=true;bool music = true;bool debuter=false;
enum Dir{Down,Left,Right,Up}; /* Touches de deplacements */
sf::RenderWindow window; /* Fenetre */
sf::Texture perso;sf::Sprite sprite_perso; /* Personnage */
sf::Vector2i anim(1, Down);
sf::View view;
sf::SoundBuffer soundBuffer;sf::Sound sound; /* Son d'ambiance */
sf::Texture Background;sf::Sprite sprite_background; /* Affichage logo linux */
sf::Texture Inst;sf::Sprite sprite_inst; /* Instructions */
sf::Texture rect;sf::Sprite sprite_rect; /* Menu demarrer */
sf::Texture Village;sf::Sprite sprite_village; /* Village */
sf::RectangleShape vivi;
sf::FloatRect JoueurBox = sprite_perso.getGlobalBounds(); /* Rectangle contenant le Joueur */
sf::FloatRect MaisonBox = vivi.getGlobalBounds(); /* Rectangle contenant la maison test */
#endif
#ifndef Fonctions       /* Fonctions */
void message(){ /* Affichage l'avancement dans le terminal */
        /* !!! Arriver du joueur dans le jeu !!! */
        if (debuter==false){std::cout<<" > Arriver dans le jeu du joueur !"<<std::endl;debuter=true;}
        /* !!! Dialogue à afficher !!!
        if (dialogue==0){std::cout<<" > Affichage du dialogue du pécheur !"<<std::endl;dialogue++;}*/
        /* !!! Déplacement à gerer !!!
        if (dialogue==1){std::cout<<" > Déplacement du personnage vers la maison (bas,gauche) !"<<std::endl;dialogue++;}*/
}
void chargelem(){ /* Chargement */
        // Création du rectangle de choix demarrer
        if(!rect.loadFromFile("rect.png"))
                std::cout<<std::endl<<">>Erreur lors du chargement rect"<<std::endl;
        rect.setSmooth(true);
        sprite_rect.setTexture(rect);
        sprite_rect.setPosition(400,0);
       
        // Charger le fond d'ecran
        if(!Background.loadFromFile("Tux.png"))
                std::cout<<std::endl<<">>Erreur lors du chargement background"<<std::endl;
        Background.setSmooth(true);
        sprite_background.setTexture(Background);
        sprite_background.setPosition(-5,10);
       
        // Charger l'image du perso
        if(!perso.loadFromFile("image.png"))
                std::cout << ">> Erreur lors du chargement perso"<<std::endl;  
        perso.setSmooth(true);
        sprite_perso.setTexture(perso);
       
        // Charger le son
        if(!soundBuffer.loadFromFile("Mists_of_Time-4T.ogg"))
                std::cout<<">>Erreur lors du chargement audio"<<std::endl;
        sound.setBuffer(soundBuffer);
        sound.setLoop(true);
       
        // Charger les instructions
        if(!Inst.loadFromFile("fleches.jpg"))
                std::cout<<std::endl<<">>Erreur lors du chargement instruction"<<std::endl;
         Inst.setSmooth(true);
        sprite_inst.setTexture(Inst);
        sprite_inst.setPosition(100,100);      

        // Charger le village
        if(!Village.loadFromFile("village.png"))
                std::cout<<std::endl<<">>Erreur lors du chargement village"<<std::endl;
        Village.setSmooth(true);
        sprite_village.setTexture(Village);
        sprite_village.setPosition(0,0);
       
        // Créer un rectangle (test de collision)
        vivi.setFillColor(sf::Color::Blue);
        vivi.setSize(sf::Vector2f(200,100));
        vivi.setPosition(100,100);
}
void affichage(){ /* Affichage du jeu */
        if (entree==0){
                                window.draw(sprite_background);
                                window.draw(sprite_rect);
        }
        else if (entree==1){
                if (posdep==0){
                        sprite_perso.setPosition(383,887); /* Position de depart du joueur */
                        posdep=1;
                }
                //std::cout<<sprite_perso.getPosition().x<<","<<sprite_perso.getPosition().y<<std::endl;
                message();
                //window.draw(sprite_village);
                window.draw(vivi);
                window.draw(sprite_perso);
        }
}
void gestionclavier(){ /* Gestion des touches */
        if(sf::Keyboard::isKeyPressed(sf::Keyboard::Up)){
                sprite_perso.move(0,-speed);
                anim.y=Up;
                //std::cout<<" > Déplacement du personnage vers le haut "<<std::endl;
        }
        else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Down)){
                sprite_perso.move(0,speed);
                anim.y=Down;
                //std::cout<<" > Déplacement du personnage vers le bas "<<std::endl;
        }
        else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Left)){
                sprite_perso.move(-speed,0);
                anim.y=Left;
                //std::cout<<" > Déplacement du personnage vers la gauche "<<std::endl;
        }
        else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Right)){
                sprite_perso.move(speed,0);
                anim.y=Right;
                //std::cout<<" > Déplacement du personnage vers la droite "<<std::endl;       
        }
        else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Return)){
                entree=1;
        }
        else if(sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)){
                if (entree==1){
                        entree=0;
                }
                else if (entree==0){
                        exit(0);
                }
                       
        }
        if(sf::Keyboard::isKeyPressed(sf::Keyboard::S)){
                speed=3;       
        }
        else
                speed=2;
}
void son(){ /* Jouer un son d'ambiance */
        if (music==true){
                sound.play();
                music=false;
        }
}
void collision(){ /* Detection des collisions principales */
                //std::cout<<"> Position du joueur : "<<sprite_perso.getPosition().x<<","<<sprite_perso.getPosition().y<<std::endl;
        if (sprite_perso.getPosition().x<=0)                   
                sprite_perso.setPosition(sf::Vector2f(0,sprite_perso.getPosition().y));
        if (sprite_perso.getPosition().y<=0)                   
                sprite_perso.setPosition(sf::Vector2f(sprite_perso.getPosition().x,0));
        if(sprite_perso.getPosition().x>=1571)
                sprite_perso.setPosition(sf::Vector2f(1571,sprite_perso.getPosition().y));     
        if(sprite_perso.getPosition().y>=1884)
                sprite_perso.setPosition(sf::Vector2f(sprite_perso.getPosition().x,1884));
        // Collision avec la map
        if (JoueurBox.intersects(MaisonBox)){
                std::cout<< "Collision !" <<std::endl;
        }
}
void scrolling(){  /* Vue en scrolling du personnage */
        view.reset(sf::FloatRect(0,0,screenW,screenH));
        sf::Vector2f position(screenW/2,screenH/2);
        position.x=sprite_perso.getPosition().x+(blockSize/2)-(screenW/2);
        position.y=sprite_perso.getPosition().y+(blockSize/2)-(screenH/2);
        if(position.x<0)
                position.x=0;
        if(position.y<0)
                position.y=0;
        view.reset(sf::FloatRect(position.x,position.y,screenW,screenH));
        window.setView(view);                  
}
void jeu(){  /* Principal ! --- Lorsque la fenetre est ouverte */
        sf::Clock time;
        float fpsCount=0,switchFPS=100,fpsSpeed=500;
        chargelem();
        while (window.isOpen()){
                sf::Event event;
                while (window.pollEvent(event)){
                        if (event.type == sf::Event::Closed)
                                window.close();
                        if (event.type == sf::Event::KeyPressed){
                                updateFPS=true;
                        }
                        else
                                updateFPS=false;
                }
                son();         
                gestionclavier();
                if (updateFPS==true){
                        if (time.getElapsedTime().asMilliseconds()>=100){
                                anim.x--;
                                if(anim.x*blockSize>=perso.getSize().x)
                                        anim.x=2;
                                        time.restart();
                        }
                }
                sprite_perso.setTextureRect(sf::IntRect(anim.x*blockSize,anim.y*blockSize,blockSize,blockSize));
                collision();
                scrolling();
                affichage();
                window.display();
                window.clear();
        }
}
#endif
int main(){             /* Main */
        window.create(sf::VideoMode(800, 600), "JEU-GEERAERT-QUENTIN");/* Créer un fenetre de taille définie */
        window.setPosition(sf::Vector2i(0,0));/* Positionne correctement la fenetre en 0,0 */
        std::cout << std::endl<<"> Lancement du jeu :"<<std::endl;
        jeu(); /* Lancement du jeu */
}