Sujet Précédent Sujet Suivant

Erreur de segmentation (segfault) sur un return int

Résolu
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018 - 20 avril 2011 à 20:31
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018 - 25 avril 2011 à 21:41
Bonjour, decidemment j'aime bien ce forum ^^ et par la meme occasion les erreurs de segmentation car en ce moment c'est mon fort (Patato ou cptPingu .... êtes vous la !!!)

Alors je vous explique j'ai un projet de jeu avec la SFML, et une obligation d'utilisation d'une archi model/vue (sans controleur).

Le jeu s'appelle jeu de la vie : une matrice de cellules, on ajoute ou supprime des cellules, on appuie sur "play", et suivant le nombre de voisins (configuré par l'utilisateur), une cellule meurt ou non au temps t+1 et ainsi de suite. Les virus sont prevus mais pas encore de classe.

Voici donc la presque integralité de mon code (presque parce que j'ai des intros avant le jeu que je ne met pas car inutile ca fonctionne parfaitement).

SI jamais vous voyez que j'ai fait un ecart par rapport a l'architecture modele/vue merci de m'indiquer ou et des conseils si possible....

Je sais que le code est long mais comme cela vous pouvez compiler directement

ArchiVue.h 

#include "Position.h"
#include "Cellule.h"

using namespace sf;

class ArchiModel;
class Cellule;

class ArchiVue {
 private:
  int _w, _h;
   
  Position _p_pause, _p_play, _p_arret, _p_curseur_vitesse, _p_scroll_1, _p_scroll_2, _p_scroll_vitesse;
  Position _p_plus_ligne, _p_moins_ligne, _p_plus_colonne, _p_moins_colonne;
  Position _p_curseur_min_cell, _p_curseur_max_cell;
  Position _p_curseur_temps_incub, _p_curseur_nb_enfants;
  Position _click, _new_cell; // pour la matrice
  
  String _t_texte_min_cell, _t_texte_max_cell;
  String _t_texte_temps_incub, _t_texte_nb_enfants;
  String _t_texte_vitesse, _t_texte_cell, _t_texte_bact;  
  String _t_texte_ligne, _t_texte_colonne;
  
  Font _police;
  
  RenderWindow * _window;
  ArchiModel * _model;
  Cellule * _cellule;

  Image _background_image;
  Sprite _background_sprite;
  
  //jeu
  
  Sprite _new_cell_sprite;
  float _size_case_x, _size_case_y;
  float _size_new_cell_X, _size_new_cell_Y;
  
  //menu
  Image _menu_recap_plus_image;
  Image _menu_recap_moins_image;
  
  Sprite _menu_recap_plus_ligne_sprite;
  Sprite _menu_recap_moins_ligne_sprite;
  Sprite _menu_recap_plus_colonne_sprite;
  Sprite _menu_recap_moins_colonne_sprite;
  float _size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y;

  Image _menu_recap_image;
  Sprite _menu_recap_sprite;
  float _size_menu_recap_X, _size_menu_recap_Y;
  
  Image _menu_global_bact_image;
  Sprite _menu_global_bact_sprite;

  Image _menu_global_cell_image;
  Sprite _menu_global_cell_sprite;
  float _size_menu_global_onglet_Y, _size_menu_global_X; //identique pour les deux menu globaux (bact selectionné ou cell)

  Image _menu_pause_image;
  Sprite _menu_pause_sprite;
  float _size_menu_pause_X, _size_menu_pause_Y;
  
  Image _menu_play_image;
  Sprite _menu_play_sprite;
  float _size_menu_play_X, _size_menu_play_Y;	

  Image _menu_arret_image;
  Sprite _menu_arret_sprite;	
  float	_size_menu_arret_X, _size_menu_arret_Y;
  
  Image _menu_scroll_image; 
  Sprite _menu_scroll_1_sprite; // cell-> min voisines / bact -> tmps incubation
  float	_size_menu_scroll_X, _size_menu_scroll_Y;
  
  Sprite _menu_scroll_2_sprite;	//cell -> max voisines / bact -> nb enfants
  Sprite _menu_scroll_vitesse_sprite;	

  Image _menu_curseur_image;
  Sprite _menu_curseur_vitesse_sprite;	
  float	_size_menu_curseur_X, _size_menu_curseur_Y;
  
  //elements du menu cellule
  Sprite _menu_curseur_min_cell_sprite;	
  Sprite _menu_curseur_max_cell_sprite;	

  //elements du menu virus
  Sprite _menu_curseur_incub_virus_sprite;	
  Sprite _menu_curseur_enfant_virus_sprite;	
  
  //Cellules
  Image _cell_image;
  Sprite _cell_sprite;

  Image _cell_strong_image;
  Sprite _cell_strong_sprite;

  Image _cell_ill_image;
  Sprite _cell_ill_sprite;
  float _size_cell_Y, _size_cell_X; //toutes les cellules ont la meme taille
  
  //Virus
  Image _bact_image;
  Sprite _bact_sprite;
  float _size_bact_Y, _size_bact_X; 
  
 public:
 
  ArchiVue(int w, int h);
  ~ArchiVue();
  
  void setModel(ArchiModel * model);
  void setWH(RenderWindow* _window);
  float getSIZECASEX();
  float getSIZECASEY();
  
  void draw(bool &passerIntro, bool &affiche_onglet_cell);
  
  void dessineMatrice();
  
  //adaptation taille et position avec taille fenetre
  void majTaille();
  void majPos();
  
  bool treatEvents(bool &passerIntro, bool &affiche_onglet_cell);
};
#endif


ArchiVue.cc 

#include 
#include <cstdlib>
#include <SFML/Audio.hpp>
#include <vector>
#include "Position.h"
#include "ArchiVue.h"
#include "ArchiModel.h"
#include "Cellule.h"

using namespace std;
using namespace sf;

/****************************************
 			Constructeur
****************************************/	

ArchiVue::ArchiVue(int w, int h): _w(w), _h(h)
{
    _window = new RenderWindow(sf::VideoMode(w, h, 64), "Game of life", sf::Style::Resize);
    majTaille();
    majPos();

    _police.LoadFromFile("Ressources/Dauphin_ttf.ttf");

    _t_texte_min_cell.SetText("Nb voisines min");
    _t_texte_max_cell.SetText("Nb voisines max");
    _t_texte_temps_incub.SetText("Temps d'incubation");
    _t_texte_nb_enfants.SetText("Enfants par virus");
    _t_texte_vitesse.SetText("Vitesse defilement");
    _t_texte_cell.SetText("Cellules : 100");
    _t_texte_bact.SetText("Virus : 9999");
    _t_texte_colonne.SetText("colonnes");
    _t_texte_ligne.SetText("lignes");

    _t_texte_min_cell.SetFont(_police);
    _t_texte_min_cell.SetSize(18);
    _t_texte_min_cell.SetColor(sf::Color(162, 64, 162));
    _t_texte_min_cell.SetPosition(5, _p_curseur_min_cell.getPosY() - 18 - 5);

    _t_texte_max_cell.SetFont(_police);
    _t_texte_max_cell.SetSize(18);
    _t_texte_max_cell.SetColor(sf::Color(162, 64, 162));
    _t_texte_max_cell.SetPosition(5, _p_curseur_max_cell.getPosY() - 18 - 5);

    _t_texte_temps_incub.SetFont(_police);
    _t_texte_temps_incub.SetSize(18);
    _t_texte_temps_incub.SetColor(sf::Color(162, 64, 162));
    _t_texte_temps_incub.SetPosition(5, _p_curseur_temps_incub.getPosY() - 18 - 5);

    _t_texte_nb_enfants.SetFont(_police);
    _t_texte_nb_enfants.SetSize(18);
    _t_texte_nb_enfants.SetColor(sf::Color(162, 64, 162));
    _t_texte_nb_enfants.SetFont(_police);
    _t_texte_nb_enfants.SetPosition(5, _p_curseur_nb_enfants.getPosY() - 18 - 5);

    _t_texte_vitesse.SetFont(_police);
    _t_texte_vitesse.SetSize(18);
    _t_texte_vitesse.SetColor(sf::Color(162, 64, 162));
    _t_texte_vitesse.SetPosition(5, _p_curseur_vitesse.getPosY() - 18 - 5);

    _t_texte_cell.SetFont(_police);
    _t_texte_cell.SetSize(18);
    _t_texte_cell.SetColor(sf::Color(162, 64, 162));
    _t_texte_cell.SetPosition(_size_menu_global_X + 5, 6.5);

    _t_texte_bact.SetFont(_police);
    _t_texte_bact.SetSize(18);
    _t_texte_bact.SetColor(sf::Color(162, 64, 162));
    _t_texte_bact.SetPosition(_size_menu_global_X * 1.66, 6.5);

    _t_texte_ligne.SetFont(_police);
    _t_texte_ligne.SetSize(18);
    _t_texte_ligne.SetColor(sf::Color(162, 64, 162));
    _t_texte_ligne.SetPosition(_w - (8.32 * _size_menu_recap_PlusMoins_X), 6.5);

    _t_texte_colonne.SetFont(_police);
    _t_texte_colonne.SetSize(18);
    _t_texte_colonne.SetColor(sf::Color(162, 64, 162));
    _t_texte_colonne.SetPosition(_w - (3.4 * _size_menu_recap_PlusMoins_X), 6.5);

if (!_background_image.LoadFromFile("Ressources/LinuxWorld.jpg")
|| !_menu_global_bact_image.LoadFromFile("Ressources/Select_bact.png")
|| !_menu_global_cell_image.LoadFromFile("Ressources/Select_cell.png")
|| !_bact_image.LoadFromFile("Ressources/Virus.png")
|| !_cell_image.LoadFromFile("Ressources/Cellule.png")
|| !_cell_ill_image.LoadFromFile("Ressources/Cellule_malade.png")
|| !_cell_strong_image.LoadFromFile("Ressources/Cellule_resistante.png")
|| !_menu_scroll_image.LoadFromFile("Ressources/Scroll.png")
|| !_menu_curseur_image.LoadFromFile("Ressources/Curseur.png")
|| !_menu_recap_image.LoadFromFile("Ressources/Recap.png")
|| !_menu_recap_plus_image.LoadFromFile("Ressources/Plus.png")
|| !_menu_recap_moins_image.LoadFromFile("Ressources/Moins.png")
|| !_menu_pause_image.LoadFromFile("Ressources/Pause.png")
|| !_menu_play_image.LoadFromFile("Ressources/Play.png")
|| !_menu_arret_image.LoadFromFile("Ressources/Arret.png")
{
    //jeu
    _background_sprite = Sprite ();
    _cell_ill_sprite = Sprite ();
    _cell_strong_sprite = Sprite ();
    _cell_sprite = Sprite ();
    _bact_sprite = Sprite ();
    //menus
    _menu_global_bact_sprite = Sprite ();
    _menu_global_cell_sprite = Sprite ();
    _menu_pause_sprite = Sprite ();
    _menu_play_sprite = Sprite ();
    _menu_arret_sprite = Sprite ();
    _menu_scroll_1_sprite = Sprite ();
    _menu_scroll_2_sprite = Sprite ();
    _menu_scroll_vitesse_sprite = Sprite ();
    _menu_curseur_vitesse_sprite = Sprite ();
    _menu_recap_sprite = Sprite ();
    _menu_recap_plus_ligne_sprite = Sprite ();
    _menu_recap_moins_ligne_sprite = Sprite ();
    _menu_recap_plus_colonne_sprite = Sprite ();
    _menu_recap_moins_colonne_sprite = Sprite ();
    //onglet cell
    _menu_curseur_min_cell_sprite = Sprite ();
    _menu_curseur_max_cell_sprite = Sprite ();
   //onglet virus		
    _menu_curseur_incub_virus_sprite = Sprite ();
    _menu_curseur_enfant_virus_sprite = Sprite ();
}	
else 
{
//jeu
_background_sprite = Sprite (_background_image);
_background_sprite.Resize(_w, _h);
_background_sprite.SetPosition(0,0);
_new_cell_sprite = Sprite (_cell_image);
_new_cell_sprite.Resize(_size_new_cell_X, _size_new_cell_Y);
_new_cell_sprite.SetPosition(_new_cell.getPosX(), _new_cell.getPosY());

//menu		
_cell_ill_sprite = Sprite (_cell_ill_image);
_cell_ill_sprite.Resize(_size_cell_X, _size_cell_Y);
_cell_ill_sprite.SetPosition(_size_menu_global_X/2.75, _h/1.125);
_cell_strong_sprite = Sprite (_cell_strong_image);
_cell_strong_sprite.Resize(_size_cell_X, _size_cell_Y);
_cell_strong_sprite.SetPosition(_size_menu_global_X/2.75, _h/1.125);

_cell_sprite = Sprite (_cell_image);
_cell_sprite.Resize(_size_cell_X, _size_cell_Y);
_cell_sprite.SetPosition(_size_menu_global_X/2.75, _h/12.70);

_bact_sprite = Sprite (_bact_image);
_bact_sprite.Resize(_size_bact_X, _size_bact_Y);
_bact_sprite.SetPosition(_size_menu_global_X/3.5, _h/12.70);

_menu_global_bact_sprite = Sprite (_menu_global_bact_image);
_menu_global_bact_sprite.Resize(_size_menu_global_X, _h);
_menu_global_bact_sprite.SetPosition(0,0);		

_menu_global_cell_sprite = Sprite (_menu_global_cell_image);
_menu_global_cell_sprite.Resize(_size_menu_global_X, _h);
_menu_global_cell_sprite.SetPosition(0,0);	

_menu_pause_sprite = Sprite (_menu_pause_image);
_menu_pause_sprite.Resize(_size_menu_pause_X, _size_menu_pause_Y);
_menu_pause_sprite.SetPosition(_p_pause.getPosX(), _p_pause.getPosY());

_menu_play_sprite = Sprite (_menu_play_image);
_menu_play_sprite.Resize(_size_menu_play_X, _size_menu_play_Y);
_menu_play_sprite.SetPosition(_p_play.getPosX(), _p_play.getPosY());

_menu_arret_sprite = Sprite (_menu_arret_image);
_menu_arret_sprite.Resize(_size_menu_arret_X, _size_menu_arret_Y);
_menu_arret_sprite.SetPosition(_p_arret.getPosX(), _p_arret.getPosY());

_menu_scroll_1_sprite = Sprite (_menu_scroll_image);
_menu_scroll_1_sprite.Resize(_size_menu_scroll_X, _size_menu_scroll_Y);
_menu_scroll_1_sprite.SetPosition(_p_scroll_1.getPosX(), _p_scroll_1.getPosY());

_menu_recap_sprite = Sprite (_menu_recap_image);
_menu_recap_sprite.Resize(_size_menu_recap_X, _size_menu_recap_Y);
_menu_recap_sprite.SetPosition(_size_menu_global_X, 0);

_menu_recap_plus_ligne_sprite = Sprite (_menu_recap_plus_image);
_menu_recap_plus_ligne_sprite.Resize(_size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y);
_menu_recap_plus_ligne_sprite.SetPosition(_p_plus_ligne.getPosX(), _p_plus_ligne.getPosY());			

_menu_recap_moins_ligne_sprite = Sprite (_menu_recap_moins_image);
_menu_recap_moins_ligne_sprite.Resize(_size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y);	_menu_recap_moins_ligne_sprite.SetPosition(_p_moins_ligne.getPosX(), _p_moins_ligne.getPosY());

_menu_recap_plus_colonne_sprite = Sprite (_menu_recap_plus_image);
_menu_recap_plus_colonne_sprite.Resize(_size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y);
_menu_recap_plus_colonne_sprite.SetPosition(_p_plus_colonne.getPosX(), _p_plus_colonne.getPosY());			

_menu_recap_moins_colonne_sprite = Sprite (_menu_recap_moins_image);
_menu_recap_moins_colonne_sprite.Resize(_size_menu_recap_PlusMoins_X, _size_menu_recap_PlusMoins_Y);
_menu_recap_moins_colonne_sprite.SetPosition(_p_moins_colonne.getPosX(), _p_moins_colonne.getPosY());

_menu_scroll_2_sprite = Sprite (_menu_scroll_image);
_menu_scroll_2_sprite.Resize(_size_menu_scroll_X, _size_menu_scroll_Y);
_menu_scroll_2_sprite.SetPosition(_p_scroll_2.getPosX(), _p_scroll_2.getPosY());

_menu_scroll_vitesse_sprite = Sprite (_menu_scroll_image);
_menu_scroll_vitesse_sprite.Resize(_size_menu_scroll_X, _size_menu_scroll_Y);
_menu_scroll_vitesse_sprite.SetPosition(_p_scroll_vitesse.getPosX(), _p_scroll_vitesse.getPosY());

_menu_curseur_vitesse_sprite = Sprite (_menu_curseur_image); //scroll 3
_menu_curseur_vitesse_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_vitesse_sprite.SetPosition(_p_curseur_vitesse.getPosX(), _p_curseur_vitesse.getPosY());

//onglet Cellule
_menu_curseur_min_cell_sprite = Sprite (_menu_curseur_image);
_menu_curseur_min_cell_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_min_cell_sprite.SetPosition(_p_curseur_min_cell.getPosX(), _p_curseur_min_cell.getPosY());

_menu_curseur_max_cell_sprite = Sprite (_menu_curseur_image);
_menu_curseur_max_cell_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_max_cell_sprite.SetPosition(_p_curseur_max_cell.getPosX(), _p_curseur_max_cell.getPosY());

//onglet virus

_menu_curseur_incub_virus_sprite = Sprite (_menu_curseur_image);
_menu_curseur_incub_virus_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_incub_virus_sprite.SetPosition(_p_curseur_temps_incub.getPosX(), _p_curseur_temps_incub.getPosY());

_menu_curseur_enfant_virus_sprite = Sprite (_menu_curseur_image);
_menu_curseur_enfant_virus_sprite.Resize(_size_menu_curseur_X, _size_menu_curseur_Y);
_menu_curseur_enfant_virus_sprite.SetPosition(_p_curseur_nb_enfants.getPosX(), _p_curseur_nb_enfants.getPosY());
}

/***************************************
Destructeur
***************************************/

ArchiVue::~ArchiVue()
{
  if(_window != 0)
    delete _window;
  if(_model != 0)
    delete _model;
  if(_cellule != 0)
    delete _cellule;
}

/***************************************
Accesseur en ecriture
***************************************/

void ArchiVue::setModel(ArchiModel * model)
{
  _model = model;
}

void ArchiVue::setWH(RenderWindow* _window)
{
_w = (_window->GetWidth());
_h = (_window->GetHeight());
}



/****************************************
Accesseur en lecture
****************************************/

float ArchiVue::getSIZECASEX()
{
//size_x = _size_case_x;
return _size_case_x;
} 

float ArchiVue::getSIZECASEY()
{
//size_y = _size_case_y;
return _size_case_y;
}

/****************************************
  Mise à jour des tailles et positions
****************************************/

void ArchiVue::majTaille()
{	
//menus du jeu
_size_menu_global_X = _w/4;
_size_menu_global_onglet_Y = _h/15;
_size_menu_pause_X = _w/17.019;
_size_menu_pause_Y = _h/10.525;
_size_menu_play_X = _w/17.019; 
_size_menu_play_Y = _h/10.525;	
_size_menu_arret_X = _w/15.6862;
_size_menu_arret_Y = _h/11.764;
_size_menu_scroll_X = _size_menu_global_X - 10;
_size_menu_scroll_Y = _h/22 ;
    _size_menu_curseur_X = _w/150 ;
    _size_menu_curseur_Y = _h/14 ;
    _size_menu_recap_X = _w - _size_menu_global_X ;
_size_menu_recap_Y = _size_menu_global_onglet_Y ;
_size_menu_recap_PlusMoins_X = _w/23 ;
_size_menu_recap_PlusMoins_Y = _size_menu_recap_Y - 10 ;

//matrice
_size_case_x = (_size_menu_global_X - (_w/(_model->getNBCOLONNES())));
_size_case_y = (_size_menu_recap_Y - (_h/(_model->getNBLIGNES())));

//Cellules
_size_cell_X = _w/15 ;
_size_cell_Y = _size_cell_X ; 

//Virus
_size_bact_X = _w/9 ;
_size_bact_Y = _h/13 ; 
}

void ArchiVue::majPos()
{
//Menu
    _p_pause.setPosX(_w/6.3) ;
    _p_pause.setPosY(_h/1.35) ;
    _p_play.setPosX(_w/27) ;
    _p_play.setPosY(_h/1.35) ;
    _p_arret.setPosX(_w/10.6) ;
    _p_arret.setPosY(_h/1.65) ; 
    _p_curseur_vitesse.setPosX(_w/162) ;
    _p_curseur_vitesse.setPosY(_h/2.027) ;
    _p_scroll_1.setPosX(_w/160) ;
    _p_scroll_1.setPosY(_h/4.25) ;
    _p_scroll_2.setPosX(_w/160) ;
    _p_scroll_2.setPosY(_h/2.70) ;
    _p_scroll_vitesse.setPosX(_w/160) ;
    _p_scroll_vitesse.setPosY(_h/1.98) ;
    
    //menu recap
    _p_plus_ligne.setPosX(_w/1.40);
    _p_plus_ligne.setPosY(4.5); 
    _p_moins_ligne.setPosX(_w/1.8);
    _p_moins_ligne.setPosY(4.5);
    _p_plus_colonne.setPosX(_w - _size_menu_recap_PlusMoins_X - 5);
    _p_plus_colonne.setPosY(4.5); 
    _p_moins_colonne.setPosX(_w/1.30);
    _p_moins_colonne.setPosY(4.5);

//Onglet cellule
_p_curseur_min_cell.setPosX(_w/162) ;
_p_curseur_min_cell.setPosY(_h/4.47) ;
_p_curseur_max_cell.setPosX(_w/162) ;
_p_curseur_max_cell.setPosY(_h/2.8) ;

//Onglet virus
/*_p_curseur_temps_incub = _p_curseur_min_cell ;
_p_curseur_nb_enfants = _p_curseur_max_cell ;*/
_p_curseur_temps_incub.setPosX(_p_curseur_min_cell.getPosX());
_p_curseur_temps_incub.setPosY(_p_curseur_min_cell.getPosY());
_p_curseur_nb_enfants.setPosX(_p_curseur_max_cell.getPosX());
_p_curseur_nb_enfants.setPosY(_p_curseur_max_cell.getPosY());

//Matrice
_new_cell.setPosX(0);
_new_cell.setPosY(0);
}

/****************************************
Affichage des images
****************************************/

void ArchiVue::draw(bool &affiche_onglet_cell)
{   
    setWH(_window); //ajustement fenetre : recuperation taille réel fenetre _w et _h  
    _window->Draw(_background_sprite); //Image de fond du jeu
    
    if(affiche_onglet_cell)
    {
_window->Draw(_menu_global_cell_sprite);
_window->Draw(_cell_sprite);		
_window->Draw(_cell_strong_sprite);
}
else if(!affiche_onglet_cell)
    {
_window->Draw(_menu_global_bact_sprite);			
_window->Draw(_bact_sprite);
_window->Draw(_cell_ill_sprite);
}

//controle de la simulation
_window->Draw(_menu_pause_sprite);
_window->Draw(_menu_play_sprite);
_window->Draw(_menu_arret_sprite);
_window->Draw(_menu_scroll_1_sprite);
_window->Draw(_menu_scroll_2_sprite);
_window->Draw(_menu_scroll_vitesse_sprite); // vitesse de defilement simulation
_window->Draw(_menu_curseur_vitesse_sprite);
_window->Draw(_menu_recap_sprite);
_window->Draw(_menu_recap_plus_ligne_sprite);
    _window->Draw(_menu_recap_moins_ligne_sprite);
_window->Draw(_menu_recap_plus_colonne_sprite);
_window->Draw(_menu_recap_moins_colonne_sprite);
_window->Draw(_t_texte_vitesse);
    _window->Draw(_t_texte_cell);
    _window->Draw(_t_texte_bact);	
    _window->Draw(_t_texte_colonne);
    _window->Draw(_t_texte_ligne);
    
    dessineMatrice();

if(affiche_onglet_cell) //meme test que dessus car il faut afficher le fond puis l'onglet puis scroll puis curseur...
{
_window->Draw(_t_texte_min_cell);
_window->Draw(_t_texte_max_cell);

_window->Draw(_menu_curseur_min_cell_sprite);
_window->Draw(_menu_curseur_max_cell_sprite);	
}
else if(!affiche_onglet_cell)
    {			
_window->Draw(_menu_curseur_incub_virus_sprite);
_window->Draw(_menu_curseur_enfant_virus_sprite);

_window->Draw(_t_texte_temps_incub);
_window->Draw(_t_texte_nb_enfants);
}	
    _window->Display();
    usleep(500);
  }
}

/******************************************************
   Dessin de la matrice
******************************************************/

void ArchiVue::dessineMatrice()
{	
vector<vector > _matrice_cellules_T;	
_matrice_cellules_T.resize(_model->getNBLIGNES(), vector(_model->getNBCOLONNES(), false));
_matrice_cellules_T = (_cellule->getMATRICECELLT());
for(int i=0; i < _model->getNBCOLONNES(); i++)
{
for(int j=0; j < _model->getNBLIGNES(); j++)
{
if(_matrice_cellules_T[i][j]) // on affiche la matrice actuelle 
{
// taille d'une cellule adaptée au nombre de L et Col
_new_cell_sprite.Resize(((_size_case_x) -2), ((_size_case_y) -2));
_new_cell.setPosX((i * (_size_case_x)) + _size_menu_global_X + 1);
_new_cell.setPosY((j * (_size_case_y)) + _size_menu_recap_Y + 1);
_new_cell_sprite.SetPosition(_new_cell.getPosX(), _new_cell.getPosY());
_window->Draw(_new_cell_sprite);
}
}

}
}

usleep(5000);
}

/******************************************************
   Traitement des evenements
Retourne false si un evenement de fin est reçu
******************************************************/

bool ArchiVue::treatEvents(bool &affiche_onglet_cell)
{
bool result = false;
if(_window->IsOpened())
{
result = true;
Event event;
// const Input &input = _window->GetInput(); pour curseurs suivents souris ---- fonctionne pas
while (_window->GetEvent(event))
{
int MouseX = _window->GetInput().GetMouseX(); //recupere position souris x
int MouseY = _window->GetInput().GetMouseY(); // idem en y

//valable tout le temps
if ((event.Type sf::Event::Closed) || (((event.Type sf::Event::KeyPressed) && (event.Key.Code == sf::Key::Escape))))
{
_window->Close();
result = false;
}

//mise a jour = adapte nouvelle taille fenetre grace a GetWidth et GetHeight dans draw
_w = _window->GetWidth();
_h = _window->GetHeight();
majTaille();
majPos();				

                        if((event.Type sf::Event::MouseButtonPressed) && (event.MouseButton.Button sf::Mouse::Left)) 
{
/** clics dans le menu **/
//selection de l'onglet cellule
if((MouseX >= 0) && (MouseX <= (_size_menu_global_X/2)) && (MouseY >= 0 ) && (MouseY <= _size_menu_global_onglet_Y))
{
affiche_onglet_cell = true;
}
//selection de l'onglet virus
else if((MouseX >= (_size_menu_global_X/2)) && (MouseX <= _size_menu_global_X) && (MouseY >= 0 ) && (MouseY <= _size_menu_global_onglet_Y))
{
affiche_onglet_cell = false;
}

/** clics sur boutons du menu **/

/** Dans l'onglet cellule **/
if(affiche_onglet_cell)
{
//curseur min cellules voisines -> clic sur scroll
if((MouseX >= _p_scroll_1.getPosX()) && (MouseX <= (_p_scroll_1.getPosX() + _size_menu_scroll_X + 1 - _size_menu_curseur_X)) && (MouseY >= _p_scroll_1.getPosY()) && (MouseY <= (_p_scroll_1.getPosY() + _size_menu_scroll_Y)))
{
_p_curseur_min_cell.setPosX(MouseX);
_menu_curseur_min_cell_sprite.SetPosition(_p_curseur_min_cell.getPosX(), _p_curseur_min_cell.getPosY());		
}
//curseur max cellule -> clic sur scroll						else if((MouseX >= _p_scroll_2.getPosX()) && (MouseX <= (_p_scroll_2.getPosX() + _size_menu_scroll_X + 1 - _size_menu_curseur_X)) && (MouseY >= _p_scroll_2.getPosY()) && (MouseY <= (_p_scroll_2.getPosY() + _size_menu_scroll_Y)))
{
_p_curseur_max_cell.setPosX(MouseX);
_menu_curseur_max_cell_sprite.SetPosition(_p_curseur_max_cell.getPosX(), _p_curseur_max_cell.getPosY());
}
/*else if(event.Type == sf::Event::MouseMoved) // les curseurs suivent la souris marche pas
{
if((MouseX >= _p_curseur_min_cell.getPosX()) && (MouseX <= (_p_curseur_min_cell.getPosX() + _size_menu_curseur_X)) && (MouseY >= _p_curseur_min_cell.getPosY()) && (MouseY <= (_p_curseur_min_cell.getPosY() + _size_menu_curseur_Y))) //deplacement curseur min cell
{
_p_curseur_min_cell.setPosX(event.MouseMove.X);
    	_menu_curseur_min_cell_sprite.SetPosition(_p_curseur_min_cell.getPosX(), _p_curseur_min_cell.getPosY());
cout<<"suivi min cell"<<endl;
}
else if((MouseX >= _p_curseur_max_cell.getPosX()) && (MouseX <= (_p_curseur_max_cell.getPosX() + _size_menu_curseur_X)) && (MouseY >= _p_curseur_max_cell.getPosY()) && (MouseY <= (_p_curseur_max_cell.getPosY() + _size_menu_curseur_Y))) // idem max cell
{
_p_curseur_max_cell.setPosX(event.MouseMove.X);
    	_menu_curseur_max_cell_sprite.SetPosition(_p_curseur_max_cell.getPosX(), _p_curseur_max_cell.getPosY());
cout<<"suivi max cell"<<endl;
}
}	*/
}
/** Dans l'onglet virus **/
else if(!affiche_onglet_cell)
{
//curseur temps d'incubation
if((MouseX >= _p_scroll_1.getPosX()) && (MouseX <= (_p_scroll_1.getPosX() + _size_menu_scroll_X + 1- _size_menu_curseur_X)) && (MouseY >= _p_scroll_1.getPosY()) && (MouseY <= (_p_scroll_1.getPosY() + _size_menu_scroll_Y)))
{
_p_curseur_temps_incub.setPosX(MouseX);
_menu_curseur_incub_virus_sprite.SetPosition(_p_curseur_temps_incub.getPosX(), _p_curseur_temps_incub.getPosY());						}
//curseur nb enfants par virus
else if((MouseX >= _p_scroll_2.getPosX()) && (MouseX <= (_p_scroll_2.getPosX() + _size_menu_scroll_X + 1 - _size_menu_curseur_X)) && (MouseY >= _p_scroll_2.getPosY()) && (MouseY <= (_p_scroll_2.getPosY() + _size_menu_scroll_Y)))
{
_p_curseur_nb_enfants.setPosX(MouseX);
_menu_curseur_enfant_virus_sprite.SetPosition(_p_curseur_nb_enfants.getPosX(), _p_curseur_nb_enfants.getPosX());
}

}

/** Objets communs **/

//play
if((MouseX >= _p_play.getPosX()) && (MouseX <= (_p_play.getPosX() + _size_menu_play_X)) && (MouseY >= _p_play.getPosY()) && (MouseY <= (_p_play.getPosY() + _size_menu_play_Y)))
{
cout<<"clic sur play"<<endl;
}
//pause
else if((MouseX >= _p_pause.getPosX()) && (MouseX <= (_p_pause.getPosX() + _size_menu_pause_X)) && (MouseY >= _p_pause.getPosY()) && (MouseY <= (_p_pause.getPosY() + _size_menu_pause_Y)))
{
cout<<"clic sur pause"<<endl;
}
//arret
else if((MouseX >= _p_arret.getPosX()) && (MouseX <= (_p_arret.getPosX() + _size_menu_arret_X)) && (MouseY >= _p_arret.getPosY()) && (MouseY <= (_p_arret.getPosY() + _size_menu_arret_Y)))
{
cout<<"clic sur arret"<<endl;
}
//curseur vitesse de defilement
else if((MouseX >= _p_scroll_vitesse.getPosX()) && (MouseX <= (_p_scroll_vitesse.getPosX() + _size_menu_scroll_X + 1 - _size_menu_curseur_X)) && (MouseY >= _p_scroll_vitesse.getPosY()) && (MouseY <= (_p_scroll_vitesse.getPosY() + _size_menu_scroll_Y)))
{
_p_curseur_vitesse.setPosX(MouseX);
_menu_curseur_vitesse_sprite.SetPosition(_p_curseur_vitesse.getPosX(), _p_curseur_vitesse.getPosY());
}
// - ligne
else if((MouseX >= _p_moins_ligne.getPosX()) && (MouseX <= (_p_moins_ligne.getPosX() + _size_menu_recap_PlusMoins_X)) && (MouseY >= _p_moins_ligne.getPosY()) && (MouseY <= (_p_moins_ligne.getPosY() + _size_menu_recap_PlusMoins_Y)))
{
if(_model->getNBLIGNES() > 0)
{
cout<<"- 1 ligne"<<endl;
_model->setNBLIGNES(_model->getNBLIGNES() - 1);
}
}
// + ligne
else if((MouseX >= _p_plus_ligne.getPosX()) && (MouseX <= (_p_plus_ligne.getPosX() + _size_menu_recap_PlusMoins_X)) && (MouseY >= _p_plus_ligne.getPosY()) && (MouseY <= (_p_plus_ligne.getPosY() + _size_menu_recap_PlusMoins_Y)))
{
if(_model->getNBLIGNES() < 10)
{
cout<<"+ 1 ligne"<<endl;
_model->setNBLIGNES(_model->getNBLIGNES() + 1);
}
}
// - colonne
else if((MouseX >= _p_moins_colonne.getPosX()) && (MouseX <= (_p_moins_colonne.getPosX() + _size_menu_recap_PlusMoins_X)) && (MouseY >= _p_moins_colonne.getPosY()) && (MouseY <= (_p_moins_colonne.getPosY() + _size_menu_recap_PlusMoins_Y)))
{
if(_model->getNBCOLONNES() > 0)
{
_model->setNBCOLONNES(_model->getNBCOLONNES() - 1);
cout<<"- 1 colonne"<<endl;
}
}
// + colonne
else if((MouseX >= _p_plus_colonne.getPosX()) && (MouseX <= (_p_plus_colonne.getPosX() + _size_menu_recap_PlusMoins_X)) && (MouseY >= _p_plus_colonne.getPosY()) && (MouseY <= (_p_plus_colonne.getPosY() + _size_menu_recap_PlusMoins_Y)))
{
if(_model->getNBCOLONNES() < 12)
{
_model->setNBCOLONNES(_model->getNBCOLONNES() + 1);
cout<<"+ 1 colonne"<<endl;
}
}	

/** Dans la matrice **/		
// clic gauche pour ajouter une cellule							if(((MouseX > _size_menu_global_X) && (MouseX < _w)) && ((MouseY > _size_menu_recap_Y) && (MouseY < _h)))
{
_click.setPosX(MouseX - _size_menu_global_X); // On va donc envoyer la position de la souris 

_click.setPosY(MouseY - _size_menu_recap_Y); // qui sera dans la matrice
// pause = true;
bool ajout = true;
_cellule->ajoutOuSuppCellule(_click, ajout);
}
}
else if((event.Type sf::Event::MouseButtonPressed) && (event.MouseButton.Button sf::Mouse::Right))
{
// clic droit pour supprimer une cellule
if(((MouseX > _size_menu_global_X) && (MouseX < _w)) && ((MouseY > _size_menu_recap_Y) && (MouseY < _h)))
{
                        _click.setPosX(MouseX - _size_menu_global_X); 
_click.setPosY(MouseY - _size_menu_recap_Y);
// pause = true;
bool ajout = false;
_cellule->ajoutOuSuppCellule(_click, ajout);
                }
}
}				
}
} 
  return result;
}


ArchiModel.h 

#ifndef _ARCHI_MODEL_
#define _ARCHI_MODEL_

#include <SFML/System.hpp>
#include <vector>
#include "Cellule.h"

using namespace std;

class Cellule;

class ArchiModel {
 private:
  int _w, _h;
  int _nb_lignes, _nb_colonnes;
  
  Cellule * _cellule;

 public:

  ArchiModel();
  ArchiModel(int w, int h);
  ~ArchiModel();
  
  //vector<vector > getMATRICECELLTM() const;
  
  int getNBCOLONNES();
  void setNBCOLONNES(int nb);
  
  int getNBLIGNES();
  void setNBLIGNES(int nb);
  
  void nextStep();
  
};
#endif
[code=cpp]


ArchiModel.cc

[code=cpp]
#include <vector>
#include 
#include <cstdlib>
#include "ArchiModel.h"
#include "Cellule.h"

using namespace std;

/****************************************
 			Constructeur
****************************************/
ArchiModel::ArchiModel() : _w(800), _h(600)
{
_nb_lignes = 4; 
_nb_colonnes = 4;
}

ArchiModel::ArchiModel(int w, int h) :  _w(w), _h(h)
{

}

/****************************************
 			Destructeur
****************************************/

ArchiModel::~ArchiModel()
{
if(_cellule != 0)
delete _cellule;
}

/****************************************
 		Accesseurs en lecture
****************************************/

int ArchiModel::getNBCOLONNES()
{
return _nb_colonnes;
} 

int ArchiModel::getNBLIGNES()
{
return _nb_lignes;
}

/****************************************
 		Accesseurs en ecriture
****************************************/

void ArchiModel::setNBLIGNES(int nb)
{
_nb_lignes = nb;
}

void ArchiModel::setNBCOLONNES(int nb)
{
_nb_colonnes = nb;
}

/****************************************
 			Prochaine etape
****************************************/
void ArchiModel::nextStep(){
//on prepare la matrice future T+1
}


Cellule.h 

#ifndef _CELLULE_
#define _CELLULE_

#include <vector>
#include "ArchiModel.h"
#include "ArchiVue.h"

class ArchiModel;
class ArchiVue;

using namespace std;

class Cellule 
{
private :
vector<vector > _matrice_cellules_T;
//vector<vector > _matrice_cellules_T_1;

int _nb_voisins ;
int _max_nb_voisins,  _min_nb_voisins;

ArchiModel* _model;
ArchiVue* _vue;

public:
Cellule();
//Cellule(int x , int y , vector<vector > _m_matrice_cellules, int _nb_voisins , int _max_nb_voisins , int _min_nb_voisins);
~Cellule();

vector<vector > getMATRICECELLT() const;

void ajoutOuSuppCellule(Position click, bool ajout);
void Generation();
//void Meurt();
//Resistance();
};
#endif


Cellule.cc 

#include <vector>
#include "Cellule.h"
#include "ArchiVue.h"
#include "ArchiModel.h"
#include 
#include <cstdlib>

using namespace std;

Cellule::Cellule()
{
_matrice_cellules_T.resize(_model->getNBLIGNES(), vector(_model->getNBCOLONNES(), false)); // initialisation matrice 2D à faux
//_matrice_cellules_T_1.resize(_vue->getNBLIGNES(), vector(_vue->getNBCOLONNES(), false));
_nb_voisins = 0 ;
_max_nb_voisins = 0;
_min_nb_voisins = 8;

}

Cellule::~Cellule()
{
  if(_model != 0)	
delete _model;
  if(_vue != 0)	
delete _vue;
}

vector<vector > Cellule::getMATRICECELLT() const
{
return _matrice_cellules_T;
}


void Cellule::ajoutOuSuppCellule(Position click, bool ajout)
{
float size_case_x = (_vue->getSIZECASEX());
float size_case_y = (_vue->getSIZECASEY());

for(int i=0; i < (_model->getNBCOLONNES()); i++)
{
for(int j=0; j < (_model->getNBLIGNES()); j++)
{
if(((click.getPosX() > (i * size_case_x)) && (click.getPosX() < ((i * size_case_x) + size_case_x))) // on a trouve la case 
&& ((click.getPosY() > (j * size_case_y)) && (click.getPosY() < ((j * size_case_y) + size_case_y)))) //où le clique s'est produit	
{
if(ajout) // on veut ajouter une cellule
{
_matrice_cellules_T[i][j] = true;
}
else // on veut supprimer une cellule car on ne veut pas en ajouter une (!ajout)
{
_matrice_cellules_T[i][j] = false;	
}
i = _model->getNBCOLONNES(); // on a trouve la case et mis a jour la matrice donc on sort
j = _model->getNBLIGNES();
}
}
}
}


Position.h 

#ifndef _POSITION_
#define _POSITION_

#include <SFML/System.hpp>

class Position{

 private:
  float _pos_x, _pos_y;

 public:

  Position();
  ~Position();

  int getPosX();
  int getPosY();  
  void setPosX(float _x);
  void setPosY(float _y);
    
};
#endif


Position.cc 

#include "Position.h"

using namespace std;

/****************************************
Constructeur
****************************************/
Position::Position()
{	
_pos_x = 0;
_pos_y = 0;
}

/****************************************
Destructeur
****************************************/  
Position::~Position()
{
}

/****************************************
     Accesseurs en ecriture
****************************************/

int Position::getPosX()
{
return _pos_x;
}

int Position::getPosY()
{
return _pos_y;
}

/****************************************
     Accesseurs en ecriture
****************************************/

void Position::setPosX(float _x)
{
_pos_x = _x;
}

void Position::setPosY(float _y)
{
_pos_y = _y;
}


main.cc 

#include "ArchiVue.h"
#include "ArchiModel.h"
const int SCREEN_WIDTH = 800;
const int SCREEN_HEIGHT = 600;

using namespace std;

int main(){
  srand(time(NULL));

  bool affiche_onglet_cell = true;
  
  ArchiModel * model = new ArchiModel(SCREEN_WIDTH, SCREEN_HEIGHT);
  ArchiVue * view = new ArchiVue(SCREEN_WIDTH, SCREEN_HEIGHT);
  view->setModel(model);
  
  while(view->treatEvents(affiche_onglet_cell))
  {
    model->nextStep();
    view->draw(affiche_onglet_cell);
  }
  delete view;
  delete model;
  
  return EXIT_SUCCESS;
}




Merci à tous pour votre extreme patience, et pour vos reponse qui je le sais seront pertinentes !!!

22 réponses

  • 1
  • 2
Réponse 1 / 22
cs_patatalo Messages postés 1466 Date d'inscription vendredi 2 janvier 2004 Statut Modérateur Dernière intervention 14 février 2014 2
20 avril 2011 à 23:27
salut,

Le constructeur que tu utilises pour ArchiModel n'initialise pas _nb_colones et _nb_lignes. Si il sont initialisés à 0, tu obtiens une division par 0.

@++
3
Réponse 2 / 22
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
21 avril 2011 à 11:38
@patatalo: Ce n'est pas le soucis, mais le code n'est pas consistent, ce qui t'a trompé (et moi aussi au début).

@tiouil: Initialise tout de la même manière. Dès que tu peux utiliser la liste d'initialisation, utilise là !

Ex: 

ArchiModel::ArchiModel() : _w(800), _h(600)
{
// Du code
_nb_lignes = 4;
_nb_colonnes = 4;
}


Devrait être: 
ArchiModel::ArchiModel()
 : _w(800), _h(600), _nb_lignes(4), _nb_colonnes(4)
{
// Du code
}


________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
3
Réponse 3 / 22
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
21 avril 2011 à 15:23
> mais pourquoi ?

Tu ne l'initialise jamais, c'est tout.

Tu instancies un objet "ArchiVue" qui est censé posséder un pointeur sur un ObjetModel (_model). Comme tu n'affectes rien à _model, ça plante.
Qu'est censé valoir _model ?
Tu intialises un model dans ton main. Soit tu l'initialise dans ton ArchiVue, soit tu passes le pointeurs de ton model créée dans ton main, vers la vue.

Mais tu ne laisses pas _model non initialisé.

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
3
Réponse 4 / 22
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
21 avril 2011 à 18:09
Double inélégance.
1) Pas de besoin de else if. Si tu n'as que deux choix, c'est soit l'un soit l'autre. Un else tout seul suffit.
2) Quand tu as un booléen et que tu affectes un booléen, c'est qu'il y a un potentiellement un souci d'élégance. Au lieu de tester la valeur, insère là. 
void Cellule::ajoutOuSuppCellule(int i, int j, bool ajout)
{
if(ajout) // on veut ajouter une cellule
{
_matrice_cellules_T[i][j] = true;
}
else if(!ajout) // on veut supprimer une cellule car on ne veut pas en ajouter une (!ajout)
{
_matrice_cellules_T[i][j] = false;	
}
}


Devient: 
void Cellule::ajoutOuSuppCellule(int i, int j, bool ajout)
{
  _matrice_cellules_T[i][j] = ajout;
}



C'est le cas classique du: 
if (true == true)
  a = true;
else
 a = false;
// au lieu de
a = true;


________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
3

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
20 avril 2011 à 20:33
J'ai oublié de precisé, je programme sous linux en c++, et l'erreur de segmentation et sur le return _nb_colonnes.

Mais je sais que si je les inverses il y en a aussi un sur return _nb_lignes (toujours dans le model) et il me semble que parfois aussi dans le return _matrice_cellules_T de cellule.cc
0
Réponse 6 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
20 avril 2011 à 23:45
Encore une fois merci pour ta réponse mais je ne vois pas pourquoi tu dis cela car pourtant je le fait dans ArchiModel.cc :


ArchiModel::ArchiModel() : _w(800), _h(600)
{
_nb_lignes = 4;
_nb_colonnes = 4;
}





Cyril Z.
0
Réponse 7 / 22
cs_patatalo Messages postés 1466 Date d'inscription vendredi 2 janvier 2004 Statut Modérateur Dernière intervention 14 février 2014 2
21 avril 2011 à 11:16
re,

Désolé mais moi je vois:
ArchiModel * model = new ArchiModel(SCREEN_WIDTH, SCREEN_HEIGHT);

@++
0
Réponse 8 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
21 avril 2011 à 11:30
HEHE, moi je vois les 2. Peux-tu être plus précis stp.


Cyril Z.
0
Réponse 9 / 22
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
21 avril 2011 à 11:34
Évite les "using namespace", voir: http://0217021.free.fr/portfolio/axel.berardino/articles/bon-usage-using-namespace

Pour la prochaine fois, merci de poster un code qui compile vraiment !
(Et de dégager tous ce qui concerne sfml, vu que je ne l'ai pas, j'ai galéré à faire une fausse classe à partir des messages d'erreurs de compil...) 

#ifndef FAKE_HH_
# define FAKE_HH_

namespace sf
{
  struct Font
  {
    void LoadFromFile(const std::string&) {}
  };

  struct Image
  {
    bool LoadFromFile(const std::string&) {}
  };

  struct Sprite
  {
    Sprite() {}
    Sprite(const Image&) {}
    void Resize(float, float) {}
    void SetPosition(float, double) {}
  };

  struct Color
  {
    Color(int, int, int) {}
  };

  struct Style
  {
    static void Resize(float, float) {}
  };

  struct VideoMode
  {
    VideoMode(int, int, int) {}
  };

  struct String
  {
    void SetText(const std::string&) {}
    void SetFont(const Font&) {}
    void SetSize(const int&) {}
    void SetColor(const Color&) {}
    void SetPosition(float, double) {}
  };

  struct Event
  {
    int Type() {}
    int Key() {}
    bool Closed() {}
    int KeyPressed() {}
  };

  struct Input
  {
    int GetMouseX() {}
    int GetMouseY() {}
    int MouseButton() {}
  };

  struct RenderWindow
  {
    RenderWindow(const VideoMode&, const char*, void (&)(float, float)) {}
    void Draw(const String&) {}
    void Draw(const Sprite&) {}
    int GetWidth() const {}
    int GetHeight() const {}
    void Display() const {}
    bool IsOpened() const { return true; }
    bool GetEvent(Event&) {}
    Input GetInput() {}
    void Close() {}
  };
}

#endif /* !FAKE_HH_ */


Avec cette fausse classe, j'ai pu compiler et passer un coup de gdb (il faut apprendre à s'en servir), qui m'a dit:


gdb ./a.out
Reading symbols from /tmp/soso/a.out...done.
gdb$ r

Program received signal SIGSEGV, Segmentation fault.
0x0000000000400ee8 in ArchiModel::getNBCOLONNES (this=0x0) at ArchiModel.cc:39
39 return _nb_colonnes;
gdb$ bt
#0 0x0000000000400ee8 in ArchiModel::getNBCOLONNES (this=0x0) at ArchiModel.cc:39
#1 0x00000000004043fe in ArchiVue::majTaille (this=0x60d030) at ArchiVue.cc:296
#2 0x0000000000401381 in ArchiVue::ArchiVue (this=0x60d030, w=0x320, h=0x258) at ArchiVue.cc:20
#3 0x0000000000409a38 in main () at main.cc:15


Ici, on voit que "ArchiModel::getNBCOLONNES (this=0x0)". Comme this == 0, ça veut dire que tu fais 0->getNBCOLONNES, et donc ça plante.

_model n'est pas initialisé, tout simplement.

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
Réponse 10 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
21 avril 2011 à 11:53
Lu, desolé pour les namespace mais je n'ai pas changé, je ne sais toujours pas quelle fonction fait partie de std donc.....

Sinon si je fait juste ca

ArchiModel::ArchiModel()
: _w(800), _h(600), _nb_lignes(4), _nb_colonnes(4)
{
// Du code
}


ca marche ???

Du code, du code, mais la j'en ai pas besoin vu que je fait des redirections.
Comment l'initialisé comme vous dite, du moins qu'est ce que je n'est pas initialisé ?

Merci a vous deux, toujours present je vois ^^.

ps : j'etais en train d'ameliorer mon code car comme vous avez pu le voir j'ai des _size_w, _size_h, apres je rappelle autre chose pour la position, c'etait le zouk, donc je me suis arrange ma classe position et j'ai fait une classe objet comme ca moins de variables et code plus clair. Je pense finir dans l'aprem car revoir tout mon code c'est long.... je vous tiens au courant pour le debuggage, si vous m'avez un peu plus eclairé

Cyril Z.
0
Réponse 11 / 22
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
21 avril 2011 à 12:05
// Du code

C'est une généralité pour illustrer le problème. J'ai bien vu que tu n'avais pas de code.

Toujours utiliser la liste d'initialisation c'est important. Ce n'est pas tout à fait pareil que d'initialiser une variable dans le constructeur.

Ex.

Soit la classe: 
class Toto
{
public:
  Toto(int i);
private:
  const int _i;
};



Toto::Toto(int i)
{
  i_ = i; // Ne compilera pas
}



Toto::Toto(int i)
 : i_(i) // Aucun souci
{
}


Utile pour des attributs const, ou des références.

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
Réponse 12 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
21 avril 2011 à 12:19
ok, donc pour repondre a ma question si j'initialise _nb_colonnes et _nb_lignes comme ca va fonctionner directement ?


ArchiModel::ArchiModel()
: _w(800), _h(600), _nb_lignes(4), _nb_colonnes(4)
{

}



ps : chez moi la compilation marchait mais comme ici j'ai supprimé des choses, j'ai du appuyer comme un fou sur la touche des temps en temps et donc -> bug


Cyril Z.
0
Réponse 13 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
21 avril 2011 à 15:18
Alors, j'ai donc finit mon remue menage avec le transfert de la classe Position en classe Objet qui a donc une position en x et y et une taille w et h.

Je viens de comprendre ce que patalo m'a dit


moi je vois "ArchiModel * model = new ArchiModel(SCREEN_WIDTH, SCREEN_HEIGHT);"


je l'ai remplace par
"ArchiModel * model = new ArchiModel(SCREEN_WIDTH, SCREEN_HEIGHT, 4, 4);"

et donc dans archiModel.cc il y a maintenant ca (apres avoir suivi les conseils de cptPingu ) 

#include <vector>
#include 
#include <cstdlib>
#include "ArchiModel.h"
#include "Cellule.h"

using namespace std;

/****************************************
 			Constructeur
****************************************/
ArchiModel::ArchiModel() : _w(800), _h(600), _nb_lignes(4), _nb_colonnes(4)
{
_cellule = new Cellule();
}

ArchiModel::ArchiModel(int w, int h, int nb_lignes, int nb_colonnes) :  _w(w), _h(h), _nb_lignes(nb_lignes), _nb_colonnes(nb_colonnes)
{

}

/****************************************
 			Destructeur
****************************************/

ArchiModel::~ArchiModel()
{
if(_cellule != 0)
delete _cellule;
}

/****************************************
 		Accesseurs en lecture
****************************************/

int ArchiModel::getNBCOLONNES()
{
return _nb_colonnes;
} 

int ArchiModel::getNBLIGNES()
{
return _nb_lignes;
}

/****************************************
 		Accesseurs en ecriture
****************************************/

void ArchiModel::setNBLIGNES(int nb)
{
_nb_lignes = nb;
}

void ArchiModel::setNBCOLONNES(int nb)
{
_nb_colonnes = nb;
}

/****************************************
 			Prochaine etape
****************************************/
void ArchiModel::nextStep(){
//on prepare la matrice future T+1
}


Mais, cela ne fonctionn toujours pas.
J'ai bien vu depuis longtemps que ce venait du model qui n'etait pas initialisé (car d'apres gdb


Program received signal SIGSEGV, Segmentation fault.
0x0000000000402844 in ArchiModel::getNBCOLONNES (this=0x0) at ArchiModel.cc:38
38 return _nb_colonnes;


-> mais pourquoi ?

Cyril Z.
0
Réponse 14 / 22
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
21 avril 2011 à 15:36
Voilà comment j'écrirais la classe ArchiModel: 
#ifndef _ARCHI_MODEL_
# define _ARCHI_MODEL_

# include "Cellule.hh"

class ArchiModel
{
public:
  ArchiModel();
  ArchiModel(int width, int height,
     int nbRow, int nbCol);
  ~ArchiModel();

  int getNbRow() const;
  void setNbRow(int nb);

  int getNbColumn() const;
  void setNbColumn(int nb);

  void nextStep();
private:
  int _width;
  int _height;
  int _nb_row;
  int _nb_col;
  Cellule _cell;
};
#endif /* !_ARCHI_MODEL_ */



#include "ArchiModel.hh"

ArchiModel::ArchiModel()
  : _width(800), _h(600),
    _nb_row(4), _nb_col(4)
{
}

ArchiModel::ArchiModel(int width, int height,
       int nbRow, int nbCol)
  :  _width(width), _height(height),
     _nb_row(nbRow), _nb_col(nbCol)
{
}

ArchiModel::~ArchiModel()
{
}

int getNbRow() const
{
  return _nb_col;
}

void setNbRow(int nb)
{
  _nb_row = nb;
}

int getNbColumn() const;
{
  return _nb_row;
}

void setNbColumn(int nb);
{
  _nb_col = nb;
}

void ArchiModel::nextStep()
{
  //on prepare la matrice future T+1
}


________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
Réponse 15 / 22
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
21 avril 2011 à 15:40
Ensuite pour ton souci: 
ArchiModel * model = new ArchiModel(SCREEN_WIDTH, SCREEN_HEIGHT);
ArchiVue * view = new ArchiVue(SCREEN_WIDTH, SCREEN_HEIGHT);
view->setModel(model);

Ton setModel est fait trop tard. Puisque dans le constructeur de ArchiVue, tu te sers de _model.

A ta place je ferais carrément un: 
new ArchiVue(model, SCREEN_WIDTH, SCREEN_HEIGHT, 4, 4);


A noter que dans ton main, je remplacerais: 
  ArchiModel * model = new ArchiModel(SCREEN_WIDTH, SCREEN_HEIGHT);
  ArchiVue * view = new ArchiVue(SCREEN_WIDTH, SCREEN_HEIGHT);
  view->setModel(model);

  while(view->treatEvents(affiche_onglet_cell))
  {
    model->nextStep();
    view->draw(affiche_onglet_cell);
  }
  delete view;
  delete model;


Par 

  ArchiModel model(SCREEN_WIDTH, SCREEN_HEIGHT);
  ArchiVue view(SCREEN_WIDTH, SCREEN_HEIGHT); // Je n'ai pas pris en compte le fait de donner le model dans le constructeur
  view.setModel(&model);

  while(view.treatEvents(affiche_onglet_cell))
  {
    model.nextStep();
    view.draw(affiche_onglet_cell);
  }


________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
Réponse 16 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
21 avril 2011 à 17:41
@cptPingu: ou mais bon ca c'est aussi un code de prof (toujours les memes XD) et la par contre si on ne s'en sert pas il peuvent penser que nous n'avons pas fait des jeux precedemment demandés mais en facultatifs. Donc je ne prefere pas meme si je suis sûr (et meme certain) que ton truc marche.

Sinon vous aviez raison, les pointeurs n'etaient pas initialisés (_model, _cellule).

Par contre cela m'a revelé une nouvelle erreur et j'ai beau avoir recours a deux procédés differents, toujours la meme segfault : voici ce que dit gdb :


Program received signal SIGSEGV, Segmentation fault.
0x000000000041d0b9 in std::vector >::operator[] (
this=0xaacc130, __n=0) at /usr/include/c++/4.4/bits/stl_bvector.h:682
682 + __n / int(_S_word_bit), __n % int(_S_word_bit));
(gdb) where
#0 0x000000000041d0b9 in std::vector >::operator[]
(this=0xaacc130, __n=0) at /usr/include/c++/4.4/bits/stl_bvector.h:682
#1 0x000000000041c8d0 in Cellule::ajoutOuSuppCellule (this=0x981ac0,
i=4203856, j=0, ajout=false) at Cellule.cc:55
#2 0x0000000000419944 in ArchiVue::treatEvents (this=0x938cf0,
passerIntro=@0x7fffffffe18f) at ArchiVue.cc:1086
#3 0x000000000041ebce in main () at main.cc:17


et voici les fichiers ou lignes concernées :

Cellule.cc 
#include <vector>
#include "Cellule.h"
#include "ArchiModel.h"
#include 
#include <cstdlib>

using namespace std;

Cellule::Cellule(int w, int h) : _w(w), _h(h)
{
_model = new ArchiModel(_w, _h, 4, 4);

_matrice_cellules_T.resize(_model->getNBLIGNES(), vector(_model->getNBCOLONNES(), false)); // initialisation matrice 2D à faux
//_matrice_cellules_T_1.resize(_vue->getNBLIGNES(), vector(_vue->getNBCOLONNES(), false));
_nb_voisins = 0 ;
_max_nb_voisins = 0;
_min_nb_voisins = 8;

}

Cellule::~Cellule()
{
  if(_model != 0)	
delete _model;
}

vector<vector > Cellule::getMATRICECELLT() const
{
return _matrice_cellules_T;
}

 //ou

bool Cellule::getValeurMatrice(int i, int j)
{
return _matrice_cellules_T[i][j];
}

void Cellule::ajoutOuSuppCellule(int i, int j, bool ajout)
{
if(ajout) // on veut ajouter une cellule
{
_matrice_cellules_T[i][j] = true;
}
else if(!ajout) // on veut supprimer une cellule car on ne veut pas en ajouter une (!ajout)
{
_matrice_cellules_T[i][j] = false;	
}
}


ArchiVue.cc 

void ArchiVue::draw(bool &passerIntro)
{   
    _window->Draw(_background_sprite); //Image de fond du jeu
    
    dessineMatrice();

    _window->Display();
    usleep(500);
}

/******************************************************
   Dessin de la matrice
******************************************************/

void ArchiVue::dessineMatrice()
{	
// taille d'une cellule adaptée au nombre de L et Col
_new_cell_sprite.Resize(_new_cell.getSizeW(), _new_cell.getSizeH());

vector<vector > _matrice_cellules_T;	
//_matrice_cellules_T.resize(_model->getNBLIGNES(), vector(_model->getNBCOLONNES(), false));
//_matrice_cellules_T = (_cellule->getMATRICECELLT());

for(int i=0; i < _model->getNBCOLONNES(); i++)
{
for(int j=0; j < _model->getNBLIGNES(); j++)
{
if(_cellule->getValeurMatrice(i, j)) //_matrice_cellules_T[i][j]) // on affiche la matrice actuelle 
{
_new_cell.setPosX((i * _case.getSizeW()) + _menu_global.getSizeW() + 1);
_new_cell.setPosY((j * _case.getSizeH()) + _menu_recap.getSizeH() + 1);
_new_cell_sprite.SetPosition(_new_cell.getPosX(), _new_cell.getPosY());
_window->Draw(_new_cell_sprite);
}
}

}
}


et pour le modele il n'a pas changé, je vous le remet

ArchiModel.cc 

ArchiModel::ArchiModel() : _w(800), _h(600), _nb_lignes(4), _nb_colonnes(4)
{
_cellule = new Cellule(_w, _h);
}

ArchiModel::ArchiModel(int w, int h, int nb_lignes, int nb_colonnes) :  _w(w), _h(h), _nb_lignes(nb_lignes), _nb_colonnes(nb_colonnes)
{

}

/****************************************
 			Destructeur
****************************************/

ArchiModel::~ArchiModel()
{
if(_cellule != 0)
delete _cellule;
}

/****************************************
 		Accesseurs en lecture
****************************************/

int ArchiModel::getNBCOLONNES()
{
return _nb_colonnes;
} 

int ArchiModel::getNBLIGNES()
{
return _nb_lignes;
}

/****************************************
 		Accesseurs en ecriture
****************************************/

void ArchiModel::setNBLIGNES(int nb)
{
_nb_lignes = nb;
}

void ArchiModel::setNBCOLONNES(int nb)
{
_nb_colonnes = nb;
}

/****************************************
 			Prochaine etape
****************************************/
void ArchiModel::nextStep(){
//on prepare la matrice future T+1
}


ainsi que le main 

#include "ArchiVue.h"
#include "ArchiModel.h"
const int SCREEN_WIDTH = 800;
const int SCREEN_HEIGHT = 600;

using namespace std;

int main(){
  srand(time(NULL));

  bool passerIntro = false;
  
  ArchiModel * model = new ArchiModel(SCREEN_WIDTH, SCREEN_HEIGHT, 4, 4);
  ArchiVue * view = new ArchiVue(SCREEN_WIDTH, SCREEN_HEIGHT);
  view->setModel(model);
  
  while(view->treatEvents(passerIntro))
  {
if(passerIntro) //evite donc le chargement de notre intro "Century fox" quand le jeu à commencé
model->nextStep();
    view->draw(passerIntro);
  }
  delete view;
  delete model;
  
  return EXIT_SUCCESS;
}


Voila, comme c'est le meme projet que tout à l'heure et que c'est toujours une erreur de segmentation, je n'ai pas changé de sujet.

De plus la tout mes pointerus sont initialisés (enfin normalement) et par contre le segfault n'a pas de "this(0x0)" donc je ne comprend pas .

Encroe et encore merci à vous deux.

Cyril Z.
0
Réponse 17 / 22
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
21 avril 2011 à 17:59
ou mais bon ca c'est aussi un code de prof

Oo, sérieusement ?!! Je ne dirais rien... Je vais rester constructif et répondre à ta question.

Comment lire ceci:

0x000000000041d0b9 in std::vector >::operator[] (
this=0xaacc130, __n=0) at /usr/include/c++/4.4/bits/stl_bvector.h:682
682 + __n / int(_S_word_bit), __n % int(_S_word_bit));


Ici on voit que tu as un tableau et que tu accèdes à sa première case (__n=0 => [0]).
Le calcul "__n / int(_S_word_bit), __n % int(_S_word_bit))" ne sert qu'à calculer l'indice ou récupérer ton élément.
Or, la taille doit être de 0 (je ne te vois pas la mettre à jour), donc tu es hors borne, et ça plante.
Avec quoi as-tu initalisé ton tableau :) ?

2 solutions:
- Faire un .push_back pour ajouter un élément en fin de tableau
- Faire un .resize préalable, qui te permet de créer par avance toutes les cases, et donc d'y accéder.

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
0
Réponse 18 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
21 avril 2011 à 20:15
En effet, j'avais pas vu, et c'est tres moche ce que j'ai fais.

On peut dire que je suis vraiment un pinguoin en programmation XD.

Par contre, je fait bien l'initialisation de la matrice mais en regardant mes messages, je voit que la fin de la ligne a saute, je le remet ici sur 2 lignes donc. (constructeur de cellule.cc) 

Cellule::Cellule(int w, int h) : _w(w), _h(h)
{
_model = new ArchiModel(_w, _h, 4, 4);

_matrice_cellules_T.resize
(_model->getNBLIGNES(), vector(_model->getNBCOLONNES(), false));

//_matrice_cellules_T_1.resize(_vue->getNBLIGNES(), vector(_vue->getNBCOLONNES(), false));
_nb_voisins = 0 ;
_max_nb_voisins = 0;
_min_nb_voisins = 8;

}


Cyril Z.
0
Réponse 19 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
21 avril 2011 à 20:27
Une autre question, si l'utilisateur modifie via l'interface la taille du vecteur, puis-je faire un resize sur la matrice deja existente ou il faut que je fasse un push.back sur la derniere colonne ou derniere ligne ou encore autre chose.

Merci mon petit cptPingu
0
Réponse 20 / 22
cs_tiouil Messages postés 51 Date d'inscription dimanche 8 août 2010 Statut Membre Dernière intervention 2 mars 2018
23 avril 2011 à 12:02
Personne ?
HELP !!!
J'y arrive pas, je fait bien l'initialisation non ?


_matrice_cellules_T.resize
(_model->getNBLIGNES(), vector(_model->getNBCOLONNES(), false));


Cyril Z.
0

Discussions similaires

question basique ^^ : création de fonction. Comment écrire le retour?
Skooma -
Skooma -

2 réponses
convertir STRING en INT
76julien -
chicfrandy -

15 réponses
Que veut dire "int"
cnovice -
BruNews -

11 réponses
convertion int vers char ou string.
KillerHunter -
DxShadow -

7 réponses
Convertir du string en int[]
Smookii -
izords -

10 réponses
Rejoignez-nous