src/World.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 "World.h"

#include <GL/glut.h>
#include <list>
#include <utility>

#include "Constants.h"
#include "Random.h"

#include "WallCell.h"
#include "ColonyCell.h"
#include "EmptyCell.h"
#include "CorridorCell.h"
#include "InfiniteFood.h"
#include "RenewableFood.h"
#include "GodsGiftFood.h"
#include "CorpseFood.h"

#include "NorthMove.h"
#include "SouthMove.h"
#include "EastMove.h"
#include "WestMove.h"
#include "NorthEastMove.h"
#include "NorthWestMove.h"
#include "SouthEastMove.h"
#include "SouthWestMove.h"
#include "NoMove.h"

#include "Colony.h"
#include "Worshiper.h"
#include "VisualContext.h"
#include "UntilVictoryFight.h"
#include "HeuristicReplication.h"
#include "GeneticReplication.h"

void World::addNewWorshipers() {
  std::list<ColonyCell*>::iterator it, begin, end;
  std::list<Worshiper*> *worshipers = NULL;
  Worshiper *w = NULL;

  // on itère sur la liste des colonies
  for(int i = 0; i < _colonies.size(); i++) {
    // on récupère les nouveaux individus créés par chaque colonie
    worshipers = _colonies[i]->getNewWorshipers();
    if(worshipers != NULL) {
      _colonies[i]->getCellIterators(begin, end);
      // tant qu'il y en a qui n'ont pas été placés sur le monde
      while(! worshipers->empty()) {
        for(it = begin; it != end && ! worshipers->empty(); ++it) {
          // on récupère le 1er individu de la liste
          w = worshipers->front();
          if(w != NULL) {
            // on met à jour son contexte de vision
            w->setVisualContext(
              new VisualContext(this, (*it)->getHeight(), (*it)->getWidth()));
            // et on l'ajoutes à une case appartenant à la colonie
            (*it)->addWorshiper(w);
          }
          // il ne reste plus qu'à l'enlever de la liste...
          worshipers->pop_front();
        }
      }
    }
  }
}

void World::addPheromone(Cell *cell, Worshiper *w) {
  std::list<Pheromone*>::iterator it, end;
  std::list<Pheromone*> *pheromones = NULL;

  // on récupère les phéromones a créer par l'individu
  pheromones = w->getPheromones();
  if(pheromones != NULL) {
    end = pheromones->end();
    // et on ajoute chacune des phéromones à la case (mise à jour si nécessaire)
    for(it = pheromones->begin(); it != end; ++it) {
      cell->addPheromone(*it);
    }
  }
}

void World::addCommand(Worshiper *w, unsigned int i, unsigned int j) {
  std::pair<unsigned int, unsigned int> coord;

  // ou doit on aller ?
  coord = _move->getAbsCoords(w->getAction(), i, j);
  // est-ce que l'on se déplace bien, que les coordonées sont valides
  // et que la case atteignable ?
  if((coord.first != i || coord.second != j) &&
      coord.first > 0 && coord.first < _height - 1 &&
      coord.second > 0 && coord.second < _width - 1 &&
      getCell(coord.first, coord.second)->reachable(w)) {
    // si c'est le cas, alors on met en attente une commande de déplacement
    coord_t c =  {coord.first, coord.second, i, j};
    _commandes[w] = c;
  }
}

void World::makeCommand() {
  std::map<Worshiper*, coord_t>::iterator it, end;
  VisualContext *view = NULL;

  // pour chacunes des commandes qui ont été passées
  end = _commandes.end();
  for(it = _commandes.begin(); it != end; ++it) {
    // si on a bien réussit à déplacer le worshiper dans sa nouvelle case
    if(getCell(it->second.i, it->second.j)->addWorshiper(it->first)) {
      // on met à jour la vision du monde de l'individu
      view = it->first->getVisualContext();
      if(view != NULL) {
        view->_i = it->second.i;
        view->_j = it->second.j;
      }
      // et on l'enlève de l'ancienne
      getCell(it->second.old_i, it->second.old_j)->removeWorshiper(it->first);
    }
  }
  // une fois toutes les commandes traitées, on les supprimes.
  _commandes.clear();
}

Cell* World::fight(Cell *cell) {
  ReachableCell *next = NULL;
  ColonyCell *colony = NULL;
  CorpseFood *dead = NULL;
  unsigned int food;

  // on effectue le combat conformément à la stratégie établie
  food = _fightStrategy->resolve(cell);
  // que leurs cadavres nourrissent la terre (et leurs congénères)
  if(food > 0) {
    if(dynamic_cast<CorpseFood*>(cell)) {
      // on est déjà sur une CorpseFood, on ajoute juste de la nouriture.
      cell->addFood(food);
    } else {
      // sinon on en crée une.
      // la case à recouvrir doit être atteignable
      next = dynamic_cast<ReachableCell*>(cell);
      //Une CorpseFood ne doit pas recouvrir une colonie
      if(colony = dynamic_cast<ColonyCell*>(cell)) {
        // on ajoute plutôt la nouriture produite à la colonie
        colony->getColony()->incrementFood(food);
      } else if(next) {
        // création de la CorpseFood
        dead = new CorpseFood(food);
        if(dead != NULL) {
          // on l'empile par dessus l'ancienne case
          dead->push(next);
          // et on s'assure que la case retournée sera bien la nouvelle.
          cell = dead;
        }
      }
    }
  }

  return cell;
}

void World::feed(Cell *cell) {
  std::list<Worshiper*> *worshipers = NULL;
  std::list<Worshiper*>::iterator it, end;
  unsigned int nb_people, ratio;
  unsigned int needed, consumed;
  unsigned int food;
  bool full;

  // qui est sur la case ?
  worshipers = cell->getPeople();
  // combien de nouriture est diponible ?
  food = cell->getFood();
  // si il y a de la nouriture et des worshipers sur la case
  if(food > 0 && worshipers != NULL && (nb_people = worshipers->size()) > 0) {
    // tout le monde n'a pas mangé à sa faim (et pour cause : personne
    // n'a encore mangé quoi que ce soit)
    full = false;
    // tant qu'il reste de la nouriture et que tout le monde n'est pas gavé
    while(food > 0 && ! full) {
      // on part du principe que tu le monde aura eu sa dose, les insatisfaits
      // n'ont qu'a faire une réclamation
      full = true;
      // on partage la nouriture en portion égales
      ratio = (unsigned int) (food / nb_people) + 1;
      // et chaque worshipers reçoit sa part
      end = worshipers->end();
      for(it = worshipers->begin(); food > 0 && it != end; ++it) {
        // on calcule dabord ce dont il a besoin
        needed = (*it)->getCapacity() - (*it)->getFood();
        // on vérifie ensuite si il pourra manger à sa faim
        full = !(full && needed > ratio);
        // on lui attribue sa part
        needed = (needed > ratio ? ratio : needed);
        // on la soustrait de la quantité totale
        consumed = cell->subFood(needed);
        // on met la quantité de nouriture disponible à jour
        food = cell->getFood();
        // et on lui donne ce qui a été réellement soustrait
        (*it)->setFood((*it)->getFood() + consumed);
      }
    }
  }
  // maintenant on décrémente d'une unité la nouriture de chaque individu
  end = worshipers->end();
  for(it = worshipers->begin(); it != end; ++it) {
    if(! (*it)->subFood()) {
      // oups... je crois qu'on est mort de faim. que c'est bête...
      // adieux !
      delete (*it);
      cell->removeWorshiper(*it);
      --it;
    }
  }
}

World::World(unsigned int width, unsigned int height, unsigned int nb_colonies):
    _width(width), _height(height), _colonies(nb_colonies) {
  unsigned int max;
  int i, j, n = 0;

  // TODO Initialisation + propre des colonies
  for(int i = 0; i < nb_colonies; i++){
    _colonies[i] = new Colony(MAX_FOOD_CAPACITY * 30, new GeneticReplication);
  }

  _map = new Cell*[_width * _height];
  for(i = 0; i < _height; i++) {
    for(j = 0; j < _width; j++) {
      if(i == 0 || i == _height - 1 || j == 0 || j == _width - 1) {
        // on s'assure que tous les bords sont bien des murs
        getCell(i, j) = new WallCell;
      } else {
        /*if((i + j) % 8 == 0) {
          getCell(i, j) = new WallCell;
        } else {
          max = MAX_FOOD_CAPACITY + 1;
          getCell(i, j) = new EmptyCell;
        }
        */
        // une case sur deux sera vide par défaut en moyenne
        switch(Random::value() % 10) {
          case 0:
               getCell(i, j) = new ColonyCell(_colonies[n++ % _colonies.size()], i, j);
            break;
          case 1:
            // il doit toujours y avoir au moins un peu de nouriture
            // et le taux de régénération doit être inférieur à la capacité
            max = (Random::value() % MAX_FOOD_CAPACITY) + 1;
            getCell(i, j) = new RenewableFood(max, (Random::value() % max) + 1);
            break;
          case 2:
            // il doit toujours y avoir au moins un peu de nouriture
            getCell(i, j) = new InfiniteFood((Random::value() % MAX_FOOD_CAPACITY) + 1);
            break;
          case 3:
            // attention, un couloir doit toujours rester traversable...
            getCell(i, j) = new CorridorCell((Random::value() % CORRIDOR_SIZE_MAX) + 1);
            break;
          case 4:
            getCell(i, j) = new WallCell;
            break;
          default:
            getCell(i, j) = new EmptyCell;
        }
      }
    }
  }
  delete getCell(7, 7);
  getCell(7, 7) = new ColonyCell(_colonies[0], 7, 7);
  delete getCell(8, 8);
  getCell(8, 8) = new ColonyCell(_colonies[1], 8, 8);

  _fightStrategy = new UntilVictoryFight;

  //Chaîne de responsabilité pour les actions de déplacement
  _move = new NoMove(
            new NorthMove(
              new SouthMove(
                new WestMove(
                  new EastMove(
                    new NorthWestMove(
                      new NorthEastMove(
                        new SouthEastMove(
                          new SouthWestMove(NULL)
                        )
                      )
                    )
                  )
                )
              )
            )
          );
}

World::~World() {
  int i;

  for(i = 0; i < _width * _height; i++) {
    delete _map[i];
  }
  delete[] _map;
  delete _fightStrategy;
  delete _move;
}

unsigned int World::getWidth() {
  return _width;
}

unsigned int World::getHeight() {
  return _height;
}

Move* World::getMove() const {
  return _move;
}

void World::addGodsGift(unsigned int i, unsigned int j) {
  ReachableCell *next = NULL;
  GodsGiftFood *gift = NULL;
  Cell *cell = NULL;

  cell = getCell(i, j);
  next = dynamic_cast<ReachableCell*>(cell);
  //Une GodsGiftFood ne doit pas recouvrir une colonie
  if(next && ! dynamic_cast<ColonyCell*>(cell)) {
    gift = new GodsGiftFood(GODS_GIFT_FOOD_VALUE);
    if(gift != NULL) {
      // on l'empile par dessus l'ancienne case
      gift->push(next);
      // et on s'assure que la case retournée sera bien la nouvelle.
      getCell(i, j) = gift;
    }
  }
}

void World::iteration() {
  std::list<Worshiper*> *worshipers = NULL;
  std::list<Worshiper*>::iterator it, end;
  Cell *cell = NULL;
  unsigned int i, j;

  // Bonjour, bienvenu dans notre restaurant (création des worshipers)
  addNewWorshipers();
  // Voici la carte (prise des différentes commandes)
  for(i = 1; i < _height - 1; i++) {
    for(j = 1; j < _width - 1; j++) {
      cell = getCell(i, j);
      // pour chaque case, on itère sur les individus
      worshipers = cell->getPeople();
      if(worshipers != NULL) {
        end = worshipers->end();
        for(it = worshipers->begin(); it != end; ++it) {
          // Je vous laisse la consulter
          (*it)->think();
          // Quel est ce doux fumet ? (dépot de phéromones)
          addPheromone(cell, *it);
          // Et pour madame, ce sera ? (gestion des commandes)
          addCommand(*it, i, j);
        }
      }
    }
  }
  // Pour qui le steak frite ? (service)
  makeCommand();
  // Itadakimasu ! (Bon appétit !)
  for(i = 1; i < _height - 1; i++) {
    for(j = 1; j < _width - 1; j++) {
      cell = getCell(i, j);
      // on itère sur chaque individu de la case
      if(cell->getPeople() != NULL) {
        // les faibles meurent... (combats)
        // (point de syntaxe : plus simple que de s'embêter avec des pointeurs
        // de pointeurs... Il faut juste s'assurer que la variable locale
        // est aussi mise à jour)
        getCell(i, j) = cell = fight(cell);
        // ...et les forts se goinffrent (no comment)
        feed(cell);
        // Comment c'est passé votre repas ? (mise à jour du monde)
        getCell(i, j) = cell->makeActions();
      }
    }
  }
}

void World::draw() {
  int i, j;

  glMatrixMode(GL_MODELVIEW);

  for(i = 0; i < _height; i++) {
    for(j = 0; j < _width; j++) {
      // display each Cell the one after another
      getCell(i, j)->draw();
      glTranslatef(CELL_SIZE, 0.0, 0.0);
    }
    glTranslatef(- (GLfloat) CELL_SIZE * _width, 0.0, CELL_SIZE);
  }
}

---