Ecosysteme/univers.cpp

#include "univers.hpp"

// -------- Univers --------

Univers::Univers(int m, int n): _m(m), _n(n), _tailleUnivers(m * n), _tour(0), _nbAnimaux(0) {
    _plateau = new int[_tailleUnivers];

    // Remplie toutes les valeurs du tableau avec l'ID de l'herbe
    Herbe herbe;
    std::fill_n(_plateau, _tailleUnivers, herbe.id());

    // On ajoute tous les index possibles
    for(int i = 0; i < _tailleUnivers; i++)
        indexLibres.push_back(i);

    // On mélange notre vecteur
    std::random_device nombreAleatoire;
    std::default_random_engine graine(nombreAleatoire());
    std::shuffle(indexLibres.begin(), indexLibres.end(), graine);
    //std::random_shuffle(indexLibres.begin(), indexLibres.end()); // random pas vraiment random pour les tests

    // On en retire quelque un pour évité de saturé notre univers
    while(indexLibres.size() > (uint64_t)_tailleUnivers - _tailleUnivers / 4)
        indexLibres.pop_back();
}

Univers::~Univers(void) {
    delete[] _plateau;
}

void Univers::ajoutAnimaux(std::vector<Animal*> animaux) {
    if(animaux.size() > indexLibres.size())
        throw std::domain_error("Trop d'organismes pour l'univers.");

    while(!animaux.empty()) {
        _plateau[indexLibres.back()] = animaux.back()->id(); // on place notre animal
        animaux.pop_back(); // on retire l'animal du vecteur
        _nbAnimaux++; // incrémente le nombre d'animaux
        indexLibres.pop_back(); // on retire l'index du vecteur
    }
}

void Univers::modificationOrganisme(Organisme * organisme, int index) {
    if(index > _tailleUnivers)
        throw std::range_error("Impossible de placer un organisme à l'index spécifié.");

    _plateau[index] = organisme->id(); // on place notre organisme

    std::cout << "indexLibres.size() -> " << indexLibres.size() << std::endl;
    std::cout << "----------------------" << std::endl;

    auto it = std::find(indexLibres.begin(), indexLibres.end(), index);
    if(it == indexLibres.end()) { // si index non libre (pas présent dans le vecteur)
        if(organisme->id() <= 0) // si c'est non vivant
            indexLibres.push_back(index); // on le rajoute
    } else { // si index libre (présent dans le vecteur)
        if(organisme->id() > 0) { // si c'est vivant
            _nbAnimaux++; // incrémente le nombre d'animaux
            indexLibres.erase(it); // on le retire
        }
    }

    std::cout << "indexLibres.size() -> " << indexLibres.size() << std::endl;
    std::cout << "----------------------" << std::endl;
}

void Univers::affichage(void) const noexcept {
    for(int i = 0; i < _n * 4; i++)
        if(i == 0)
            std::cout << "┌";
        else
            std::cout << "─";
    std::cout << "┐" << std::endl;

    std::cout << "│ ";
    for(int i = 0; i < _tailleUnivers; i += _n) {
        for(int j = 0; j < _n; j++) {
            std::cout << Organisme::correspondance(_plateau[i + j]);
            if(j == _n - 1)
                std::cout << " │ ";
            else
                std::cout << "   ";
        }
        if(i != _tailleUnivers - _n) std::cout << std::endl << "│ ";
    }

    std::cout << std::endl;
    for(int i = 0; i < _n * 4; i++)
        if(i == 0)
            std::cout << "└";
        else
            std::cout << "─";
    std::cout << "┘"  << std::endl;
}

bool Univers::enVie(void) const noexcept {
    return _nbAnimaux > 0;
}


// -------- Organisme --------

Organisme::Organisme(void) { }

char Organisme::correspondance(int id) {
    return _correspondance[id];
}

// -------- Animal --------

Animal::Animal(void): Organisme() { }

Animal::~Animal(void) { }

// -------- Herbe --------

Herbe::Herbe(void): Organisme() {
    _correspondance[id()] = ' ';
}

short Herbe::id(void) const noexcept {
    return 0;
}


// -------- Sel --------

Sel::Sel(void): Organisme() {
    _correspondance[id()] = 'S';
}

short Sel::id(void) const noexcept {
    return -1;
}


// -------- Mouton --------

Mouton::Mouton(void): Animal() {
    _correspondance[id()] = 'M';
}

Mouton::~Mouton(void) { }

bool Mouton::carnivore(void) const noexcept {
    return false;
}

short Mouton::id(void) const noexcept {
    return 1;
}


// -------- Loup --------

Loup::Loup(void): Animal() {
    _correspondance[id()] = 'L';
}

Loup::~Loup(void) { }

bool Loup::carnivore(void) const noexcept {
    return true;
}

short Loup::id(void) const noexcept {
    return 2;
}