Bienvenue, Invité. Merci de vous connecter ou de vous inscrire. Avez-vous oublié d'activer ?

Messages récents

Pages: « Précédente 1 ... 8 9 [10]
91
Projets SFML / Re: Moteur de jeu SFML pour Android et PC
« Dernier message par IsDaouda le Mars 10, 2020, 12:20:22 am »
Salut à tous,
Nouvelle mise à jour pour is::Engine.

- Ajout de la fonction basicSFMLMain() implémenter dans core/basicSFMLMain.cpp et utilisable dans le main.cpp.

Cette fonction lance une fenetre SFML sans passer par le rendu principal du moteur. Elle vous permet d'utiliser votre propre boucle de rendu avec le moteur.

Ceci a pour but de permettre aux débutants d'utiliser facilement le moteur et de permettre à d'autres personnes d'utiliser le moteur pour exporter des projets existants sur d'autres OS (Android, Linux, Windows).
92
Discussions générales / Re: SFML Warning
« Dernier message par Laurent le Mars 09, 2020, 12:46:53 pm »
Citer
J'insiste bien sur les segfaults random
Ils ont beau être aléatoires, un debugger te sera bien plus utile que ma boule de cristal ;)

Citer
undefined reference to `sf::CircleShape::CircleShape(float, unsigned int)'
Ce n'est pas une erreur de compilation, mais d'édition de liens. Cela signifie que l'éditeur de liens ne trouve pas la fonction citée dans les bibliothèques SFML, bien que celle-ci soit déclarée dans les en-têtes. Causes récurrentes de ce genre d'erreur : tu n'as pas lié à sfml-graphics, ou alors à une version qui ne correspond pas aux en-têtes (ça peut être le cas lorsque plusieurs versions de SFML cohabitent).
93
Discussions générales / Re: SFML Warning
« Dernier message par strikeblack91 le Mars 09, 2020, 10:04:28 am »
Bonjour

J'insiste bien sur les segfaults random, liés à la librairie (enfin à un problème d'installation de mon côté...).
De plus, je n'ai pas accès à certaines features de la libraire. Quand j'essaye le main de test de la SFML(https://www.sfml-dev.org/tutorials/2.5/start-linux.php), j'obtiens l'erreur de compilation suivante :

/usr/bin/ld: main.o: in function `main':
main.cpp:(.text+0xfc): undefined reference to `sf::CircleShape::CircleShape(float, unsigned int)'
collect2: error: ld returned 1 exit status
94
Discussions générales / Re: SFML Warning
« Dernier message par Laurent le Mars 08, 2020, 06:18:51 pm »
Le "warning" n'est pas gênant, ça te dit simplement que tu as un contexte OpenGL 4.6 et non 2.0, mais c'est 100% compatible.

Si tu as un crash il faut utiliser ton debugger pour le résoudre.
95
Discussions générales / SFML Warning
« Dernier message par strikeblack91 le Mars 08, 2020, 01:18:08 pm »
Bonjour

Je suis étudiant à Epitech et je dois réaliser divers programmes en utilisant la sfml.
Le problème et que lorsque je lance mon programme, des warnings apparaissent et le programme segfault de manière random:

Warning: The created OpenGL context does not fully meet the settings that were requested
Requested: version = 2.0 ; depth bits = 0 ; stencil bits = 0 ; AA level = 0 ; core = false ; debug = false ; sRGB = true
Created: version = 4.6 ; depth bits = 0 ; stencil bits = 0 ; AA level = 0 ; core = false ; debug = false ; sRGB = true

Par contre, si je lance mon programme sur l'ordinateur de mon collègue, le programme marche parfaitement.
Après de nombreuses recherches sur le net, je me tourne vers vous ... help
96
Graphique / Re: SetPos avec matrice
« Dernier message par Laurent le Février 26, 2020, 08:45:00 pm »
Et le "int" que tu sors de ta matrice, il représente quoi ? En tout cas, si tu veux positionner un rectangle il te faudra à un moment donné une position...
97
Graphique / SetPos avec matrice
« Dernier message par Bonjour le Février 26, 2020, 06:47:49 pm »
Bonjour bonsoir  :)

je me permet de vous demander une petite question.

La voici : puis-je faire un "rectangle.setPositionmatrice[nbr1][nbr2]" avec l'include vector
Je créer la matrice comme ceci std::vector<std::vector<int> > matrice;

Si cela n'est pas assez claire voici en exemple, un jeu d'echec, mettre une pièce sur une case sans mettre la position sur le pixel mais directement sur la matrice

Mais le setPosition ne fonctionne pas avec matrice  :(

Je suis sur le bon chemin ?

Merci de votre aide
98
Graphique / Re: tileMap Sprite Positionnement et Scintillement
« Dernier message par TrucMuche le Février 23, 2020, 03:24:41 pm »
J'ai essayé cela :
https://fr.sfml-dev.org/forums/index.php?topic=8786.0

Mais le résultat est vraiment très moche. Mes tuiles sont aléatoirement découpées

Mon code actuel :

//directive de préprocesseur

//systeme windows
#include <windows.h>

//Standard
#include <iostream>
#include <string>
#include <ctime>
#include <cstdlib>

//SFML
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>

//obtention de la taille de l'écran utilisateur en pixel.
float const SCREEN_Width = GetSystemMetrics(SM_CXSCREEN);
float const SCREEN_Height = GetSystemMetrics(SM_CYSCREEN);

int const UP = 0, UP_RIGHT = 1, RIGHT = 2, DOWN_RIGHT = 3, DOWN = 4,DOWN_LEFT = 5,LEFT = 6,UP_LEFT = 7;
void maj_direction(bool up,bool right, bool down, bool left, float& xMove , float& yMove)
{

    int direction = -1;

    if ( up && !right && !down && !left )//up
        {direction = UP;            xMove = 0;      yMove = -4;}
    if ( up &&  right && !down && !left )//up right
        {direction = UP_RIGHT;      xMove = 4;      yMove = -2;}
    if (!up &&  right && !down && !left )//right
        {direction = RIGHT;         xMove = 4;      yMove = 0;}
    if (!up &&  right &&  down && !left )//down right
        {direction = DOWN_RIGHT;    xMove = 4;      yMove = 2;}
    if (!up && !right &&  down && !left )//down
        {direction = DOWN;          xMove = 0;      yMove = 4;}
    if (!up && !right &&  down &&  left )//down left
        {direction = DOWN_LEFT;     xMove = -4;     yMove = 2;}
    if (!up && !right && !down &&  left )// left
        {direction = LEFT;          xMove = -4;     yMove = 0;}
    if ( up && !right && !down &&  left )// up left
        {direction = UP_LEFT;       xMove = -4;     yMove = -2;}

    if ( !up && !right && !down &&  !left ){direction = -1; xMove = 0; yMove = 0;}
}


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))
            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);

        int compteurAxeY = 0;
        // on remplit le tableau de vertex, avec un quad par tuile
        for (unsigned int i = 0; i < width; ++i)
        {
            compteurAxeY = 0;

            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 en fonction de :
                if (( j % 2) == 0) // si j est paire
                {
                    compteurAxeY = compteurAxeY + tileSize.y;
                    quad[0].position = sf::Vector2f( i   * tileSize.x  , compteurAxeY);
                    quad[1].position = sf::Vector2f((i+1)* tileSize.x  , compteurAxeY);
                    quad[2].position = sf::Vector2f((i+1)* tileSize.x  , compteurAxeY + tileSize.y);
                    quad[3].position = sf::Vector2f( i   * tileSize.x  , compteurAxeY + tileSize.y);

                }
                else //j impaire
                {
                    quad[0].position = sf::Vector2f( i   * tileSize.x + (tileSize.x / 2) , compteurAxeY + (tileSize.y/2) );
                    quad[1].position = sf::Vector2f((i+1)* tileSize.x + (tileSize.x / 2) , compteurAxeY + (tileSize.y/2) );
                    quad[2].position = sf::Vector2f((i+1)* tileSize.x + (tileSize.x / 2) , compteurAxeY +  tileSize.y + (tileSize.y/2) );
                    quad[3].position = sf::Vector2f( i   * tileSize.x + (tileSize.x / 2) , compteurAxeY+  tileSize.y + (tileSize.y/2) );
                }

                // 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;
};


int main()
{
//-------------------------
//création de la fenêtre
//-------------------------
    sf::RenderWindow myWindow(sf::VideoMode(0,0), "World",sf::Style::Fullscreen );
    //sf::RenderWindow myWindow((sf::VideoMode::GetMode(0)); //can't use this instruction because GetMode is not a member of sf::VideoMode !!!!!!!?
    myWindow.setVerticalSyncEnabled(true); //activation de synchronisation vertical pour meilleur affichage
    myWindow.setFramerateLimit(60);//max fps
    myWindow.setKeyRepeatEnabled(false);//Désactivation de la répétition lorsqu'une touche est maintenu appuyée.

    //Activation de l'icon de la fenêtre // set a icon
    sf::Image icon;
    if(!icon.loadFromFile("icon.png")){std::cout << "Load of icon Failed!" <<std::endl;}
    myWindow.setIcon(32,32,icon.getPixelsPtr());

    // création d'une vue à partir de ( sa position centrale , et de sa taille )
    //sf::View gameView(sf::Vector2f(800.f, 600.f), sf::Vector2f(1200.f, 600.f));
    //float event_ResizedWidth = 1.f;
    //float event_ResizedHeight = 1.f;
    //sf::FloatRect visibleArea(0.f, 0.f,event_ResizedWidth,event_ResizedHeight);
    //gameView.setViewport(visibleArea);
    sf::View gameView;
    gameView.setSize(SCREEN_Width,SCREEN_Height);
    gameView.setCenter( (SCREEN_Width/2) , (SCREEN_Height/2) );

    // Déterminer s'il faut des bandes horizontales ou verticales
    float largeur_image = 1200;
    float hauteur_image = 600;
    if (SCREEN_Width/SCREEN_Height < hauteur_image/largeur_image)// Fenêtre plus large que l'image (relativement à leur hauteur)
    {
        // Bandes à-gauche et à-droite
        // Définir la proportion entre le "input" et le "output" de "view_1" pour que le haut et le bas correspondent
        gameView.zoom(hauteur_image/SCREEN_Height);
        // Ne représenter que la zone "input" (et pas un élément extérieur pouvant par-exemple glisser dedans), et la représenter au-centre de la fenêtre
        gameView.setViewport({(1-largeur_image*SCREEN_Height/hauteur_image/SCREEN_Width)/2, 0, largeur_image*SCREEN_Height/hauteur_image/SCREEN_Width, 1});
    }
    else
        // Fenêtre plus haute que l'image (relativement à leur largeur), ou formats équivalents
        // Bandes en-haut et en-bas
    {   // Définir la proportion entre le "input" et le "output" de "view_1" pour que la gauche et la droite correspondent
        gameView.zoom(largeur_image/SCREEN_Width);
        // Ne représenter que la zone "input" (et pas un élément extérieur pouvant par-exemple glisser dedans), et la représenter au-centre de la fenêtre
        gameView.setViewport({0, (1-hauteur_image*SCREEN_Width/largeur_image/SCREEN_Height)/2, 1, hauteur_image*SCREEN_Width/largeur_image/SCREEN_Height});
    }


    // Attribuer "view_1" à "RenderWindow_1"; je crois qu'il n'y a pas besoin de le refaire en cas de modification de "view_1", mais il faudrait vérifier
    //RenderWindow_1.setView(View_1);

    //-------------------------
    // horloge du jeux // game timer
    //-------------------------
    sf::Clock gameClock; //démarre le chrono
    sf::Time timeInterval = sf::milliseconds(15);//espace de temps entre chaque mise à jours de la map
    sf::Time timeElapsed = gameClock.getElapsedTime();//enregistre le temps actuel
    sf::Time timePrecElapsed = timeElapsed;//enregistre le temps actuel précédent

    // variable pour déplacement de la map // variable for move the map
    float xMove = 0 , yMove = 0;

    // on définit le niveau à l'aide de numéro de tuiles // define the level with tiles numbers
    const int level[] =
    {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,//3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

        /*0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
        1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3,
        0, 1, 0, 0, 2, 0, 3, 3, 3, 0, 1, 1, 1, 0, 0, 0,
        0, 1, 1, 0, 3, 3, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0,
        0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        2, 0, 1, 0, 3, 0, 2, 2, 2, 0, 1, 1, 1, 1, 1, 1,
        0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1,*/

    };

    // on crée la tilemap avec le niveau précédemment défini
    TileMap myMap;
    if (!myMap.load("Images/GAME/MAP/tileset.png", sf::Vector2u(128, 64), level, 16, 32))
    {
        //error...
        std::cout << "Load of tileset Failed!" <<std::endl;
        exit(EXIT_FAILURE);
        //return -1;
    }

    bool up ,upRight, right, downRight, down, downLeft, left, upLeft;
    up = 0; upRight=0; right=0; downRight=0; down=0; downLeft=0; left=0; upLeft=0;
    int choix = 1;
    while (myWindow.isOpen() && choix == 1)
    {
        // on traite tous les évènements de la fenêtre qui ont été générés depuis la dernière itération de la boucle
        sf::Event event;
        //------------------------------
        //Gestion Clavier , joystick ...
        //------------------------------
        while (myWindow.pollEvent(event))
        {// tant qu'il y a des évènements : clavier , joystick...
            switch (event.type)
            {
                //croix fermeture fenêtre.
                case sf::Event::Closed:
                    choix = 0;
                    //window.close();
                    std::cout << "fenetre fermee par [X]!" <<std::endl;
                    break;
                // n'importe quelle touche pressée
                case sf::Event::KeyPressed:
                    switch (event.key.code)
                    {
                        case sf::Keyboard::Escape:
                            choix = 0;
                            //window.close();
                            std::cout << "fenetre fermee par Escape!" <<std::endl;
                            break;
                        case sf::Keyboard::Up:
                            up = 1;
                            down = 0;
                            break;
                        case sf::Keyboard::Right:
                            right = 1;
                            left = 0;
                            break;
                        case sf::Keyboard::Down:
                            down = 1;
                            up = 0;
                            break;
                        case sf::Keyboard::Left:
                            left = 1;
                            right = 0;
                            break;
                        default:
                            break;
                    }
                    break;
                //n'importe quelle touche relachée
                case sf::Event::KeyReleased:
                    switch (event.key.code)
                    {
                        case sf::Keyboard::Up:
                            up = 0;
                            break;
                        case sf::Keyboard::Right:
                            right = 0;
                            break;
                        case sf::Keyboard::Down:
                            down = 0;
                            break;
                        case sf::Keyboard::Left:
                            left = 0;
                            break;
                        default:
                            break;
                    }
                    break;
            }
        }

        //------------------------------
        //Mise à jour de l'affichage
        //------------------------------
        // effacement de la fenêtre en une couleur au choix
        myWindow.clear(sf::Color(0,0,0));//BLACK

        myWindow.setView(gameView);

        //déplacement de la View
        timeElapsed = gameClock.getElapsedTime();//Mise à jour du temps écoulé
        if (timeElapsed >= timePrecElapsed + timeInterval)
        {
            maj_direction(up, right, down, left,xMove,yMove);
            timePrecElapsed = timeElapsed;
            // déplacement de la vue
            gameView.move(xMove, yMove);
        }
        myWindow.draw(myMap);

        //réactivation de la vue par défaut wh
        //myWindow.setView(myWindow.getDefaultView());

        //affichage de la nouvelle frame
        myWindow.display();
    }
//fin du programme
return 0;
}

Biensur j'ai éssayé le tuto sur les view https://www.sfml-dev.org/tutorials/2.5/graphics-view-fr.php
J'ai fait fonctionner "Affichée plus lorsque la fenêtre est redimentionnée" ça a fonctionné mais je ne pouvais plus déplacer la vue. Puis je souhaite être en plein écran.

Comment être en fullScreen sans redimentionner quoi que ce soit, mise à part la fenêtre ?
99
Graphique / Re: tileMap Sprite Positionnement et Scintillement
« Dernier message par TrucMuche le Février 23, 2020, 02:40:43 pm »
Plus le resize des images en fullscreen que je n'arrive pas à désactiver ...
100
Graphique / Re: tileMap Sprite Positionnement et Scintillement
« Dernier message par TrucMuche le Février 20, 2020, 08:09:31 pm »
C'est encore moi  ::)

Je suis parvenu à exploiter le tuto de la SFML concernant le tile map. Je l'ai réadapté pour mon tile map isométrique.

 Il fonctionne, voici le code :

//directive de préprocesseur

//systeme windows
#include <windows.h>

//Standard
#include <iostream>
#include <string>
#include <ctime>
#include <cstdlib>

//SFML
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>

//obtention de la taille de l'écran utilisateur en pixel.
int const SCREEN_X = GetSystemMetrics(SM_CXSCREEN);
int const SCREEN_Y = GetSystemMetrics(SM_CYSCREEN);
int const SCREEN_X_MIDDLE = SCREEN_X / 2;
int const SCREEN_Y_MIDDLE = SCREEN_Y / 2;

//Constante de la MAP
int const TAILLEMAP_X = 10, TAILLEMAP_Y = 20;
int const UP = 4, UP_RIGHT = 3, RIGHT = 2, DOWN_RIGHT = 1, DOWN = 0,DOWN_LEFT = 7,LEFT = 6,UP_LEFT = 5;



void maj_direction(bool up,bool right, bool down, bool left, int& xMove , int& yMove)
{

    int direction = -1;

    if ( up && !right && !down && !left )
        {direction = UP; xMove = 0; yMove = -1;}
    if ( up &&  right && !down && !left )
    {direction = UP_RIGHT; xMove = 1; yMove = -1;}
    if (!up &&  right && !down && !left )
    {direction = RIGHT; xMove = 1; yMove = 0;}
    if (!up &&  right &&  down && !left )
    {direction = DOWN_RIGHT; xMove = 1; yMove = 1;}
    if (!up && !right &&  down && !left )
    {direction = DOWN; xMove = 0; yMove = 1;}
    if (!up && !right &&  down &&  left )
    {direction = DOWN_LEFT; xMove = -1; yMove = 1;}
    if (!up && !right && !down &&  left )
    {direction = LEFT; xMove = -1; yMove = 0;}
    if ( up && !right && !down &&  left )
    {direction = UP_LEFT; xMove = -1; yMove = -1;}

    if ( !up && !right && !down &&  !left ){direction = -1; xMove = 0; yMove = 0;}
}

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))
            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);

        int compteurAxeY = 0;
        // on remplit le tableau de vertex, avec un quad par tuile
        for (unsigned int i = 0; i < width; ++i)
        {
            compteurAxeY = 0;

            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 en fonction de :
                if (( j % 2) == 0) // si j est paire
                {
                    compteurAxeY = compteurAxeY + tileSize.y;
                    quad[0].position = sf::Vector2f( i   * tileSize.x  , compteurAxeY);
                    quad[1].position = sf::Vector2f((i+1)* tileSize.x  , compteurAxeY);
                    quad[2].position = sf::Vector2f((i+1)* tileSize.x  , compteurAxeY + tileSize.y);
                    quad[3].position = sf::Vector2f( i   * tileSize.x  , compteurAxeY + tileSize.y);

                }
                else //j impaire
                {
                    quad[0].position = sf::Vector2f( i   * tileSize.x + (tileSize.x / 2) , compteurAxeY + (tileSize.y/2) );
                    quad[1].position = sf::Vector2f((i+1)* tileSize.x + (tileSize.x / 2) , compteurAxeY + (tileSize.y/2) );
                    quad[2].position = sf::Vector2f((i+1)* tileSize.x + (tileSize.x / 2) , compteurAxeY +  tileSize.y + (tileSize.y/2) );
                    quad[3].position = sf::Vector2f( i   * tileSize.x + (tileSize.x / 2) , compteurAxeY+  tileSize.y + (tileSize.y/2) );
                }

                // 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;
};


int main()
{
//-------------------------
//création de la fenêtre
//-------------------------
    sf::RenderWindow myWindow(sf::VideoMode(1200, 600), "testMAP");//celon taille écran
    //sf::RenderWindow myWindow(sf::VideoMode(SCREEN_X, SCREEN_Y), "BLABLA",sf::Style::Fullscreen);//plein écran
    myWindow.setVerticalSyncEnabled(false); //activation de synchronisation vertical pour meilleur affichage
    myWindow.setFramerateLimit(60);// max fps
    myWindow.setKeyRepeatEnabled(false);//Désactivation de la répétition lorsqu'une touche est maintenu appuyée.
    //Activation de l'icon de la fenêtre
    sf::Image icon;
    if(!icon.loadFromFile("icon.png"))
    {
        //error...
        std::cout << "Load of icon Failed!" <<std::endl;
        exit(EXIT_FAILURE);
    }
    myWindow.setIcon(32,32,icon.getPixelsPtr());

    //-------------------------
    // Time du jeux
    //-------------------------
    sf::Clock gameClock; //démarre le chrono
    sf::Time timeInterval = sf::milliseconds(20);;//espace de temps entre chaque mise à jours de la map
    sf::Time timeElapsed = gameClock.getElapsedTime();//enregistre le temps actuel
    sf::Time timePrecElapsed = timeElapsed;//enregistre le temps actuel précédent


    int xMove = 0 , yMove = 0; //test de déplacement de la map

        // on définit le niveau à l'aide de numéro de tuiles
    const int level[] =
    {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

        /*0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
        1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3,
        0, 1, 0, 0, 2, 0, 3, 3, 3, 0, 1, 1, 1, 0, 0, 0,
        0, 1, 1, 0, 3, 3, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0,
        0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
        2, 0, 1, 0, 3, 0, 2, 2, 2, 0, 1, 1, 1, 1, 1, 1,
        0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1,*/

    };

    // on crée la tilemap avec le niveau précédemment défini
    TileMap myMap;
    if (!myMap.load("Images/GAME/MAP/tilesetTEST_V3.png", sf::Vector2u(128, 64), level, 8, 6))
        return -1;

    sf::Texture mapFullTexture;
    mapFullTexture.loadFromFile("Images/GAME/MAP/fullTEXTURE.png");
    sf::Sprite mapSprite;
    mapSprite.setTexture(mapFullTexture);
    mapSprite.setPosition(0,0);

    bool up ,upRight, right, downRight, down, downLeft, left, upLeft;
    up = 0; upRight=0; right=0; downRight=0; down=0; downLeft=0; left=0; upLeft=0;
    int choix = 1;
    while (myWindow.isOpen() && choix == 1)
    {
        // on traite tous les évènements de la fenêtre qui ont été générés depuis la dernière itération de la boucle
        sf::Event event;
        //------------------------------
        //Gestion Clavier , joystick ...
        //------------------------------
        while (myWindow.pollEvent(event))
        {// tant qu'il y a des évènements : clavier , joystick...
            switch (event.type)
            {
                //croix fermeture fenêtre
                case sf::Event::Closed:
                    choix = 0;
                    //window.close();
                    std::cout << "fenetre fermee par [X]!" <<std::endl;
                    break;
                // n'importe quelle touche pressée
                case sf::Event::KeyPressed:
                    switch (event.key.code)
                    {
                        case sf::Keyboard::Escape:
                            choix = 0;
                            //window.close();
                            std::cout << "fenetre fermee par Escape!" <<std::endl;
                            break;
                        case sf::Keyboard::Up:
                            up = 1;
                            down = 0;
                            break;
                        case sf::Keyboard::Right:
                            right = 1;
                            left = 0;
                            break;
                        case sf::Keyboard::Down:
                            down = 1;
                            up = 0;
                            break;
                        case sf::Keyboard::Left:
                            left = 1;
                            right = 0;
                            break;
                        default:
                            choix = 0;
                            break;
                    }
                    break;
                //n'importe quelle touche relachée
                case sf::Event::KeyReleased:
                    switch (event.key.code)
                    {
                        case sf::Keyboard::Up:
                            up = 0;
                            break;
                        case sf::Keyboard::Right:
                            right = 0;
                            break;
                        case sf::Keyboard::Down:
                            down = 0;
                            break;
                        case sf::Keyboard::Left:
                            left = 0;
                            break;
                        default:
                            break;
                    }
                    break;
            }
        }


        //------------------------------
        //Mise à jour de l'affichage
        //------------------------------
        timeElapsed = gameClock.getElapsedTime();//Mise à jour du temps écoulé
        // effacement de la fenêtre en une couleur au choix
        myWindow.clear(sf::Color(255,255,150));//BLANC beige
        // c'est ici qu'on dessine tout

        // gestion affichage de la map
        maj_direction(up, right, down, left,xMove,yMove);
        if (timeElapsed >= timePrecElapsed + timeInterval)
        {
            timePrecElapsed = timeElapsed;
            myMap.move(xMove,yMove);
            //mapSprite.move(xMove,yMove);
        }

        myWindow.draw(myMap);
        //myWindow.draw(mapSprite);

        //affichage de la nouvelle frame
        myWindow.display();
    }
//fin du programme
return 0;
}
 

C'est trop propre les Classes.

Seulement voila j'ai toujours un petit kwak, plus aucun scintillement la c'est génial

myWindow.setVerticalSyncEnabled(true); // ou false
En option soit un sprite standard soit une classe fille type drawable / transformable optimisé celon le tuto.

Lorsque je change de direction up_right up_left ou down_right down_left alternativement, il y un effet désagréable sur les lignes noires des tuiles, un coup c'est la diagonale " \ " qui est lisse l'autre " / " pixélisée, puis un coup c'est l'inverse selon la direction. 

Que j'utilise la Classe optimisée ou un sprite de tuile utilisant une texture de plusieurs tuile. (si joint)

Avec mes tests je suis presque persuadé que ce n'est plus lié à la SFML.

Quelqu'un à une idée ou une piste à me donner ?
Ma tuile doit elle faire 64/128 ou 65/129 ...
Dois je abandonner les bordures de tuile et les diagonales pures 1:2 ?
Dois-je poser une autre question ? <----   ???
TOK TOK ? " c'est le début d'une blague ça ? "

Salut
Pages: « Précédente 1 ... 8 9 [10]