Bonjours à tous et à toutes! C'est mon premier message ici donc sachez simplement que je suis plutôt jeune mais à l'aise en C++ et que j'apprécie le libre, le chocolat et la philosophie... Mais revenons à mes moutons: Je tente actuellement de programmer un jeu, bonnes connaissances du C++ à l'appui. Après avoir installé la vertion 2.0 de la SFML sous Linux Ubuntu (avec LXDE parce que je ne supporte pas unity mais ce n'est pas important), je commence le moteur de pseudo 3D en vue de dessus que je nomme simplement profondeur. Après quelques erreurs faciles et un premier test, la fenetre ne m'affiche RIEN. Je pense que le problème vient soit méconnaissance de la SFML: Utilis-je correctement l'héritage de RenderWindow avec ma classe fenetre? Ces morceaux de code permettent de vérifier si je l'ais fait correctement:
Main.cpp:#include <SFML/Graphics.hpp>
#include <iostream>
#include <vector>
#include "fenetre.hpp"
#define X 400//largeur
#define Y 400//hauteur
using namespace std;
int main()
{
Fenetre fenetre(sf::VideoMode(X, Y), "TestProfondeur 1.0");
while(fenetre.isOpen())
{
sf::Event event;
switch (event.type)
{
case sf::Event::Closed://si l'évenement actuelement testé est la fermeture de la fenetre
fenetre.close();//on ferme la fenetre
break;
default:
break;
}
fenetre.clear();
fenetre.actualiser(event);
fenetre.display();
}
return 0;
}
fenetre.hpp#ifndef FENETRE_HPP_INCLUDED
#define FENETRE_HPP_INCLUDED
#include <iostream>
#include <fstream>
#include <vector>
#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include "map"
#include "poHeaders/objet.hpp"
#include "poHeaders/player.hpp"
class Fenetre : public sf::RenderWindow
{
public:
Fenetre(sf::VideoMode, std::string);
bool actualiser(sf::Event&);
protected:
int nbreTextures;
po::Objet objet1;
po::Objet objet2;
std::string packname;
po::Player joueur;
std::map<std::string, sf::Texture> m_textures;
};
#endif // FENETRE_HPP_INCLUDED
fenetre.cpp#include "fenetre.hpp"
using namespace std;
Fenetre::Fenetre(sf::VideoMode videomode, std::string nom) : sf::RenderWindow(videomode, nom)
{
std::string vinciCode;
std::string cheminInfoPack;
ifstream packsNames("GameData/textures/packsnames.txt");
packsNames>>vinciCode;
cheminInfoPack="GameData/textures/"+vinciCode+"/infos.txt";
ifstream listeTextures(cheminInfoPack.c_str());
while(listeTextures)
{
listeTextures>>vinciCode;
sf::Texture texture;
if(!texture.loadFromFile(vinciCode))
cout<<"ERREURWTF?!: Impossible de charger "<<vinciCode<<endl;
m_textures[vinciCode]=texture;
}
po::Position position(100, 100, 3000, 10, 30);
joueur.build(m_textures["cb.bmp"], po::Position(100, 100, 3000, 10, 30), po::Vie(20, 30, 30, 50, 40));
position.reBuild(10, 40, 2914, 40, 40);
objet1.build(m_textures["bleu.jpg"], position, joueur.getPosition());
position.reBuild(40, 10, 3100, 40, 40);
objet2.build(m_textures["rouge.jpg"], position, joueur.getPosition());
}
bool Fenetre::actualiser(sf::Event& event)
{
draw(objet1.getSprite());
return true;
}
Mais peut être que le problème est tout autre, que mes calculs pour la "3D" sont mal écrits et que j'affiche mon sprite à la position 50000 avec une taille nulle...
objet.hpp/*po::Objet est la classe de base de l'arborescence de Profondeur, elle
contient l'essentiel: Un pointeur vers une texture, un sprite et une
position (voir po::Position). La methode actualiser permet, en
fonction de la position de la caméra, d'actualiser la position et la
taille apparente de son sprite pour la pseudo 3D.*/
#ifndef OBJET_HPP_INCLUDED
#define OBJET_HPP_INCLUDED
#define CAMERA 100//définit de combien de pixel la vue est plus haute que le joueur
#include <SFML/Graphics.hpp>
#include <iostream>
#include "position.hpp"
namespace po
{
class Objet
{
public:
Objet();//constructeur par défaut, pour pouvoir le déclarer et l'initialiser plus tard avec build
Objet(sf::Texture&, po::Position&, po::Position);//paramètres: référence vers la texture, une position et la position du joueur
void actualiser(po::Position);//sert à réagir en fonction des évènements (position du joueur)
void build(sf::Texture&, po::Position&, po::Position);//si ce n'est pas déjà fait, construit l'objet. Même tache que le constructeur
sf::Sprite getSprite();
po::Position getPosition();
protected:
int ancienJoueurX;//stocke la position X du joueur lors du dernier appel de la fonction actualiser
int ancienJoueurY;//stocke la position Y du joueur lors du dernier appel de la fonction actualiser
po::Position m_posit;//la position de l'objet
sf::Texture *m_texture;//le pointeur vers la texture
sf::Sprite m_sprite;//le sprite de l'objet
bool estAffichable;//s'il est utile d'afficher l'objet
bool estConstruit;//pour savoir si l'objet a déjà été construit
};
}
#endif // OBJET_HPP_INCLUDED
objet.cpp#include "/home/alexis/programmes/C++/SFML/en développement actif/blablasfml/poHeaders/objet.hpp"
/**
Formule de la 3D:
taille_apparente_et_vitesse_apparente = distance_jusqu'à_l'objet_repère/distance_jusqu'à_l'objet_à_calculer *
taille_réèle_des_deux_objets ou distance_réèle_parcourue_par_les_deux_objets
*/
po::Objet::Objet(){estConstruit=false;}
po::Objet::Objet(sf::Texture& tex, po::Position &pos, po::Position posJoueur)
{
m_texture=&tex;
m_sprite.setTexture(*m_texture);
m_posit=pos;
estConstruit=true;
estAffichable=true;
m_sprite.setPosition(sf::Vector2f(m_posit.x, m_posit.y));
//on utilise la formule de la 3D pour trouver la taille apparente de l'objet:
m_sprite.setScale((posJoueur.z+CAMERA)/((posJoueur.z+CAMERA)-m_posit.z), (posJoueur.z+CAMERA)/((posJoueur.z+CAMERA)-m_posit.z));
}
void po::Objet::build(sf::Texture& tex, po::Position &pos,po::Position posJoueur)//fait exactement la même chose que le constructeur
{
if(!estConstruit)
{
m_texture=&tex;
m_sprite.setTexture(*m_texture);
m_posit=pos;
estConstruit=true;
m_sprite.setPosition(sf::Vector2f(m_posit.x, m_posit.y));
m_sprite.setScale((posJoueur.z+CAMERA)/((posJoueur.z+CAMERA)-m_posit.z), (posJoueur.z+CAMERA)/((posJoueur.z+CAMERA)-m_posit.z));
}
}
void po::Objet::actualiser(po::Position posJoueur)
{
int differenceX=posJoueur.x-ancienJoueurX;
int differenceY=posJoueur.y-ancienJoueurY;
if(posJoueur.z+CAMERA<m_posit.z){
m_sprite.setScale(0,0);
estAffichable=false;
}
else
//on utilise la formule de la 3D pour savoir à quelle vitesse apparente se déplacera l'objet:
m_sprite.move(sf::Vector2f(((posJoueur.z+CAMERA)/((posJoueur.z+CAMERA)-m_posit.z))*differenceX, ((posJoueur.z+CAMERA)/((posJoueur.z+CAMERA)-m_posit.z))*differenceY));
if(posJoueur.z+CAMERA>m_posit.z&&!estAffichable){
m_sprite.setScale((posJoueur.z+CAMERA)/((posJoueur.z+CAMERA)-m_posit.z), (posJoueur.z+CAMERA)/((posJoueur.z+CAMERA)-m_posit.z));
estAffichable=true;
}
ancienJoueurX=posJoueur.x;
ancienJoueurY=posJoueur.y;
}
sf::Sprite po::Objet::getSprite(){
return m_sprite;
}
po::Position po::Objet::getPosition(){
return m_posit;
}
position.hpp/*po::position est une classe englobant les paramètres relatifs à la position 3D et à
la forme du sprite: deux float pour la position (pour qu'elle soit toujours la
plus précise), un int positif pour la hauteur et deux pour la forme.
*/
vie.hpp/*po::Vie regroupe les variables essentielles contenant la vie des
différentes parties du corps du personnage, l'énumération corps
sert à rendre plus logiques certaines méthodes (voir po::Faune).*/
enum corps{cerveau, gauche, droite, bas, centre};
Vie(int,int,int,int,int);//paramètres: cerveau, droite, gauche, centre, bas
faune.hpp/*po::Faune est la classe de base héritant de po::Objet pour les monstres,
les PNJs et même... le joueur. Il utilise po::Vie et les nouvelles
méthodes addLife et remLife qui font exactement ce qu'elles disent
(voir l'énumération corps dans vie.hpp).
*/
Faune();
Faune(sf::Texture&, po::Position&,po::Position, po::Vie);// paramètre supplémentaire: LA VIE (et oui, nous créons la vie! [rire du docteur frankenstein])
void build(sf::Texture&, po::Position&,po::Position, po::Vie);//même rôle que dans objet
void addLife(corps, int);//pour ajouter des vies
void remLife(corps, int);//pour enlever des vies
bool estVivant;
protected:
po::Vie vie;
bool estConstruit;
player.hpp/*po::player [basique] est la classe qui va définir tous les paramètres spécifiques
au joueur comme son inventaire, avec les armes qu'il porte actuellement [à suivre...]
*/
public:
Player();
Player(sf::Texture&, po::Position, po::Vie);
void build(sf::Texture&, po::Position, po::Vie);
protected:
bool estConstruit;
Je me demande bien ce qui m'échappe... Je continue les recherches de mon coté pour la deuxième possibilité...
