home *** CD-ROM | disk | FTP | other *** search
/ Freelog 17 / Freelog017.iso / BeOS / ababelone / Sources / PlateauDeJeuInterne.cpp < prev    next >
C/C++ Source or Header  |  2000-11-05  |  12KB  |  314 lines
  1. /*
  2.     Copyright (C) 2000 by Herv├⌐ PHILIPPE <rv@bemail.org>
  3.  
  4.     This library is free software; you can redistribute it and/or
  5.     modify it under the terms of the GNU Library General Public
  6.     License as published by the Free Software Foundation; either
  7.     version 2 of the License, or (at your option) any later version.
  8.  
  9.     This library is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.     Library General Public License for more details.
  13.  
  14.     You should have received a copy of the GNU Library General Public
  15.     License along with this library; if not, write to the Free
  16.     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18.  
  19. #include "PlateauDeJeuInterne.h"
  20.  
  21.   ////////////////////////////////////////////
  22.  // CONSTANTE "m_kTableauDirectionInterne" //
  23. ////////////////////////////////////////////-------------------------------------------------
  24. // Constante membre en "static" pour d├⌐finir les 6 d├⌐placements possibles (en Coordonnees) --
  25. //-------------------------------------------------------------------------------------------
  26. const Coordonnees PlateauDeJeuInterne::m_kTableauDirectionInterne[6]={
  27.             Coordonnees(-1,0),
  28.             Coordonnees(0,-1),
  29.             Coordonnees(1,-1),
  30.             Coordonnees(1,0),
  31.             Coordonnees(0,1),
  32.             Coordonnees(-1,1)
  33. };
  34.  
  35.   ///////////////////////////////////////////
  36.  // CONSTRUCTEUR de "PlateauDeJeuInterne" //
  37. ///////////////////////////////////////////----------------
  38. // Construit les tableaux dynamiques en les initialisant --
  39. //---------------------------------------------------------
  40. PlateauDeJeuInterne::PlateauDeJeuInterne(uint8 nombre_boules, uint8 nombre_joueurs)
  41. // 2 PARAMETRES :                                ENTREE                ENTREE
  42.     : PlateauDeJeu(0, nombre_joueurs)    // 0 pour pouvoir utiliser "ChangerNombreBoules" !
  43. {
  44.     int i;
  45.  
  46.     m_TableauBoulesCoord = NULL;
  47.     ChangerNombreBoules(nombre_boules);
  48.  
  49.     m_TableauBoulesEjectees = new uint8[NOMBRE_JOUEURS_MAXI];
  50.     InitialiserBoulesEjectees();
  51.  
  52.     m_Tableau = new (int8*)[TAILLE_TABLEAU_INTERNE];
  53.     for (i = 0; i < TAILLE_TABLEAU_INTERNE; i++)
  54.         m_Tableau[i] = new int8[TAILLE_TABLEAU_INTERNE];
  55. }
  56.  
  57.   //////////////////////////////////////////
  58.  // DESTRUCTEUR de "PlateauDeJeuInterne" //
  59. //////////////////////////////////////////
  60. // D├⌐truit les tableaux dynamiques --
  61. //-----------------------------------
  62. PlateauDeJeuInterne::~PlateauDeJeuInterne()
  63. // AUCUN PARAMETRE
  64. {
  65.     int i;
  66.  
  67.     for (i = 0; i < TAILLE_TABLEAU_INTERNE; i++)
  68.         delete m_Tableau[i];
  69.     delete[] m_Tableau;
  70.     delete[] m_TableauBoulesCoord;
  71.     delete[] m_TableauBoulesEjectees;
  72. }
  73.  
  74.   //////////////////////////
  75.  // FONCTION "operator=" //
  76. //////////////////////////--------------
  77. // Affectation  (├⌐galit├⌐ de 2 objets) --
  78. //--------------------------------------
  79. PlateauDeJeuInterne&        // VALEUR DE RETOUR
  80. PlateauDeJeuInterne::operator=(const PlateauDeJeuInterne& ancien_plateau_interne)
  81. // 1 PARAMETRE :                                    ENTREE (@)
  82. {
  83.     int i, j;
  84.  
  85.     ChangerNombreBoules(ancien_plateau_interne.m_NombreBoules);
  86.     for (i = 0; i < TAILLE_TABLEAU_INTERNE; i++)
  87.         for (j = 0; j < TAILLE_TABLEAU_INTERNE; j++)
  88.             m_Tableau[i][j] = ancien_plateau_interne.m_Tableau[i][j];
  89.     for (i = 0; i < m_NombreBoules; i++)
  90.         m_TableauBoulesCoord[i] = ancien_plateau_interne.m_TableauBoulesCoord[i];
  91.     for (i = 0; i < NOMBRE_JOUEURS_MAXI; i++)
  92.         m_TableauBoulesEjectees[i] = ancien_plateau_interne.m_TableauBoulesEjectees[i];
  93.     return *this;
  94. }
  95.  
  96.   ///////////////////////////////////
  97.  // FONCTION "ValeurCaseSuivante" //
  98. ///////////////////////////////////--------
  99. // Renvoie la valeur de la case suivante --
  100. //-----------------------------------------
  101. int8        // VALEUR DE RETOUR
  102. PlateauDeJeuInterne::ValeurCaseSuivante(int8 numero_boule, int8 direction)
  103. // 2 PARAMETRES :                                ENTREE            ENTREE
  104. {
  105.     Coordonnees coordonnees_case = CoordonneesBoule(numero_boule);
  106.     coordonnees_case += m_kTableauDirectionInterne[direction];
  107.     return ValeurCase(coordonnees_case);
  108. }
  109.  
  110.   /////////////////////////////////////
  111.  // FONCTION "ValeurCasePrecedente" //
  112. /////////////////////////////////////--------
  113. // Renvoie la valeur de la case pr├⌐c├⌐dente --
  114. //-------------------------------------------
  115. int8        // VALEUR DE RETOUR
  116. PlateauDeJeuInterne::ValeurCasePrecedente(int8 numero_boule, int8 direction)
  117. // 2 PARAMETRES :                                ENTREE            ENTREE
  118. {
  119.     Coordonnees coordonnees_case = CoordonneesBoule(numero_boule);
  120.     coordonnees_case -= m_kTableauDirectionInterne[direction];
  121.     return ValeurCase(coordonnees_case);
  122. }
  123.  
  124.   //////////////////////////////////
  125.  // FONCTION "DeplacerBoule" n┬░1 //
  126. //////////////////////////////////-----------------------------------------------------
  127. // D├⌐place une boule en fonction de son num├⌐ro et de la direction de son d├⌐placement --
  128. // REMARQUE : traitement de l'├⌐jection s'il y a lieu                                 --
  129. //-------------------------------------------------------------------------------------
  130. void        // AUCUNE VALEUR DE RETOUR
  131. PlateauDeJeuInterne::DeplacerBoule(int8 numero_boule, int8 direction)
  132. // 2 PARAMETRES :                        ENTREE            ENTREE
  133. {
  134.     Coordonnees coordonnees_case = m_TableauBoulesCoord[numero_boule-1];
  135.     Coordonnees coordonnees_case_suivante = coordonnees_case;
  136.  
  137.     coordonnees_case_suivante += m_kTableauDirectionInterne[direction];
  138.     if (ValeurCase(coordonnees_case_suivante) != -1)
  139.         SetCase(coordonnees_case_suivante, numero_boule);
  140.     else {
  141.         m_TableauBoulesCoord[numero_boule-1] = COORD_NULL;
  142. //        (m_TableauBoulesEjectees[CouleurBoule(numero_boule)])++;
  143.     }
  144.     SetCase(coordonnees_case, 0);
  145.  
  146. }
  147.  
  148.   //////////////////////////////////
  149.  // FONCTION "DeplacerBoule" n┬░2 //
  150. //////////////////////////////////-------------------------------------------------------------------
  151. // D├⌐place une boule en fonction des coordonn├⌐es (anciennes) et de la direction de son d├⌐placement --
  152. // REMARQUE : traitement de l'├⌐jection s'il y a lieu                                               --
  153. //---------------------------------------------------------------------------------------------------
  154. Coordonnees        // VALEUR DE RETOUR
  155. PlateauDeJeuInterne::DeplacerBoule(Coordonnees coordonnees_case, int8 direction)
  156. // 2 PARAMETRES :                            ENTREE                    ENTREE
  157. {
  158.     Coordonnees coordonnees_case_suivante = coordonnees_case;
  159.     int8 numero_boule = m_Tableau[coordonnees_case.x][coordonnees_case.y];
  160.  
  161.     coordonnees_case_suivante += m_kTableauDirectionInterne[direction];
  162.     if (ValeurCase(coordonnees_case_suivante) != -1)
  163.         SetCase(coordonnees_case_suivante, numero_boule);
  164.     else {
  165.         m_TableauBoulesCoord[numero_boule-1] = COORD_NULL;
  166. //        (m_TableauBoulesEjectees[CouleurBoule(numero_boule)])++;
  167.     }
  168.     SetCase(coordonnees_case, 0);
  169.     return coordonnees_case_suivante;
  170. }
  171.  
  172.   /////////////////////////////////
  173.  // FONCTION "CoordonneesBoule" //
  174. /////////////////////////////////---------
  175. // Renvoie les coordonn├⌐es d'une boule  --
  176. //----------------------------------------
  177. Coordonnees        // VALEUR DE RETOUR
  178. PlateauDeJeuInterne::CoordonneesBoule(int8 numero_boule)
  179. // 1 PARAMETRE :                            ENTREE
  180. {
  181.     return m_TableauBoulesCoord[numero_boule-1];
  182. }
  183.  
  184.   /////////////////////////////////////
  185.  // FONCTION "CoordonneesSuivantes" //
  186. /////////////////////////////////////-----------------------------------------
  187. // Renvoie les coordonn├⌐es de la case suivante, en fonction de la direction --
  188. //----------------------------------------------------------------------------
  189. Coordonnees        // VALEUR DE RETOUR
  190. PlateauDeJeuInterne::CoordonneesSuivantes(Coordonnees coordonnees_case, int8 direction)
  191. // 2 PARAMETRES :                                        ENTREE                ENTREE
  192. {
  193.     return coordonnees_case + m_kTableauDirectionInterne[direction];
  194. }
  195.  
  196.   ///////////////////////////
  197.  // FONCTION "ValeurCase" //
  198. ///////////////////////////---------------------------------------------
  199. // Renvoie la valeur d'une case (ou -100 si la case n'est pas valide) --
  200. //----------------------------------------------------------------------
  201. int8        // VALEUR DE RETOUR
  202. PlateauDeJeuInterne::ValeurCase(Coordonnees coordonnees_case)
  203. // 1 PARAMETRE :                            ENTREE
  204. { 
  205.     TYPE_COORD    x = coordonnees_case.x,
  206.                 y = coordonnees_case.y;
  207.  
  208.     if (x > -1 && y > -1 && x < TAILLE_TABLEAU_INTERNE && y < TAILLE_TABLEAU_INTERNE)
  209.         return m_Tableau[x][y];
  210.     else
  211.         return -100;
  212. }
  213.  
  214.   ////////////////////////
  215.  // FONCTION "SetCase" //
  216. ////////////////////////---------------------------------------------------------------------------
  217. // Ecrit une donn├⌐e dans une case du tableau interne (modification aussi du tableau qui contient --
  218. // les coordonn├⌐es de boules)                                                                    --
  219. //-------------------------------------------------------------------------------------------------
  220. void        // AUCUNE VALEUR DE RETOUR
  221. PlateauDeJeuInterne::SetCase(Coordonnees coordonnees_case, int8 donnee)
  222. // 2 PARAMETRES :                        ENTREE                ENTREE
  223. {
  224.     TYPE_COORD    x = coordonnees_case.x,
  225.                 y = coordonnees_case.y;
  226.  
  227.     if (x > -1 && y > -1 && x < TAILLE_TABLEAU_INTERNE && y < TAILLE_TABLEAU_INTERNE)
  228.         m_Tableau[x][y] = donnee;
  229.     if (x > 0)
  230.         m_TableauBoulesCoord[donnee-1] = coordonnees_case;
  231. }
  232.  
  233.   //////////////////////////////////////////
  234.  // FONCTION "InitialiserBoulesEjectees" //
  235. //////////////////////////////////////////-----------------------------
  236. // Initialise le nombre des boules ├⌐ject├⌐es pour toutes les couleurs --
  237. //---------------------------------------------------------------------
  238. void        // AUCUNE VALEUR DE RETOUR
  239. PlateauDeJeuInterne::InitialiserBoulesEjectees()
  240. // AUCUN PARAMETRE
  241. {
  242.     int i;
  243.  
  244.     for (i = 0; i < NOMBRE_JOUEURS_MAXI; i++)
  245.         m_TableauBoulesEjectees[i] = 0;
  246. }
  247.  
  248.   ///////////////////////////////
  249.  // FONCTION "BoulesEjectees" //
  250. ///////////////////////////////---------------------------
  251. // Retourne le nombre des boules ├⌐ject├⌐es d'une couleur --
  252. //--------------------------------------------------------
  253. uint8        // VALEUR DE RETOUR
  254. PlateauDeJeuInterne::BoulesEjectees(int8 couleur)
  255. // 1 PARAMETRE :                        ENTREE
  256. {
  257.     return m_TableauBoulesEjectees[couleur];
  258. }
  259.  
  260.   //////////////////////////////////////////
  261.  // FONCTION "IncrementerBoulesEjectees" //
  262. //////////////////////////////////////////------------------
  263. // Incr├⌐mente le nombre des boules ├⌐ject├⌐es d'une couleur --
  264. //----------------------------------------------------------
  265. void        // AUCUNE VALEUR DE RETOUR
  266. PlateauDeJeuInterne::IncrementerBoulesEjectees(int8 couleur)
  267. // 1 PARAMETRE :                                    ENTREE
  268. {
  269.     (m_TableauBoulesEjectees[couleur])++;
  270. }
  271.  
  272.   //////////////////////////////////////////
  273.  // FONCTION "DecrementerBoulesEjectees" //
  274. //////////////////////////////////////////------------------
  275. // D├⌐cr├⌐mente le nombre des boules ├⌐ject├⌐es d'une couleur --
  276. //----------------------------------------------------------
  277. void        // AUCUNE VALEUR DE RETOUR
  278. PlateauDeJeuInterne::DecrementerBoulesEjectees(int8 couleur)
  279. // 1 PARAMETRE :                                    ENTREE
  280. {
  281.     (m_TableauBoulesEjectees[couleur])--;
  282. }
  283.  
  284.   ////////////////////////////////////
  285.  // FONCTION "ChangerNombreBoules" //
  286. ////////////////////////////////////----------------------------------
  287. // Change le nombre total de boules et change le tableau de boules  --
  288. //--------------------------------------------------------------------
  289. void        // AUCUNE VALEUR DE RETOUR
  290. PlateauDeJeuInterne::ChangerNombreBoules(uint8 nombre_boules)
  291. // 1 PARAMETRE :                                ENTREE
  292. {
  293.     if (nombre_boules != m_NombreBoules) {
  294.         PlateauDeJeu::ChangerNombreBoules(nombre_boules);
  295.         if (m_TableauBoulesCoord != NULL) {
  296.             delete[] m_TableauBoulesCoord;
  297.             m_TableauBoulesCoord = NULL;    // Pas n├⌐cessaire
  298.         }
  299.         m_TableauBoulesCoord = new Coordonnees[m_NombreBoules](COORD_NULL);
  300.     }
  301. }
  302.  
  303.   //////////////////////////////////////
  304.  // FONCTION "TableauBoulesEjectees" //
  305. //////////////////////////////////////------------------------------------------
  306. // Renvoie le tableau des boules ├⌐ject├⌐ees (pour le plateau de jeu graphique) --
  307. //------------------------------------------------------------------------------
  308. uint8*        // VALEUR DE RETOUR
  309. PlateauDeJeuInterne::TableauBoulesEjectees()
  310. // AUCUN PARAMETRE
  311. {
  312.     return m_TableauBoulesEjectees;
  313. }
  314.