Collison Tileset

[Quentin-35]

Bonjour à tous,
Je me présente je m'appelle Quentin.
J'ai commencé le codage C++ il y a maintenant 1 mois et 2 ou 3 semaine environs. 

Afin de m'améliorer si on peut dire sa comme sa, j'ai commencé un jeux de plateforme en 2D.
Mon soucis est le suivant : J'ai utilisé le forum SFML pour l'utilisation d'un tileset sans soucis mais maintenant je cherche comment créer une collision avec certain tile par exemple le 2 et le 3.

Voila donc mon fameux soucis, je suis bloqué depuis 3 semaines dessus, je me suis même renseigné au prêt du créateur du cour de collision sur OpenClassroom, mais après plusieurs explications je suis toujours dans l'impasse étant donné qu'il la codé en SDL et moi je suis avec la SFML 2.1 (je ne suis pas encore passé à la 2.2) je vais faire sa prochainement.

Donc j'aimerais bien si possible que vous jetiez un oeil sur mon code (très peut simplifié et aussi pas très "propre"), si possible pouvez vous me montrer un code similaire avec un exemple de collision ou alors avec le miens en faire quelque chose, car je comprend mieux avec un exemple que je puisse modifier.

J'ai déjà cherché sur le FORUM mais chaque sujet parlant de collision avec un tileset son comment dire *flou*
Voilà pourquoi j'ai décidé de vous demander votre aide directement en créant un nouveau sujet voici mon code tel qu'il est actuellement :

main.cpp

(click to show/hide)

#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include <SFML/system.hpp>
#include <SFML/Audio.hpp>
#include <cmath>
#include <math.h>
#include <string>
#include <iostream>
#include <cstdlib>
#include <iostream>
#include "Variables.h"
#include "vertex.cpp"

int main()
{

    // on crée la fenêtre
    sf::RenderWindow window(sf::VideoMode(largeurFenetre, hauteurFenetre), "Jeux Test");
    window.setFramerateLimit(70);

// mes bouton en sprite :

if (!jouer.loadFromFile("jouer.png"))
{
std::cout << "Erreur lors du chargement du bouton jouer" << std::endl;
}
sprite_jouer.setTexture(jouer);
sprite_jouer.setPosition(320, 140);
jouer.setSmooth(true);

if (!quitter.loadFromFile("quitter.png"))
{
std::cout << "Erreur lors du chargement du bouton quitter" << std::endl;
}
sprite_quitter.setTexture(quitter);
sprite_quitter.setPosition(320, 210);
quitter.setSmooth(true);


//texte

sf::Font font;
if (!font.loadFromFile("reforma.ttf"))
{
    // erreur...
}

sf::Text text;
text.setFont(font);
text.setString("BIENVENUE");  //texte écris entre (""). ou variable ().
text.setPosition(340, 80);
text.setCharacterSize(30);
text.setColor(sf::Color (40, 80, 140));


// temps que la fenetre est ouverte elle ne se ferme pas (condition)

      sf::Clock clock;
      while(window.isOpen())
      {
      sf::Event event;
      while(window.pollEvent(event))
      {
      if (event.type == sf::Event::Closed)
      window.close();
      }




// boutons

if (event.type == sf::Event::MouseButtonPressed)
{
    if (event.mouseButton.button == sf::Mouse::Left)
    {
        std::cout << "mouse x: " << event.mouseButton.x << std::endl;
        std::cout << "mouse y: " << event.mouseButton.y << std::endl;

       if (event.mouseButton.x > sprite_jouer.getPosition().x && event.mouseButton.y > sprite_jouer.getPosition().y &&
           event.mouseButton.x < sprite_jouer.getPosition().x + 150 && event.mouseButton.y < sprite_jouer.getPosition().y + 50)
       {

    sf::Clock time;

            //Personnage et Décors*


if (!perso.loadFromFile("hero.png"))
{
std::cout << "Erreur lors du chargement du Hero" << std::endl;
}
sprite_perso.setTexture(perso);
sprite_perso.setPosition(2, 380);
perso.setSmooth(true);


if (!nuage.loadFromFile("nuage.png"))
{
std::cout << "Erreur lors du chargement du Hero" << std::endl;
}
sprite_nuage.setTexture(nuage);
sprite_nuage.setPosition(200, 100);
nuage.setSmooth(true);


sf::Font font;
if (!font.loadFromFile("reforma.ttf"))
{
    // erreur...
}



// on définit le niveau à l'aide de numéro de tuiles// on crée la tilemap avec le niveau précédemment défini
    TileMap map;
    if (!map.load("tileset.png", sf::Vector2u(30, 30), level, 200, 14))
        return -1;

// temps que la fenetre est ouverte elle ne se ferme pas (condition)

      sf::Clock clock;
      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;
      }

//Gestion clavier

gestion_clavier();

//Temps d'animation du Personnage

if (UpdateFPS == true)
{
    if (time.getElapsedTime().asMilliseconds() >= 150)
{

    anim.x++;
    if (anim.x * 32 >= perso.getSize().x)
    anim.x = 0;
    time.restart();
}
}

// Création vue caméra

sprite_perso.setTextureRect(sf::IntRect(anim.x * 32, anim.y * 32, 32, 32));

    view.reset(sf::FloatRect(0, 0, largeurFenetre, hauteurFenetre));
    sf::Vector2f position(largeurFenetre / 2,hauteurFenetre / 2);
    position.x = sprite_perso.getPosition().x + 16 - (largeurFenetre / 2);
    position.y = sprite_perso.getPosition().y + 16 - (largeurFenetre / 2);
    if(position.x < 0)
    position.x = 0;
    if(position.y < 0)
    position.y = 0;
    view.reset(sf::FloatRect(position.x, position.y, largeurFenetre, hauteurFenetre));
    window.setView(view);

// Collisions

/* code collision ici ... */

// Ont dessine et on actualise avec "clear"

      window.clear();
      window.draw(map);
      window.draw(sprite_nuage);
      window.draw(sprite_perso);
      window.display();



    sf::Time frameTime = clock.restart();
    }

           std::cout << "BOUTON JOUER ACTIVE" << std::endl;
       }

       if (event.mouseButton.x > sprite_quitter.getPosition().x && event.mouseButton.y > sprite_quitter.getPosition().y &&
           event.mouseButton.x < sprite_quitter.getPosition().x + 150 && event.mouseButton.y < sprite_quitter.getPosition().y + 50)
       {

            sf::Event::Closed;
            window.close();
            break;

           std::cout << "BOUTON QUITTER ACTIVE" << std::endl;

       }
    }
}



// Ont dessine et on actualise avec "clear"

      window.clear();
      window.draw(text);
      window.draw(sprite_jouer);
      window.draw(sprite_quitter);
      window.display();



    }
 return 0;
}


void gestion_clavier()
{

    /* Gestion de mon clavier */

static bool bOne = false;
static float toX = sprite_perso.getPosition().x;


if (persoSurSol)
{

if (sf::Keyboard::isKeyPressed(sf::Keyboard:: Up))
    {

    if(!bOne ){
        bOne = true;
        saut = -8; //hauteur du saut
    }

}else{ bOne = false; }

saut += 0.3; // gravité
if (saut > 6.1){
    saut = 6.1; //graviteMaximal

}
}

if (sf::Keyboard::isKeyPressed(sf::Keyboard:: Left)){
  anim.y = Left;
  toX -= speed;
}

if (sf::Keyboard::isKeyPressed(sf::Keyboard:: Right)){
  anim.y = Right;
  toX  += speed;
}


sprite_perso.move( (toX * 1.2 - sprite_perso.getPosition().x)/10.0, saut); //10.0 qui correspond à la vitesse de décélération



    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().y >=330)
        sprite_perso.setPosition(sf::Vector2f(sprite_perso.getPosition().x, 330));




}
 

le vertex.cpp

(click to show/hide)

#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include <SFML/system.hpp>
#include <cmath>
#include <math.h>
#include <string>
#include <iostream>
#include <cstdlib>
#include <iostream>
#include "Variables.h"



 class TileMap : public sf::Drawable, public sf::Transformable
{
public:

    bool load(const std::string& tileset, sf::Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height)
    {
        // on charge la texture du tileset
        if (!m_tileset.loadFromFile("tileset.bmp"))
            return false;

        // on redimensionne le tableau de vertex pour qu'il puisse contenir tout le niveau
        m_vertices.setPrimitiveType(sf::Quads);
        m_vertices.resize(width * height * 4);

        // on remplit le tableau de vertex, avec un quad par tuile
        for (unsigned int i = 0; i < width; ++i)
            for (unsigned int j = 0; j < height; ++j)
            {
                // on récupère le numéro de tuile courant
                int tileNumber = tiles[i + j * width];

                // on en déduit sa position dans la texture du tileset
                int tu = tileNumber % (m_tileset.getSize().x / tileSize.x);
                int tv = tileNumber / (m_tileset.getSize().x / tileSize.x);

                // on récupère un pointeur vers le quad à définir dans le tableau de vertex
                sf::Vertex* quad = &m_vertices[(i + j * width) * 4];

                // on définit ses quatre coins
                quad[0].position = sf::Vector2f(i * tileSize.x, j * tileSize.y);
                quad[1].position = sf::Vector2f((i + 1) * tileSize.x, j * tileSize.y);
                quad[2].position = sf::Vector2f((i + 1) * tileSize.x, (j + 1) * tileSize.y);
                quad[3].position = sf::Vector2f(i * tileSize.x, (j + 1) * tileSize.y);

                // on définit ses quatre coordonnées de texture
                quad[0].texCoords = sf::Vector2f(tu * tileSize.x, tv * tileSize.y);
                quad[1].texCoords = sf::Vector2f((tu + 1) * tileSize.x, tv * tileSize.y);
                quad[2].texCoords = sf::Vector2f((tu + 1) * tileSize.x, (tv + 1) * tileSize.y);
                quad[3].texCoords = sf::Vector2f(tu * tileSize.x, (tv + 1) * tileSize.y);
            }
        return true;
    }

private:

    virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
    {
        // on applique la transformation
        states.transform *= getTransform();

        // on applique la texture du tileset
        states.texture = &m_tileset;

        // et on dessine enfin le tableau de vertex
        target.draw(m_vertices, states);
    }

    sf::VertexArray m_vertices;
    sf::Texture m_tileset;
};


 

Variables.hpp

(click to show/hide)

#ifndef VARIABLES_H_INCLUDED
#define VARIABLES_H_INCLUDED

//Mes Variables :

sf::RenderWindow window;
float speed(3);
void gestion_clavier();
sf::Vector2i positionSouris;
sf::Texture perso;
sf::Sprite sprite_perso;
sf::Texture nuage;
sf::Sprite sprite_nuage;
enum Dir{Down, Left, Right, Up};
sf::Vector2i anim(10, Down);
bool UpdateFPS (true);
sf::View view;
int largeurFenetre(800), hauteurFenetre(400);
sf::Texture getGlobalBounds;
sf::Sprite sprite_texture;
sf::Texture bloc;
sf::Sprite sprite_bloc;
float saut(-10);
sf::Window fenetre;
sf::Event evenement;
int persoSurSol (330);
sf::Event event;
std::string m_saisie("");
sf::Texture jouer;
sf::Sprite sprite_jouer;
sf::Texture quitter;
sf::Sprite sprite_quitter;

#endif // VARIABLES_H_INCLUDED

 

si jamais ce n'est pas assez clair voici le .ZIP de mon projet : http://www.fichier-zip.com/2014/12/30/jeux-2d/

J'utilise Code::Blocks et la SFML 2.1
Je vous remercie d'avance de vos réponses et encore une fois bonne année 2015 à vous tous.   

[kimci86]

Donc j'aimerais bien si possible que vous jetiez un oeil sur mon code (très peut simplifié et aussi pas très "propre")

Si tu veux que quelqu'un regarde ton code, pense au moins à l'indenter...

[G.]

Y'a pas que l'indentation, c'est le truc le plus dégueulasse que j'ai vu cette année, pourtant je suis passé sur openclassrooms hier.
Y'a des évènements à peu près partout mais pas dans les boucles d'évènements. Plusieurs boucles while(window.isOpen()) c'est douteux. Un sf::Event::Closed tout seul. Des trucs après des break...
Franchement, la moindre des choses quand on demande de l'aide c'est de donner un truc lisible.

Si tu veux un conseil qui concerne ton problème, vu que tu débutes tu devrais essayer de créer des collisions dans un truc à part, pour ne pas être gêné par tout le code qui n'a rien à voir avec ta collision. Genre tu crées un programme tout bête de 50 lignes avec 2 rectangles et tu tentes de résoudre des collisions entre eux, puis t'essaies avec plus de 2 sprites, etc. une fois que ça fonctionne comme tu veux et que tu as bien compris ce que tu fais tu tentes d'intégrer ce système à ton jeu.
Ça sera plus facile à réaliser, ça sera plus facile de demander de l'aide, ça sera moins dégueulasse.

Pour aller au plus simple, tu voudras très certainement te servir de la fonction getGlobalBounds (des sprites ou des rectangles) pour récupérer le rectangle englobant (un sf::Rect) de tes sprites, puis de la fonction intersects qui permet de voir si 2 sf::Rect (les rectangles englobants des 2 sprites que tu veux tester entre eux) se superposent (= collision).
Etant donné que pour ta tilemap tu n'utilises pas de sprites tu vas devoir créer toi-même les rectangles englobants de tes tiles.
De même pour tester si un point (la souris) est à l'intérieur d'un rectangle (un bouton), tu peux récupérer le rectangle englobant de ton bouton (getGlobalBounds) et utiliser sa fonction contains. Ça sera plus simple que de faire ce que tu fais pour Jouer et Quitter.
Tu peux évidemment faire comme dans le tuto de FVirtman auquel tu fais référence, mais autant utiliser des fonctions qui existent déjà.

[Quentin-35]

Salut merci de ta réponse, oui c'est pas propre comme code étant donné que à la base j'avais créer deux projet le jeux en question et le menu et apres j'ai mélangé les deux grosse erreur je vais réctifier sa merci, et merci du conseil je me lance dans la création des collisions avec un petit programme comme tu me la conseillé.

EDIT 2 :

Voici le code pour essayer les collisions (Il est mieux indenté ?) :p

(click to show/hide)

#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include <string>
#include <iostream>

using namespace std;

sf::RectangleShape rectangle1;
sf::RectangleShape rectangle2;
void gestion_clavier();

int main()
{

    //On créer la Fenêtre
    sf::RenderWindow window(sf::VideoMode(500, 400), "Collison");
    window.setFramerateLimit(200);

    //Je créer mes deux rectangles

    rectangle1.setFillColor(sf::Color(50, 200, 50));
    rectangle1.setSize(sf::Vector2f(30, 30));
    rectangle1.setPosition(50, 50);

    rectangle2.setFillColor(sf::Color(50, 60, 200));
    rectangle2.setSize(sf::Vector2f(100, 100));
    rectangle2.setPosition(200, 150);

    // temps que la fenetre est ouverte elle ne se ferme pas (condition)

      sf::Clock clock;
      while(window.isOpen())
      {
      sf::Event event;
      while(window.pollEvent(event))
      {
      if (event.type == sf::Event::Closed)
      window.close();
      }

//code contenue dans ma boucle :


    /* Gestion du clavier pour rectangle1 */

    gestion_clavier();

    /* Détection Collision */

if (rectangle1.getPosition().x + 30 >= rectangle2.getPosition().x && rectangle1.getPosition().y + 30 >= rectangle2.getPosition().y &&
    rectangle1.getPosition().x <= rectangle2.getPosition().x + 100 && rectangle1.getPosition().y <= rectangle2.getPosition().y + 100)
{
    cout << "Collision" << endl;
}


//On commence par actualiser avec Clear ensuite on dessine.

      window.clear();
      window.draw(rectangle2);
      window.draw(rectangle1);
      window.display();

      }

      return 0;
}


void gestion_clavier()
{


if (sf::Keyboard::isKeyPressed(sf::Keyboard:: Up))
{
 rectangle1.move(0, -1);
}

if (sf::Keyboard::isKeyPressed(sf::Keyboard:: Down))
{
 rectangle1.move(0, 1);
}

if (sf::Keyboard::isKeyPressed(sf::Keyboard:: Left))
{
 rectangle1.move(-1, 0);
}

if (sf::Keyboard::isKeyPressed(sf::Keyboard:: Right))
{
 rectangle1.move(1, 0);
}





    if (rectangle1.getPosition().x <=0)
        rectangle1.setPosition(sf::Vector2f(0, rectangle1.getPosition().y));
    if (rectangle1.getPosition().x + 30 >=500)
        rectangle1.setPosition(sf::Vector2f(470, rectangle1.getPosition().y));
    if (rectangle1.getPosition().y <=0)
        rectangle1.setPosition(sf::Vector2f(rectangle1.getPosition().x, 0));
    if (rectangle1.getPosition().y + 30>=400)
        rectangle1.setPosition(sf::Vector2f(rectangle1.getPosition().x, 370));




}
 

[Cmdu76]

Ce que je peux te conseiller comme technique "basique" :

- Tu crées un tableau contenant des futures tiles qui vont faire des collisions (std::vector<sf::FloatRect>)
- Tu parcours tes tiles
- Pour chaque tile, tu testes si l'id de ta tile est une des id que comptée comme entraînant une collision
- Si elle l'est tu ajoutes un FloatRect dans ton tableau avec cette petite formule
tab.push_back(sf::FloatRect(xTile * tileSize.x, yTile * tileSize.y, tileSize.x, tileSize.y)); // xTile et yTile sont les variables pour parcourir ton tableau de tiles

- Ensuite pour chaque update :
- Tu regardes si la getGlobalBounds() de la sprite de ton perso intersects avec un des blocs
- Si oui :
- Tu calcules comment décaler ton perso
- Et tu le décales tant que tu es encore en collision avec le rectangle qui posait problème