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
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 ?