/*
 * Module ID: lab2ches.h
 * Titre    : Module Secondaire du Lab 2 du cours ELE-440
 *
 * Auteur   : Olivier Langlois <olivier@olivierlanglois.net>
 * Date     : 4 Fevrier 1998
 *
 */

#ifndef   _LAB2CHES_H_
#define   _LAB2CHES_H_

#include "collect/colclass.h"
#include "chess.h"

class Lab2ChessCase : public ChessCase
{
  public:
     unsigned seq;
     int originCounter;

     /*
      * Ce sont des copies de cases qui sont inserees dans la queue afin d'eviter
      * une double liberation de memoire pour le meme objet a la destruction
      * du ChessBoard.
      *
      * possibleNextMoves est un PQ<Lab2ChessCase> mais une declaration
      * directe aurrait causee un probleme d'interdependance. C'est pourquoi
      * 'Collection *' est plutot utilise.
      */
     oliCollection *possibleNextMoves;

     /*
      * Le parametre allocatePQ est utilise pour indiquer au constructeur
      * si il doit ou non initialiser possibleNextMoves.
      * Il est necessaire de ne pas initialiser possibleNextMoves pour la
      * construction de sentinel car l'initialisation de possibleNextMoves
      * prend comme parametre sentinel.
      */
     Lab2ChessCase(
                         int      oc = 0,
                         unsigned s  = 0
                      );
     Lab2ChessCase( const Lab2ChessCase & );

     ~Lab2ChessCase() { delete possibleNextMoves; }

     virtual void init( void );

     // Operateurs necessaire pour le bon fonctionnement de PQ<Lab2ChessCase>
     // Voir PQ.h pour plus de detail.
     // Note : Plus originCounter est petit, plus la priorite est grande.
     void                    operator =(const Lab2ChessCase&);
     int                     operator==(const Lab2ChessCase&) const;
     int                     operator!=(const Lab2ChessCase&) const;
     int                     operator <(const Lab2ChessCase&) const;
     int                     operator >(const Lab2ChessCase&) const;
     int                     operator<=(const Lab2ChessCase&) const;
     int                     operator>=(const Lab2ChessCase&) const;

     virtual void print( ostream &os )
    { os << originCounter << " " << seq << "\t"; }

/******************************************************************************
 *
 * Nom       : addCase
 *
 * Utilite   : Ajoute la case a la position specifie dans la Priority Queue.
 *
 * Parametres:
 *     x,y    (int) Position de la case a ajouter.
 *
 * Valeur de retour: Aucune.
 *
 ****************************************************************************/
     void addCase( int x, int y );
};

class Lab2Column : public Column
{
  public:
     Lab2Column();
};

class Lab2ChessBoard : public ChessBoard
{
  public:
     /*
      * Il est important d'appeler initColumns() apres l'appel du constructeur
      * Cela ne peut pas etre fait a l'interieur du constructeur car l'appel
      * de fonctions virtuelles a l'interieur de constructeur est deconseille.
      */
     Lab2ChessBoard();
     ~Lab2ChessBoard();
#ifdef __GNUG__
     static Lab2ChessCase *sentinel;
#endif
};

/*
 * Lab2Knight: Knight specialise pour resoudre le probleme P3
 */
class Lab2Knight : public Knight
{
  public:
  Lab2Knight( ChessCase *initialPos = NULL )
  : Knight(initialPos) {}

/******************************************************************************
 *
 * Nom       : visitBoard
 *
 * Utilite   : Calcul le nombre d'origines possibles pour chaque case avec le
 *             chevalier.
 *
 * Parametres:
 *     board   (ChessBoard &) Jeu a visite.
 *
 * Valeur de retour: Aucune.
 *
 ****************************************************************************/
  virtual void visitBoard( ChessBoard &board );

/******************************************************************************
 *
 * Nom       : visitCase
 *
 * Utilite   : Calcul les destinations possibles pour le
 *             chevalier.
 *
 * Parametres:
 *     c      (ChessCase &) Case d'origine.
 *
 * Valeur de retour: Aucune.
 *
 ****************************************************************************/
  virtual void visitCase( ChessCase  &c     );
};

/******************************************************************************
 *
 * Nom       : getNext
 *
 * Utilite   : Retourne la prochaine case a essayer.
 *             (Sert aussi a decoupler PQ du module lab2)
 *
 * Parametres:
 *     ptrCase (Lab2ChessCase *) Case occupee.
 *
 * Valeur de retour: (Lab2ChessCase *) Case suivante.
 *
 ****************************************************************************/
 Lab2ChessCase *getNext( Lab2ChessCase *ptrCase );

#endif /* _LAB2CHES_H_ */