home *** CD-ROM | disk | FTP | other *** search
/ Freelog 17 / Freelog017.iso / BeOS / ababelone / Sources / PlateauDeJeuGraphique.cpp < prev    next >
C/C++ Source or Header  |  2000-11-22  |  26KB  |  663 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 "PlateauDeJeuGraphique.h"
  20. #include "FenetreAbabelone.h"    // Pour faire appel aux fonctions "SourisBouton..."
  21.                                 //  de la fen├¬tre FenetreAbabelone
  22.  
  23.   //////////////////////////////////////////////
  24.  // CONSTANTE "m_kTableauDirectionGraphique" //
  25. //////////////////////////////////////////////------------------------------------------
  26. // Constante membre en "static" pour d├⌐finir les 6 d├⌐placements possibles (en pixels) --
  27. //--------------------------------------------------------------------------------------
  28. const BPoint PlateauDeJeuGraphique::m_kTableauDirectionGraphique[6]={
  29.             BPoint(-LARGEUR_CASE_BOULE,0),
  30.             BPoint(-LARGEUR_CASE_BOULE/2,-HAUTEUR_CASE_BOULE),
  31.             BPoint(LARGEUR_CASE_BOULE/2,-HAUTEUR_CASE_BOULE),
  32.             BPoint(LARGEUR_CASE_BOULE,0),
  33.             BPoint(LARGEUR_CASE_BOULE/2,HAUTEUR_CASE_BOULE),
  34.             BPoint(-LARGEUR_CASE_BOULE/2,HAUTEUR_CASE_BOULE)
  35. };
  36.  
  37.   /////////////////////////////////////////////
  38.  // CONSTRUCTEUR de "PlateauDeJeuGraphique" //
  39. /////////////////////////////////////////////----------------------------------------------------
  40. // Construit les tableaux dynamiques et les Bitmap, et initialise toutes les variables membres --
  41. //-----------------------------------------------------------------------------------------------
  42. PlateauDeJeuGraphique::PlateauDeJeuGraphique(BRect rect, char *name, TextesDuLogiciel* textes, MenuDynamique* menu_plateau, uint8 nombre_boules, uint8 nombre_joueurs)
  43. // 5 PARAMETRES :                                ENTREE        ENTREE            ENTREE                    ENTREE                    ENTREE
  44.     : PlateauDeJeu(0, nombre_joueurs),     // 0 pour pouvoir utiliser "ChangerNombre..." !
  45.     BView(rect, name, B_FOLLOW_ALL, B_WILL_DRAW | B_SUBPIXEL_PRECISE /* | B_FULL_UPDATE_ON_RESIZE | B_FRAME_EVENTS*/)
  46. {
  47.     int8 i;                            // Compteur
  48.     char chaine_nom_fichier[100];    // Pour le chargement des fichiers Bitmap
  49.  
  50.     m_Textes = textes;
  51.     m_MenuPlateauDeJeu = menu_plateau;
  52.     m_PlateauBitmap = NULL;
  53.     m_TableauBoules = NULL;
  54.     ChangerNombreBoules(nombre_boules);
  55.  
  56.     m_TableauSelect = new BRect[3](BOULE_CACHEE);
  57.     m_TableauFleches = new BRect[6](BOULE_CACHEE);
  58.     m_TableauBoulesEjectees = NULL;
  59.     m_CouronneDeLaurier = false;
  60.     m_Pause = false;
  61.     m_Echelle = 1;
  62.     m_BouleCouleurAJouer = -1;
  63.     m_TableauChainesJoueurs = NULL;
  64.     m_TableauBoulesJoueursBitmap = new (BBitmap*)[NOMBRE_JOUEURS_MAXI];
  65.     // Lire les fichiers image pour les images des boules
  66.     for (i = 0; i < NOMBRE_JOUEURS_MAXI; i++) {
  67.         sprintf(chaine_nom_fichier,"Images/Boule joueur n┬░%d",i+1);
  68.         m_TableauBoulesJoueursBitmap[i] = BTranslationUtils::GetBitmap(chaine_nom_fichier);
  69.     }
  70.  
  71.     m_TableauFlechesBitmap = new (BBitmap*)[6];
  72.     // Lire les fichiers image pour les images des fl├¿ches
  73.     for (i = 0; i < 6; i++) {
  74.         sprintf(chaine_nom_fichier,"Images/Fl├¿che n┬░%d",i);
  75.         m_TableauFlechesBitmap[i] = BTranslationUtils::GetBitmap(chaine_nom_fichier);
  76.     }
  77.     m_TableauSelectBitmap = new (BBitmap*)[3];
  78.     // Lire les fichiers image pour les images des s├⌐lections
  79.     for (i = 0; i < 3; i++) {
  80.         sprintf(chaine_nom_fichier,"Images/S├⌐lection n┬░%d",i);
  81.         m_TableauSelectBitmap[i] = BTranslationUtils::GetBitmap(chaine_nom_fichier);
  82.     }
  83.     m_CouronneDeLaurierBitmap = BTranslationUtils::GetBitmap("Images/Couronne de laurier");
  84.     m_BufferBitmap = new BBitmap(rect, B_RGB32, true);
  85.     ChangerPlateauDeJeu();
  86.     SetViewColor(B_TRANSPARENT_COLOR);
  87. }
  88.  
  89.   ////////////////////////////////////////////
  90.  // DESTRUCTEUR de "PlateauDeJeuGraphique" //
  91. ////////////////////////////////////////////-------
  92. // D├⌐truit les tableaux dynamiques et les Bitmap --
  93. //-------------------------------------------------
  94. PlateauDeJeuGraphique::~PlateauDeJeuGraphique()
  95. // AUCUN PARAMETRE
  96. {
  97.     int i;
  98.  
  99.     // D├⌐truire "m_TableauChainesJoueurs" s'il a ├⌐t├⌐ cr├⌐├⌐
  100.     ChangerTypeJoueurs(m_NombreJoueurs, NULL, NULL);
  101.     // D├⌐truire les fichiers Bitmap des images des s├⌐lections
  102.     for (i = 0; i < 3; i++)
  103.         delete m_TableauSelectBitmap[i];
  104.     delete m_TableauSelectBitmap;
  105.     // D├⌐truire les fichiers Bitmap des images des fl├¿ches
  106.     for (i = 0; i < 6; i++)
  107.         delete m_TableauFlechesBitmap[i];
  108.     delete m_TableauFlechesBitmap;
  109.     // D├⌐truire les fichiers Bitmap des images des boules
  110.     for (i = 0; i < NOMBRE_JOUEURS_MAXI; i++)
  111.         delete m_TableauBoulesJoueursBitmap[i];
  112.     delete m_TableauBoulesJoueursBitmap;
  113.     delete m_BufferBitmap;
  114.     delete m_PlateauBitmap;
  115.     delete m_TableauBoules;
  116. }
  117.  
  118.   /////////////////////
  119.  // FONCTION "Draw" //
  120. /////////////////////------------------------------------------------------------------
  121. // Redessine une partie (ou la totalit├⌐) du plateau de jeu (en se servant du buffer) --
  122. //-------------------------------------------------------------------------------------
  123. void        // AUCUNE VALEUR DE RETOUR
  124. PlateauDeJeuGraphique::Draw(BRect updateRect)
  125. // 1 PARAMETRE :                ENTREE
  126. {
  127.     if (m_BufferBitmap != NULL && m_BufferBitmap->Lock()) {
  128.         DrawBitmap(m_BufferBitmap,updateRect,updateRect);
  129.         m_BufferBitmap->Unlock();    
  130.     }
  131. }
  132.  
  133.   //////////////////////////////////////
  134.  // FONCTION "MiseAJourBufferEntier" //
  135. //////////////////////////////////////---------------------------------
  136. // Met ├á jour TOUT le buffer servant ├á l'affichage du plateau de jeu --
  137. //---------------------------------------------------------------------
  138. void        // AUCUNE VALEUR DE RETOUR
  139. PlateauDeJeuGraphique::MiseAJourBufferEntier()
  140. // AUCUN PARAMETRE
  141. {
  142.     MiseAJourBuffer(m_PlateauBitmap->Bounds());
  143. }
  144.  
  145.   ////////////////////////////////
  146.  // FONCTION "MiseAJourBuffer" //
  147. ////////////////////////////////--------------------------------------------------------------
  148. // Met ├á jour une partie du buffer (ou la totalit├⌐) servant ├á l'affichage du plateau de jeu --
  149. //--------------------------------------------------------------------------------------------
  150. void        // AUCUNE VALEUR DE RETOUR
  151. PlateauDeJeuGraphique::MiseAJourBuffer(BRect updateRect)
  152. // 1 PARAMETRE :                            ENTREE
  153. {
  154.     int i;
  155.     BPoint position_texte;
  156.  
  157.     if (Window()->Lock()) {
  158.         BView vue(Bounds(), NULL, B_FOLLOW_ALL, B_WILL_DRAW | B_SUBPIXEL_PRECISE);
  159.         if (m_BufferBitmap->Lock()) {
  160.     
  161.             vue.SetViewColor(B_TRANSPARENT_COLOR);
  162.             vue.SetDrawingMode(B_OP_ALPHA);
  163.             vue.SetBlendingMode(B_PIXEL_ALPHA,B_ALPHA_OVERLAY);
  164.     
  165.             m_BufferBitmap->AddChild(&vue);
  166.             vue.SetScale(m_Echelle);
  167.             vue.DrawBitmapAsync(m_PlateauBitmap, updateRect, updateRect);
  168.     
  169.             if (m_BouleCouleurAJouer != -1 && updateRect.Intersects(RECT_BOULE_COULEUR_A_JOUER)) {
  170.                 vue.DrawBitmapAsync(m_TableauBoulesJoueursBitmap[m_BouleCouleurAJouer], RECT_BOULE_COULEUR_A_JOUER);
  171.                 if (m_CouronneDeLaurier == true)
  172.                     vue.DrawBitmapAsync(m_CouronneDeLaurierBitmap, RECT_COURONNE_DE_LAURIER);
  173.                 else
  174.                     if (m_Pause == true) {
  175.                         vue.SetFontSize(20);
  176.                         vue.SetHighColor(255,0,0);
  177.                         position_texte = RECT_BOULE_COULEUR_A_JOUER.LeftBottom();
  178.                         position_texte.x += 10;
  179.                         position_texte.y += -RECT_BOULE_COULEUR_A_JOUER.Height()/2+8;
  180.                         vue.DrawString(m_Textes->Texte(26),  position_texte);
  181.                     }
  182.             }
  183.             
  184.             if (m_TableauChainesJoueurs != NULL && updateRect.Intersects(RECT_JOUEURS)) {
  185.                 vue.SetFontSize(20);
  186.                 vue.SetHighColor(255,255,0);
  187.                 position_texte = RECT_JOUEURS.LeftTop();
  188.                 if (m_NombreJoueurs == 2)
  189.                     position_texte.y += HAUTEUR_BOULE + 10;
  190.                 for (i=0; i < m_NombreJoueurs; i++) {
  191.                     vue.DrawBitmapAsync(m_TableauBoulesJoueursBitmap[i], BRect(position_texte.x,position_texte.y,position_texte.x+LARGEUR_PETITE_BOULE,position_texte.y+HAUTEUR_PETITE_BOULE));
  192.                     position_texte.x += LARGEUR_PETITE_BOULE + 5;
  193.                     position_texte.y += (HAUTEUR_BOULE+10)/2 - 10;
  194.                     vue.DrawString(m_TableauChainesJoueurs[i],  position_texte);
  195.                     position_texte.x -= LARGEUR_PETITE_BOULE + 5;
  196.                     position_texte.y += (HAUTEUR_BOULE+10)/2 + 10;
  197.                 }
  198.             }
  199.             if (m_TableauBoulesEjectees != NULL) {
  200.                 vue.SetFontSize(20);
  201.                 vue.SetHighColor(255,255,0);
  202.                 position_texte.y = 400;
  203.                 position_texte.x = 40;
  204.                 for (i=0; i < m_NombreJoueurs; i++) {
  205.                     vue.DrawBitmapAsync(m_TableauBoulesJoueursBitmap[i], BRect(position_texte.x-5,position_texte.y+15,position_texte.x+LARGEUR_PETITE_BOULE-5,position_texte.y+HAUTEUR_PETITE_BOULE+15));
  206.                     vue.DrawChar(m_TableauBoulesEjectees[i]+'0',  position_texte);
  207.                     position_texte.x += LARGEUR_BOULE + 8;
  208.                 }
  209.             }
  210.             for (i = 0; i < m_NombreBoules; i++)
  211.                 if (m_TableauBoules[i] != BOULE_CACHEE && updateRect.Intersects(m_TableauBoules[i]))
  212.                     vue.DrawBitmapAsync(m_TableauBoulesJoueursBitmap[CouleurBoule(i+1)], m_TableauBoules[i]);
  213.     
  214.             for (i = 0; i < 3; i++)
  215.                 if (m_TableauSelect[i] != BOULE_CACHEE && updateRect.Intersects(m_TableauSelect[i]))
  216.                     vue.DrawBitmapAsync(m_TableauSelectBitmap[i], m_TableauSelect[i]);
  217.     
  218.             for (i = 0; i < 6; i++)
  219.                 if (m_TableauFleches[i] != BOULE_CACHEE && updateRect.Intersects(m_TableauFleches[i]))
  220.                     vue.DrawBitmapAsync(m_TableauFlechesBitmap[i], m_TableauFleches[i]);
  221.     
  222.             vue.Sync();
  223.             m_BufferBitmap->RemoveChild(&vue);
  224.             m_BufferBitmap->Unlock();
  225.             Draw(ConvertirAvecEchelle(updateRect));
  226.         }
  227.         Window()->Unlock();
  228.     }
  229. }
  230.  
  231.   ///////////////////////////////
  232.  // FONCTION "ChangerEchelle" //
  233. ///////////////////////////////-------------
  234. // Change l'├⌐chelle servant ├á l'affichage --
  235. //------------------------------------------
  236. void        // AUCUNE VALEUR DE RETOUR
  237. PlateauDeJeuGraphique::ChangerEchelle(float echelle)
  238. // 1 PARAMETRE :                        ENTREE
  239. {
  240.     m_Echelle = echelle;
  241. }
  242.  
  243.   //////////////////////////
  244.  // FONCTION "MouseDown" //
  245. //////////////////////////---------------------------------------------------
  246. // Traite le cas o├╣ l'utilisateur appuie sur un bouton de la souris        --
  247. // Si c'est le bouton gauche, la fonction "SourisBoutonGaucheAppuye"       --
  248. // de la classe "FenetreAbabelone" sera ex├⌐cut├⌐e                           --
  249. // Si c'est le bouton droit, ce sera la fonction "SourisBoutonDroitAppuye" --
  250. //---------------------------------------------------------------------------
  251. void        // AUCUNE VALEUR DE RETOUR
  252. PlateauDeJeuGraphique::MouseDown(BPoint where)
  253. // 1 PARAMETRE :                    ENTREE
  254. {
  255.     BPoint where_temp;
  256.     uint32 bouton;
  257.  
  258.     GetMouse(&where_temp, &bouton);
  259.     if (bouton == B_PRIMARY_MOUSE_BUTTON)
  260.         ((FenetreAbabelone*)Window())->SourisBoutonGaucheAppuye(ConvertirAvecEchelleInverse(where));
  261.     else
  262.         if (bouton == B_SECONDARY_MOUSE_BUTTON)
  263.             ((FenetreAbabelone*)Window())->SourisBoutonDroitAppuye();
  264. }
  265.  
  266.   ////////////////////////
  267.  // FONCTION "MouseUp" //
  268. ////////////////////////-------------------------------------------------------------
  269. // Traite le cas o├╣ l'utilisateur rel├óche un bouton de la souris                   --
  270. // La fonction "SourisBoutonRelache" de la classe "FenetreAbabelone" sera ex├⌐cut├⌐e --
  271. //-----------------------------------------------------------------------------------
  272. void        // AUCUNE VALEUR DE RETOUR
  273. PlateauDeJeuGraphique::MouseUp(BPoint where)
  274. // 1 PARAMETRE :                    ENTREE
  275. {
  276.     ((FenetreAbabelone*)Window())->SourisBoutonRelache(ConvertirAvecEchelleInverse(where));
  277. }
  278.  
  279.   ///////////////////////////
  280.  // FONCTION "MouseMoved" //
  281. ///////////////////////////---------------------------------------------------------------
  282. // Traite le cas o├╣ l'utilisateur bouge la souris en dehors de la vue du plateau de jeu --
  283. // La fonction "SourisBoutonRelache" de la classe "FenetreAbabelone" sera ex├⌐cut├⌐e      --
  284. //----------------------------------------------------------------------------------------
  285. void        // AUCUNE VALEUR DE RETOUR
  286. PlateauDeJeuGraphique::MouseMoved(BPoint where, uint32 transit, const BMessage *message)
  287. // 3 PARAMETRES :                    ENTREE            ENTREE                ENTREE
  288. {
  289.     if (transit == B_EXITED_VIEW)
  290.         ((FenetreAbabelone*)Window())->SourisBoutonRelache(ConvertirAvecEchelleInverse(where));
  291. }
  292.  
  293.   //////////////////////////////////
  294.  // FONCTION "SetBouleInvisible" //
  295. //////////////////////////////////
  296. // Rend une boule invisible  --
  297. //-----------------------------
  298. void        // AUCUNE VALEUR DE RETOUR
  299. PlateauDeJeuGraphique::SetBouleInvisible(int8 numero_boule)
  300. // 1 PARAMETRE :                                ENTREE
  301. {
  302.     m_TableauBoules[numero_boule-1] = BOULE_CACHEE;
  303. }
  304.  
  305.   /////////////////////////////
  306.  // FONCTION "BouleVisible" //
  307. /////////////////////////////----------------------------------------------------------------
  308. // Renvoie l'information selon laquelle une boule est visible (true) ou invisible (false)  --
  309. //-------------------------------------------------------------------------------------------
  310. bool        // VALEUR DE RETOUR
  311. PlateauDeJeuGraphique::BouleVisible(int8 numero_boule)
  312. // 1 PARAMETRE :                        ENTREE
  313. {
  314.     return m_TableauBoules[numero_boule-1] != BOULE_CACHEE;
  315. }
  316.  
  317.   //////////////////////
  318.  // FONCTION "Boule" //
  319. //////////////////////-------------------
  320. // Renvoie les coordonn├⌐es d'une boule --
  321. //---------------------------------------
  322. BRect        // VALEUR DE RETOUR
  323. PlateauDeJeuGraphique::Boule(int8 numero_boule)
  324. // 1 PARAMETRE :                    ENTREE
  325. {
  326.     return m_TableauBoules[numero_boule-1];
  327. }
  328.  
  329.   //////////////////////////////
  330.  // FONCTION "DeplacerBoule" //
  331. //////////////////////////////-----------------------------------------
  332. // D├⌐place graphiquement une boule (avec delta_x et delta_y)         --
  333. // Renvoie le rectangle de mise ├á jour pour le buffer de la fen├¬tre  --
  334. //---------------------------------------------------------------------
  335. BRect        // VALEUR DE RETOUR
  336. PlateauDeJeuGraphique::DeplacerBoule(int8 numero_boule, int delta_x, int delta_y)
  337. // 3 PARAMETRES :                            ENTREE            ENTREE        ENTREE
  338. {
  339.     BRect position_union = m_TableauBoules[numero_boule-1];
  340.  
  341.     m_TableauBoules[numero_boule-1].OffsetBy(delta_x, delta_y);
  342.     return position_union | m_TableauBoules[numero_boule-1];
  343. }
  344.  
  345.   /////////////////////////
  346.  // FONCTION "SetBoule" //
  347. /////////////////////////---------------
  348. // Change les coordonn├⌐es d'une boule --
  349. //--------------------------------------
  350. void        // AUCUNE VALEUR DE RETOUR
  351. PlateauDeJeuGraphique::SetBoule(int8 numero_boule, const BRect& rect)
  352. // 2 PARAMETRES :                    ENTREE            ENTREE (@)
  353. {
  354.     m_TableauBoules[numero_boule-1] = rect;
  355. }
  356.  
  357.   /////////////////////////////////
  358.  // FONCTION "SetPositionBoule" //
  359. /////////////////////////////////-------------------------------------
  360. // D├⌐place graphiquement une boule (vers un BPoint)                 --
  361. // Renvoie le rectangle de mise ├á jour pour le buffer de la fen├¬tre --
  362. //--------------------------------------------------------------------
  363. BRect        // VALEUR DE RETOUR
  364. PlateauDeJeuGraphique::SetPositionBoule(int8 numero_boule, const BPoint& point)
  365. // 2 PARAMETRES :                            ENTREE                ENTREE (@)
  366. {
  367.     BRect position_union = m_TableauBoules[numero_boule-1];
  368.  
  369.     m_TableauBoules[numero_boule-1].OffsetTo(point);
  370.     return position_union | m_TableauBoules[numero_boule-1];
  371. }
  372.  
  373.   ///////////////////////////////
  374.  // FONCTION "AfficherSelect" //
  375. ///////////////////////////////------------------------------------------
  376. // Affiche l'image de la s├⌐lection (n┬░1, 2 ou 3) au-dessus d'une boule --
  377. // Met ├á jour le buffer de la fen├¬tre                                  --
  378. //-----------------------------------------------------------------------
  379. void        // AUCUNE VALEUR DE RETOUR
  380. PlateauDeJeuGraphique::AfficherSelect(uint8 numero_select, int8 numero_boule)
  381. // 2 PARAMETRES :                            ENTREE                ENTREE
  382. {
  383.     BRect position = Boule(numero_boule);
  384.     m_TableauSelect[numero_select-1] = position;
  385.     MiseAJourBuffer(position);
  386. }
  387.  
  388.   //////////////////////////////
  389.  // FONCTION "EffacerSelect" //
  390. //////////////////////////////--------------------
  391. // Efface l'image de la s├⌐lection (n┬░1, 2 ou 3) --
  392. // Met ├á jour le buffer de la fen├¬tre           --
  393. //------------------------------------------------
  394. void        // AUCUNE VALEUR DE RETOUR
  395. PlateauDeJeuGraphique::EffacerSelect(uint8 numero_select)
  396. // 1 PARAMETRE :                            ENTREE
  397. {
  398.     BRect ancienne_position = m_TableauSelect[numero_select-1];
  399.  
  400.     if (ancienne_position != BOULE_CACHEE) {
  401.         m_TableauSelect[numero_select-1] = BOULE_CACHEE;
  402.         MiseAJourBuffer(ancienne_position);
  403.     }
  404. }
  405.  
  406.   ///////////////////////////////
  407.  // FONCTION "AfficherFleche" //
  408. ///////////////////////////////-------------------------
  409. // Affiche l'image d'une fl├¿che au-dessus d'une boule --
  410. // Met ├á jour le buffer de la fen├¬tre                 --
  411. //------------------------------------------------------
  412. void        // AUCUNE VALEUR DE RETOUR
  413. PlateauDeJeuGraphique::AfficherFleche(uint8 numero_fleche, int8 numero_boule)
  414. // 2 PARAMETRES :                            ENTREE                ENTREE
  415. {
  416.     BRect position = Boule(numero_boule);
  417.     position.OffsetBy(m_kTableauDirectionGraphique[numero_fleche]);
  418.     m_TableauFleches[numero_fleche] = position;
  419.     MiseAJourBuffer(position);
  420. }
  421.  
  422.   //////////////////////////////
  423.  // FONCTION "EffacerFleche" //
  424. //////////////////////////////-----------
  425. // Efface l'image d'une fl├¿che         --
  426. // Met ├á jour le buffer de la fen├¬tre  --
  427. //---------------------------------------
  428. void        // AUCUNE VALEUR DE RETOUR
  429. PlateauDeJeuGraphique::EffacerFleche(uint8 numero_fleche)
  430. // 1 PARAMETRE :                            ENTREE
  431. {
  432.     BRect ancienne_position = m_TableauFleches[numero_fleche];
  433.     
  434.     if (ancienne_position != BOULE_CACHEE) {
  435.         m_TableauFleches[numero_fleche] = BOULE_CACHEE;
  436.         MiseAJourBuffer(ancienne_position);
  437.     }
  438. }
  439.  
  440.   ///////////////////////
  441.  // FONCTION "Fleche" //
  442. ///////////////////////------------------------------
  443. // Renvoie les coordonn├⌐es graphiques d'une fl├¿che --
  444. //---------------------------------------------------
  445. BRect        // VALEUR DE RETOUR
  446. PlateauDeJeuGraphique::Fleche(uint8 numero_fleche)
  447. // 1 PARAMETRE :                    ENTREE
  448. {
  449.     return m_TableauFleches[numero_fleche];
  450. }
  451.  
  452.   //////////////////////////////////////////
  453.  // FONCTION "EffacerToutSelectEtFleche" //
  454. //////////////////////////////////////////-------------------------------
  455. // Efface les images de toutes les s├⌐lections et de toutes les fl├¿ches --
  456. //-----------------------------------------------------------------------
  457. void        // AUCUNE VALEUR DE RETOUR
  458. PlateauDeJeuGraphique::EffacerToutSelectEtFleche()
  459. // AUCUN PARAMETRE
  460. {
  461.     int i;
  462.  
  463.     for (i = 0; i < 6; i++)
  464.         EffacerFleche(i);
  465.     for (i = 1; i < 4; i++)
  466.         EffacerSelect(i);
  467. }
  468.  
  469.   //////////////////////////////////////////
  470.  // FONCTION "InitialiserSelectEtFleche" //
  471. //////////////////////////////////////////------------------------------------------------
  472. // Initialise les tableaux de coordonn├⌐es pour les images des s├⌐lections et des fl├¿ches --
  473. //----------------------------------------------------------------------------------------
  474. void        // AUCUNE VALEUR DE RETOUR
  475. PlateauDeJeuGraphique::InitialiserSelectEtFleche()
  476. // AUCUN PARAMETRE
  477. {
  478.     int8 i;
  479.  
  480.     for (i = 0; i < 6; i++)
  481.         m_TableauFleches[i] = BOULE_CACHEE;
  482.     for (i = 0; i < 3; i++)
  483.         m_TableauSelect[i] = BOULE_CACHEE;
  484. }
  485.  
  486.   ///////////////////////////////////
  487.  // FONCTION "DirectionGraphique" //
  488. ///////////////////////////////////---------------------
  489. // Renvoie les coordonn├⌐es graphiques d'une direction --
  490. //------------------------------------------------------
  491. BPoint        // VALEUR DE RETOUR
  492. PlateauDeJeuGraphique::DirectionGraphique(int8 direction)
  493. // 1 PARAMETRE :                                ENTREE
  494. {
  495.     return m_kTableauDirectionGraphique[direction];
  496. }
  497.  
  498.   ///////////////////////////////////////////
  499.  // FONCTION "AfficherBouleCouleurAJouer" //
  500. ///////////////////////////////////////////----------------
  501. // Affiche la boule qui indique le joueur qui doit jouer --
  502. // Met ├á jour le buffer de la fen├¬tre                    --
  503. //---------------------------------------------------------
  504. void        // AUCUNE VALEUR DE RETOUR
  505. PlateauDeJeuGraphique::AfficherBouleCouleurAJouer(int8 couleur, bool pause, bool couronne_de_laurier)
  506. // 1 PARAMETRE :                                    ENTREE            ENTREE            ENTREE
  507. {
  508.     m_Pause = pause;
  509.     m_CouronneDeLaurier = couronne_de_laurier;
  510.     if (m_CouronneDeLaurier == false)
  511.         m_BouleCouleurAJouer = couleur;
  512.     MiseAJourBuffer(RECT_COURONNE_DE_LAURIER);
  513. }
  514.  
  515.   //////////////////////////////////////////
  516.  // FONCTION "EffacerBouleCouleurAJouer" //
  517. //////////////////////////////////////////----------------
  518. // Efface la boule qui indique le joueur qui doit jouer --
  519. // Met ├á jour le buffer de la fen├¬tre                   --
  520. //--------------------------------------------------------
  521. void        // AUCUNE VALEUR DE RETOUR
  522. PlateauDeJeuGraphique::EffacerBouleCouleurAJouer()
  523. // AUCUN PARAMETRE
  524. {
  525.     m_BouleCouleurAJouer = -1;
  526.     MiseAJourBuffer(RECT_BOULE_COULEUR_A_JOUER);
  527. }
  528.  
  529.   ////////////////////////////////////
  530.  // FONCTION "ChangerNombreBoules" //
  531. ////////////////////////////////////----------------------------------
  532. // Change le nombre total de boules et change le tableau de boules  --
  533. //--------------------------------------------------------------------
  534. void        // AUCUNE VALEUR DE RETOUR
  535. PlateauDeJeuGraphique::ChangerNombreBoules(uint8 nombre_boules)
  536. // 1 PARAMETRE :                                ENTREE
  537. {
  538.     if (nombre_boules != m_NombreBoules) {
  539.         PlateauDeJeu::ChangerNombreBoules(nombre_boules);
  540.         if (m_TableauBoules != NULL) {
  541.             delete m_TableauBoules;
  542.             m_TableauBoules = NULL;    // Pas n├⌐cessaire
  543.         }
  544.         m_TableauBoules = new BRect[m_NombreBoules](BOULE_CACHEE);
  545.     }
  546. }
  547.  
  548.   ///////////////////////////////////
  549.  // FONCTION "ChangerTypeJoueurs" //
  550. ///////////////////////////////////---------------------------------------------------------
  551. // Change le tableau des cha├«nes de caract├¿res des joueurs et change (├⌐ventuellement) le  --
  552. // nombre total de joueurs                                                                --
  553. //------------------------------------------------------------------------------------------
  554. void        // AUCUNE VALEUR DE RETOUR
  555. PlateauDeJeuGraphique::ChangerTypeJoueurs(uint8 nombre_joueurs, uint8* tableau_joueurs, uint8* tableau_boules_ejectees)
  556. // 3 PARAMETRES :                                    ENTREE                    ENTREE                    ENTREE
  557. {
  558.     int i;
  559.     char chaine[100];
  560.  
  561.     m_TableauBoulesEjectees = tableau_boules_ejectees;
  562.     if (m_TableauChainesJoueurs != NULL) {
  563.         for (i=0; i < m_NombreJoueurs; i++)
  564.             delete[] m_TableauChainesJoueurs[i];
  565.         delete[] m_TableauChainesJoueurs;
  566.         m_TableauChainesJoueurs = NULL;    // Pas n├⌐cessaire
  567.     }
  568.     if (nombre_joueurs != m_NombreJoueurs)
  569.         PlateauDeJeu::ChangerNombreJoueurs(nombre_joueurs);
  570.     if (tableau_joueurs != NULL) {
  571.         m_TableauChainesJoueurs = new char*[m_NombreJoueurs];
  572.         for (i=0; i < m_NombreJoueurs; i++) {
  573.             if (tableau_joueurs[i] == 0)
  574.                 sprintf(chaine,"%s%d : %s", m_Textes->Texte(32), i+1, m_Textes->Texte(24));
  575.             else
  576.                 sprintf(chaine,"%s%d : %s %s %d", m_Textes->Texte(32), i+1, m_Textes->Texte(25), m_Textes->Texte(29), tableau_joueurs[i]);
  577.             m_TableauChainesJoueurs[i] = new char[strlen(chaine)+1];
  578.             strcpy(m_TableauChainesJoueurs[i], chaine);
  579.         }
  580.         MiseAJourBuffer(RECT_JOUEURS);
  581.     }
  582. }
  583.  
  584.   ////////////////////////////////////
  585.  // FONCTION "ChangerPlateauDeJeu" //
  586. ////////////////////////////////////--------------------------------------------------------
  587. // Change l'image du plateau de jeu                                                       --
  588. //------------------------------------------------------------------------------------------
  589. void        // AUCUNE VALEUR DE RETOUR
  590. PlateauDeJeuGraphique::ChangerPlateauDeJeu(uint8 numero_plateau_de_jeu)
  591. // 1 PARAMETRE :                                    ENTREE
  592. {
  593.     BBitmap* ancien_plateau_de_jeu;
  594.     entry_ref entree_ref;
  595.     uint8 ancien_numero_fichier = m_MenuPlateauDeJeu->NumeroFichier();
  596.  
  597.     ancien_plateau_de_jeu = m_PlateauBitmap;
  598.  
  599.     (m_MenuPlateauDeJeu->SelectionnerFichier(numero_plateau_de_jeu)).GetRef(&entree_ref);
  600.     m_PlateauBitmap = BTranslationUtils::GetBitmap(&entree_ref);
  601.     if (m_PlateauBitmap == NULL) {
  602.         if (ancien_plateau_de_jeu == NULL)
  603.             m_PlateauBitmap = new BBitmap(m_BufferBitmap->Bounds(), B_RGB32, true);
  604.         else
  605.             m_PlateauBitmap = ancien_plateau_de_jeu;
  606.         m_MenuPlateauDeJeu->SelectionnerFichier(ancien_numero_fichier);
  607.     }
  608.     else {
  609.         if (numero_plateau_de_jeu != 0)
  610.             MiseAJourBufferEntier();
  611.         if (ancien_plateau_de_jeu != NULL)
  612.             delete ancien_plateau_de_jeu;
  613.     }
  614. }
  615.  
  616.   ///////////////////////
  617.  // FONCTION "Buffer" //
  618. ///////////////////////--------------------------
  619. // Renvoie le pointeur du buffer de la fen├¬tre --
  620. //-----------------------------------------------
  621. BBitmap*        // VALEUR DE RETOUR
  622. PlateauDeJeuGraphique::Buffer()
  623. // AUCUN PARAMETRE
  624. {
  625.     return m_BufferBitmap;
  626. }
  627.  
  628.   /////////////////////////////////////
  629.  // FONCTION "ConvertirAvecEchelle" //
  630. /////////////////////////////////////--------------------------
  631. // Calcule la taille d'un rectangle en fonction de l'├⌐chelle --
  632. // Renvoie le rectangle convertit                            --
  633. //-------------------------------------------------------------
  634. BRect        // VALEUR DE RETOUR
  635. PlateauDeJeuGraphique::ConvertirAvecEchelle(const BRect& rect)
  636. // 1 PARAMETRE :                                ENTREE (@)
  637. {
  638.     BRect nouv_rect = rect;
  639.  
  640.     nouv_rect.left *= m_Echelle;
  641.     nouv_rect.right *= m_Echelle;
  642.     nouv_rect.top *= m_Echelle;
  643.     nouv_rect.bottom *= m_Echelle;
  644.     return nouv_rect;
  645. }
  646.  
  647.   ////////////////////////////////////////////
  648.  // FONCTION "ConvertirAvecEchelleInverse" //
  649. ////////////////////////////////////////////---------------------
  650. // Calcule les coordonn├⌐es d'un point en fonction de l'├⌐chelle --
  651. // Renvoie les coordonn├⌐es du point convertit                  --
  652. //---------------------------------------------------------------
  653. BPoint        // VALEUR DE RETOUR
  654. PlateauDeJeuGraphique::ConvertirAvecEchelleInverse(const BPoint& position)
  655. // 1 PARAMETRE :                                        ENTREE (@)
  656. {
  657.     BPoint nouv_position = position;
  658.  
  659.     nouv_position.x /= m_Echelle;
  660.     nouv_position.y /= m_Echelle;
  661.     return nouv_position;
  662. }
  663.