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 !!!
Afficher la suite
