foret.h

#ifndef FORET_H
#define FORET_H

#include <vector>
#include <list>
#include <iostream>
#include <fstream>
// Pour l'aléatoire
#include <cstdlib>
#include <ctime>

#include "../debug.h"
#include "cellulevide.h"
#include "essence.h"
#include "arbre.h"
#include "vent.h"
#include "loadprogress.h"

#define MAXI 1000 

class Foret
{
private:
    int lignes;
    int colonnes;

    // altère la progression du feu, il lui faut plus de tours pour progresser
    //   si la valeur est faible peut affecter la précision des mesures)
    float burningCoef;
    
    std::time_t randomSeed;
    
    Vent* wind;
    std::vector< Essence > essences;
    std::vector<std::vector< Cellule* > > matrix;
    
    std::list< Arbre* > onFire;
    std::list< Arbre* > uprooted;
    std::list< Arbre* > delayed;
    std::list< Arbre* > delayBurned;
    std::list< Arbre* > burned;
    std::list< Arbre* > carbonized;
    
// METHODES
public:
// Constructeur et destructeur
    Foret(int _largeur, int _hauteur, float proba = 0.60, float _coefFeu = 0.5, std::time_t graine=std::time(0));
//  Foret(int _largeur, int _hauteur, std::time_t graine, float proba = 0.60, float _coefFeu = 0.5);
//  Foret(Foret& other, float proba=0.60);
    Foret(int _largeur, int _hauteur, std::ifstream* file, LoadProgress* PB);
    Foret(int _largeur, int _hauteur, std::vector< std::vector< int > >* matrice, float coef_brulure);
    virtual ~Foret();
    
    void initEmpty();
    
private:
    std::vector< std::string >& explode(const std::string& str);
    unsigned essenceRandom(int col, int row, unsigned int distOthers);
    
public:
// Setters
    void setValues(int largeur, int hauteur, float coef);
    void setWind(int angle, int vitesse);
    
/* Getters */
    int width() const { return colonnes; }
    int height()    const { return lignes; }
    int nbEssences(){ return essences.size() ; }
    const Vent* getVent() const { return wind; }
    std::vector< Cellule* >* operator[](int ligne) { return &(matrix[ligne]); }
    
// Initialisations
    bool tryLoadEssences(const std::string& fileName);
    
    void create(int largeur, int hauteur, std::vector< std::vector< int > >* matrice);
    void randomMatrix(float probabilite);
    
    void clean();
    
    const std::list< Arbre* >* getOnFire() const    { return &onFire; }
    std::list< Arbre* >* getUprooted()      { return &uprooted; }
    std::list< Arbre* >* getDelayed()       { return &delayed; }
    std::list< Arbre* >* getDelayBurned()   { return &delayBurned; }
    std::list< Arbre* >* getCarbonized()    { return &carbonized; }
    std::list< Arbre* >* getBurned()            { return &burned; }
    std::list< std::list< Arbre* > >* getChanged();
    
    // Vidage des listes
    void clearUprooted()    { uprooted.clear(); }
    void clearDelayed() { delayed.clear(); }
    void clearDelayBurned() { delayBurned.clear(); }
    void clearCarbonized()  { carbonized.clear(); }
    void clearBurned()  { burned.clear(); }
    void clearChanged();
    
    
    // Manipulations d'arbre
    void plantTree(int col, int row);
    void plantTree(int col, int row, unsigned int numEss, int PdV, float humidite, float coef, int etat);
    
    void uproot(Arbre* ab);
    void uproot(int col, int row);
    
    void delay(Arbre* ab, float coef=0.5);
    
    void kindle(Arbre* ab);
    void kindle(int col, int row);
    
    void blast(Arbre* ab);
    //  void eteindre(int row, int col);
    
    void spark(Arbre* ab, int intensite);
    void spark(int col, int row, int intensite);

    
// Autres méthodes
    void cut(int xDep, int yDep, int xArr, int yArr);
    void delay(int xDep, int yDep, int xArr, int yArr);
    std::list< Arbre* > adjacents(int col, int row, int distance) const;
    std::list< Arbre* > adjacents(const Arbre * ab, int distance) const;
    
    
    void sparkAdjacentsWind(int posCol, int posRow, int hor, int vert);
    void sparkAdjacentsWind(Arbre* a, const Vent* vent);
    
//  Avancee du temps
    // voir transition avec d'autres parametres
    void transition(Arbre* ab);
    void transitionWind(Arbre* a, const Vent* vent);
    
    bool NextMove();
    
    
// Persistance des donnees
    void loadSizes(std::ifstream* file);
    void loadBurningCoef(std::ifstream* file);
    void loadEssences(std::ifstream* file);
    void loadMatrix(std::ifstream* file, LoadProgress* progress);
    bool tryLoad(std::ifstream* file, LoadProgress* progress);
    
    void saveProperties(std::ofstream* file);
    void saveEssences(std::ofstream* file);
    void saveMatrix(std::ofstream* file);
    bool trySave(std::string filePath = "save_forest");
    
    bool trySaveSeed(std::string filePath = "save_forest");
    
// Affichage attributs
    void showEssences() const;
};

#endif // FORET_H