src/ReachableCell.cpp

Go to the documentation of this file.

/*
This file is part of Teapot Colony Wars.

Teapot Colony Wars is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.

Teapot Colony Wars is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Teapot Colony Wars.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "ReachableCell.h"

#include <GL/glut.h>

#include "Constants.h"
#include "Worshiper.h"

ReachableCell::ReachableCell() : _next(NULL) {
  _people = new std::list<Worshiper *>;
  _pheromones = new std::map<Pheromone*, unsigned int>;
}

ReachableCell::~ReachableCell() {
  delete _people;
  delete _pheromones;
}

void ReachableCell::draw() {
  std::list<Worshiper *>::iterator i, end = _people->end();
  // affichage des Worshipers sous forme de cercle : calcul de l'angle entre eux
  GLfloat angle = 360.0 / (GLfloat) _people->size();
  // translatation à effectuer pour dessiner un Worshiper
  GLfloat translate = CELL_SIZE / -3.0;

  // on passe en mode dessin
  glMatrixMode(GL_MODELVIEW);

  // on dessine la cellule
  Cell::draw();

  glPushMatrix();
  // pour chaque Worshiper on se place à l'endroit ou on veut le dessiner
  // et on appelle sa méthode de dessin
  for(i = _people->begin(); i != end; ++i) {
    glPushMatrix();
    glTranslatef(translate, 0.0, 0.0);
    (*i)->draw();
    glPopMatrix();
    glRotatef(angle, 0.0, 1.0, 0.0);
  }
  glPopMatrix();
}

bool ReachableCell::reachable(Worshiper *w) {
  return (_people->size() < MAX_WORSHIPER_PER_CELL) &&
    (_next != NULL ? _next->reachable(w) : true);
}

std::list<Worshiper*>* ReachableCell::getPeople() {
  return _people;
}

std::map<Pheromone*, unsigned int>* ReachableCell::getPheromones() {
  return _pheromones;
}

bool ReachableCell::addWorshiper(Worshiper *w) {
  bool ok = reachable(w);

  if(ok) {
    _people->push_back(w);
  }

  return ok;
}

bool ReachableCell::removeWorshiper(const Worshiper *w) {
  std::list<Worshiper *>::iterator it, end = _people->end();
  bool find = false;

  for(it = _people->begin(); !find && it != end; ++it) {
    if(find = ((*it) == w)) {
      _people->erase(it);
    }
  }

  return find;
}

void ReachableCell::addPheromone(Pheromone *p) {
  (*_pheromones)[p] = PHEROMONE_LIFE_TIME;
}

void ReachableCell::push(ReachableCell *next) {
  _next = next;
  _people = _next->_people;
  _pheromones = _next->_pheromones;
}

ReachableCell* ReachableCell::pop() {
  ReachableCell *next = NULL;

  if(_next != NULL) {
    // petite astuce : pour éviter que le destructeur de cette Cell détruise
    // la Cell en dessous ainsi que les pointeurs qu'elle partage avec elle,
    // on les positionnent à NULL
    _people = NULL;
    _pheromones = NULL;
    next = _next;
    _next = NULL;
  }
  // puis on s'auto-détruit
  delete this;

  // et on retourne la Cell qui était précédement en dessous
  return next;
}

Cell* ReachableCell::makeActions() {
  std::map<Pheromone*, unsigned int>::iterator it, end;

  // on met à jour les phéromones en fonction de leur durée de vie
  end = _pheromones->end();
  for(it = _pheromones->begin(); it != end; ++it) {
    if(it->second <= 1) {
      // on supprime la phéromone
      _pheromones->erase(it);
    } else {
      // sinon on la décrémente
      it->second--;
    }
  }

  return this;
}

---