home *** CD-ROM | disk | FTP | other *** search
/ Freelog 17 / Freelog017.iso / BeOS / ababelone / Sources / Deplacement.cpp < prev    next >
C/C++ Source or Header  |  2000-11-22  |  23KB  |  587 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 "Deplacement.h"
  20.  
  21.   ///////////////////////////////////
  22.  // CONSTRUCTEUR de "Deplacement" //
  23. ///////////////////////////////////-------------------
  24. // Initialise les variables (et constantes) membres --
  25. //----------------------------------------------------
  26. Deplacement::Deplacement(PlateauDeJeuInterne* plateau_de_jeu_interne, PlateauDeJeuGraphique* plateau_de_jeu_graphique, int8 couleur, bool ordinateur)
  27. // 4 PARAMETRES :            ENTREE/SORTIE (modification par la suite)    ENTREE/SORTIE (modification par la suite)            ENTREE            ENTREE
  28.     : m_kOrdinateur(ordinateur),
  29.         m_CouleurCourante(couleur)
  30. {
  31.     BPath chemin;
  32.     BEntry entree;
  33.     entry_ref entree_ref;
  34.     app_info infos_application;
  35.  
  36.     m_PlateauInterne = plateau_de_jeu_interne;
  37.     m_PlateauGraphique = plateau_de_jeu_graphique;
  38.     m_NombreBoulesSelectionnees = 0;
  39.  
  40.     be_app->GetAppInfo(&infos_application);
  41.     chemin.SetTo(&(infos_application.ref));
  42.     chemin.GetParent(&chemin);
  43.     chemin.SetTo(chemin.Path(), "Sons/Pousser");
  44.     entree.SetTo(chemin.Path());
  45.     entree.GetRef(&entree_ref);
  46.     m_SonPousser = new BFileGameSound(&entree_ref, false);
  47.     if (m_SonPousser->InitCheck() == B_OK)
  48.         m_SonPousser->Preload();
  49.  
  50.     chemin.GetParent(&chemin);
  51.     chemin.SetTo(chemin.Path(), "Tomber");
  52.     entree.SetTo(chemin.Path());
  53.     entree.GetRef(&entree_ref);
  54.     m_SonTomber = new BFileGameSound(&entree_ref, false);
  55.     if (m_SonTomber->InitCheck() == B_OK)
  56.         m_SonTomber->Preload();
  57. }
  58.  
  59.   ///////////////////////////
  60.  // FONCTION "Ordinateur" //
  61. ///////////////////////////------------------------------------------
  62. // Renvoie le type de joueur : ordinateur (true) ou humain (false) --
  63. //-------------------------------------------------------------------
  64. bool        // VALEUR DE RETOUR
  65. Deplacement::Ordinateur()
  66. // AUCUN PARAMETRE
  67. {
  68.     return m_kOrdinateur;
  69. }
  70.  
  71.   /////////////////////////
  72.  // FONCTION "CoupJoue" //
  73. /////////////////////////-----------------------------
  74. // Renvoie toutes les infos concernant le coup jou├⌐ --
  75. //----------------------------------------------------
  76. type_deplacement        // VALEUR DE RETOUR
  77. Deplacement::CoupJoue()
  78. // AUCUN PARAMETRE
  79. {
  80.     return m_CoupJoue;
  81. }
  82.  
  83.   ///////////////////////////////////
  84.  // FONCTION "JouerCoupPrecedent" //
  85. ///////////////////////////////////----------------------------------
  86. // Joue le coup pr├⌐c├⌐dent (avec ou sans une mise ├á jour graphique) --
  87. //-------------------------------------------------------------------
  88. void        // AUCUNE VALEUR DE RETOUR
  89. Deplacement::JouerCoupPrecedent(type_deplacement coup_joue, bool mise_a_jour_buffer_ecran)
  90. // 2 PARAMETRES :                        ENTREE                            ENTREE
  91. {
  92.     BPoint delta;
  93.     BRect rect_mis_a_jour;
  94.     int8 boule;
  95.     int8 boule_actuelle;
  96.     int i;
  97.     int max = coup_joue.NombreBoulesADeplacer;
  98.     int8 direction_boule_suivante;
  99.     Coordonnees coord_boule;
  100.     BRect position_boule;
  101.  
  102.     m_PremiereBouleSelectionnee = coup_joue.PremiereBouleSelectionnee;
  103.     m_Direction = (coup_joue.Direction+3)%6;
  104.     m_DirectionLaterale = coup_joue.DirectionLaterale;
  105.  
  106.     delta = m_PlateauGraphique->DirectionGraphique(m_Direction);
  107.     if (m_DirectionLaterale < 0) {
  108.         m_NombreBoulesSelectionnees = 1;
  109.         direction_boule_suivante = coup_joue.Direction;
  110.         if (coup_joue.BouleEjectee != 0)
  111.             max--;
  112.     }
  113.     else {
  114.         m_NombreBoulesSelectionnees = coup_joue.NombreBoulesADeplacer;
  115.         direction_boule_suivante = coup_joue.DirectionLaterale;
  116.     }
  117.  
  118.     boule = m_PremiereBouleSelectionnee;
  119.     for (i = 0; i < max; i++) {
  120.         if (coup_joue.BouleEjectee != 0 && i == (max-1)) {
  121.             coord_boule = m_PlateauInterne->CoordonneesBoule(boule);
  122.             position_boule = m_PlateauGraphique->Boule(boule);
  123.         }
  124.         rect_mis_a_jour = m_PlateauGraphique->DeplacerBoule(boule, delta.x, delta.y);
  125.         if (mise_a_jour_buffer_ecran == true)
  126.             m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  127.         boule_actuelle = boule;
  128.         boule = m_PlateauInterne->ValeurCaseSuivante(boule,direction_boule_suivante);    // Se positionner sur la case suivante
  129.         m_PlateauInterne->DeplacerBoule(boule_actuelle, m_Direction);    // D├⌐placer la boule dans le tableau interne
  130.     }
  131.     if (coup_joue.BouleEjectee != 0) {
  132.         rect_mis_a_jour = m_PlateauGraphique->Boule(coup_joue.BouleEjectee);
  133.         m_PlateauGraphique->SetBoule(coup_joue.BouleEjectee, position_boule);
  134.         if (mise_a_jour_buffer_ecran == true) {
  135.             m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  136.             m_PlateauGraphique->MiseAJourBuffer(position_boule);
  137.         }
  138.         m_PlateauInterne->SetCase(coord_boule, coup_joue.BouleEjectee);
  139.         m_PlateauInterne->DecrementerBoulesEjectees(m_CouleurCourante);
  140.         if (mise_a_jour_buffer_ecran == true)
  141.             m_PlateauGraphique->MiseAJourBuffer(RECT_SCORE);
  142.     }
  143.  
  144.     m_NombreBoulesSelectionnees = 0;
  145. }
  146.  
  147.   //////////////////////////
  148.  // FONCTION "JouerCoup" //
  149. //////////////////////////------------------------------------
  150. // Rejoue un coup jou├⌐, avec un d├⌐placement r├⌐aliste ou non --
  151. // (avec ou sans une mise ├á jour graphique)                 --
  152. //------------------------------------------------------------
  153. void        // AUCUNE VALEUR DE RETOUR
  154. Deplacement::JouerCoup(type_deplacement coup_joue, bool faire_glisser_les_boules, bool mise_a_jour_buffer_ecran)
  155. // 3 PARAMETRES :                ENTREE                        ENTREE                            ENTREE
  156. {
  157.     m_PremiereBouleSelectionnee = coup_joue.PremiereBouleSelectionnee;
  158.     m_Direction = coup_joue.Direction;
  159.     m_DirectionLaterale = coup_joue.DirectionLaterale;
  160.     if (m_DirectionLaterale < 0) {
  161.         m_NombreBoulesSelectionnees = 1;
  162.         DeplacerBoulesPoussee(faire_glisser_les_boules, mise_a_jour_buffer_ecran);
  163.     }
  164.     else {
  165.         m_NombreBoulesSelectionnees = coup_joue.NombreBoulesADeplacer;
  166.         DeplacerBoulesLaterales(faire_glisser_les_boules, mise_a_jour_buffer_ecran);
  167.     }
  168.     m_NombreBoulesSelectionnees = 0;
  169. }
  170.  
  171.   ///////////////////////////////////
  172.  // FONCTION "RangerBouleEjectee" //
  173. ///////////////////////////////////-----------------------------------------------------------------------------
  174. // Range les boules ├⌐ject├⌐es, d'une fa├ºon r├⌐aliste : la boule ├⌐ject├⌐e fait le tour du plateau et va se placer --
  175. // dans la goulotte du joueur qui l'a ├⌐ject├⌐e                                                                 --
  176. //--------------------------------------------------------------------------------------------------------------
  177. void        // AUCUNE VALEUR DE RETOUR
  178. Deplacement::RangerBouleEjectee(int8 numero_boule)
  179. // 1 PARAMETRE                         ENTREE
  180. {
  181.     int8 direction_cote;
  182.     Coordonnees coord_boule = m_PlateauInterne->CoordonneesBoule(numero_boule);
  183.     int8 i, j, k, debut;
  184.     BPoint position_boule;
  185.     BPoint position_temp;
  186.     BRect rect_mis_a_jour;
  187.     bigtime_t temps;
  188.  
  189.     position_boule = m_PlateauGraphique->Boule(numero_boule).LeftTop();
  190.     coord_boule = m_PlateauInterne->CoordonneesSuivantes(coord_boule, m_Direction);
  191.  
  192.     if (coord_boule.y == 0) {
  193.         debut = 5-(coord_boule.x-5);
  194.         direction_cote = 0;
  195.     }
  196.     else
  197.          if (coord_boule.y == 10) {
  198.             debut = coord_boule.x;
  199.             direction_cote = 3;
  200.         }
  201.         else {
  202.             debut = coord_boule.y;
  203.             if (coord_boule.y > 5) {
  204.                 debut -= 5;
  205.                 direction_cote = 2;
  206.             }
  207.             else
  208.                 direction_cote = 1;
  209.             if (coord_boule.x > 5)
  210.                 debut = 5-debut;
  211.             else
  212.                 direction_cote = 6 - direction_cote;
  213.         }
  214.     if (m_Direction == (direction_cote + 1)%6)
  215.         debut++;
  216.     for(i=direction_cote; i > -2; i--) {
  217.         if (i > -1) {
  218.             position_temp = m_PlateauGraphique->DirectionGraphique(i);
  219.             if (i == 0)
  220.                 debut += m_CouleurCourante - 7;
  221.         }
  222.         else {
  223.             debut = m_PlateauInterne->BoulesEjectees(m_CouleurCourante);
  224.             position_temp.x = 0;
  225.             position_temp.y = HAUTEUR_CASE_BOULE+1;
  226.         }
  227.         for(j=debut; j < 6; j++)
  228.             for(k=0; k < 10; k++) {
  229.                 temps = system_time();
  230.                 position_boule.x += position_temp.x/10;
  231.                 position_boule.y += position_temp.y/10;
  232.                 // D├⌐placer les vues "Boule" (graphiquement)
  233.                 rect_mis_a_jour = m_PlateauGraphique->SetPositionBoule(numero_boule, position_boule);
  234.                 m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  235.                 while ((system_time() - temps) < DELAI_POUR_POUSSER );
  236.             }
  237.         debut = 0;
  238.     }
  239. }
  240.  
  241.   /////////////////////////////////////////
  242.  // FONCTION "DirectionPousseePossible" //
  243. /////////////////////////////////////////-------------------------------------------------------------------
  244. // Renvoie "vrai" si une pouss├⌐e est possible dans une direction.                                         --
  245. // Renseigne aussi ├⌐ventuellement sur le nombre de boules qui doivent ├¬tre pouss├⌐es (les boules du joueur --
  246. // courant et les boules adverses                                                                         --
  247. //----------------------------------------------------------------------------------------------------------
  248. bool        // VALEUR DE RETOUR
  249. Deplacement::DirectionPousseePossible(int8 direction, int8* ptr_nombre_boules_joueur, int8* ptr_nombre_boules_adversaire)
  250. // 3 PARAMETRES :                            ENTREE            (ENTREE)/SORTIE                        (ENTREE)/SORTIE
  251. {
  252.     // Cr├⌐ation et initialisation ├⌐ventuelle des variables locales
  253.     int8 i, nb_cases_meme_couleur, nb_cases_couleur_opposee;
  254.     bool direction_possible = true;
  255.     int8 numero_boule = m_PremiereBouleSelectionnee;
  256.  
  257.     // Boucle pour d├⌐terminer le nombre de boules de la couleur du joueur
  258.     for (i = 0; i < 4 && numero_boule > 0 && m_PlateauInterne->CouleurBoule(numero_boule) == m_CouleurCourante; i++) {
  259.         numero_boule = m_PlateauInterne->ValeurCaseSuivante(numero_boule,direction);    // Se positionner sur la case suivante
  260.     }
  261.     if (ptr_nombre_boules_joueur != NULL)
  262.         *ptr_nombre_boules_joueur = i;
  263.     if (i > 3)        // Si le joueur veut pousser plus de 3 boules,
  264.         direction_possible = false;        // le d├⌐placement est impossible
  265.     else {
  266.         nb_cases_meme_couleur = i;    // Nombre de cases de la couleur du joueur
  267.         // Boucle pour d├⌐terminer le nombre de boules de la couleur de l'adversaire
  268.         for (i = 0; i < 3 && numero_boule > 0 && m_PlateauInterne->CouleurBoule(numero_boule) != m_CouleurCourante; i++) {
  269.             numero_boule = m_PlateauInterne->ValeurCaseSuivante(numero_boule,direction);    // Se positionner sur la case suivante
  270.         }
  271.         nb_cases_couleur_opposee = i;    // Nombre de cases de la couleur de l'adversaire
  272.         if (ptr_nombre_boules_adversaire != NULL)
  273.             *ptr_nombre_boules_adversaire = nb_cases_couleur_opposee;
  274.         // Si le joueur veut pousser plus de 2 boules adverses OU s'il n'a pas la sup├⌐riorit├⌐ num├⌐rique,
  275.         if (i > 2 || nb_cases_couleur_opposee >= nb_cases_meme_couleur)
  276.             direction_possible = false;        // le d├⌐placement est impossible
  277.         else
  278.             if (numero_boule == -1) {    // Si la prochaine case est une case hors du plateau de jeu,
  279.                 if (nb_cases_couleur_opposee == 0)    // et s'il n'y a aucune boule adverse ├á pousser
  280.                     direction_possible = false;            // le d├⌐placement est impossible
  281.             }
  282.             else    // Si la prochaine case est une case dans le plateau de jeu,
  283.                 if (numero_boule != 0)    // et si cette case n'est pas une case vide
  284.                     direction_possible = false;        // le d├⌐placement est impossible
  285.     }
  286.     return direction_possible;
  287. }
  288.  
  289.   /////////////////////////////////////////////
  290.  // FONCTION "FaireGlisserLesBoulesPoussee" //
  291. /////////////////////////////////////////////----------------------------------------------------------------
  292. // Fait "glisser" les boules pour un d├⌐placement en pouss├⌐e, c'est-├á-dire d├⌐place graphiquement les boules --
  293. // d'une fa├ºon r├⌐aliste                                                                                    --
  294. //-----------------------------------------------------------------------------------------------------------
  295. void        // AUCUNE VALEUR DE RETOUR
  296. Deplacement::FaireGlisserLesBoulesPoussee(int8 nombre_de_boules_a_deplacer, bool ejection)
  297. // 2 PARAMETRES :                                        ENTREE                    ENTREE
  298. {
  299.     // Cr├⌐ation et initialisation ├⌐ventuelle des variables locales
  300.     float coef_dir = LARGEUR_CASE_BOULE / (2.0 * HAUTEUR_CASE_BOULE);
  301.     int delta_x;
  302.     int delta_y;
  303.     BPoint delta = m_PlateauGraphique->DirectionGraphique(m_Direction);
  304.     int i, j, compteur_max, translation;
  305.     int distance_entre_boules;
  306.     int8 nombre_de_boules_en_deplacement = 1;
  307.     bigtime_t temps;
  308.     int8 boule;
  309.     BPoint position_boule;
  310.     BRect rect_mis_a_jour;
  311.  
  312.     delta_x = (int)delta.x;
  313.     delta_y = (int)delta.y;
  314.  
  315.     position_boule = m_PlateauGraphique->Boule(m_PremiereBouleSelectionnee).LeftTop();
  316.  
  317.     if (delta_y == 0) {
  318.         compteur_max = abs(delta_x);
  319.         distance_entre_boules = LARGEUR_ENTRE_BOULES;
  320.     }
  321.     else {
  322.         compteur_max = abs(delta_y);
  323.         delta_y /= abs(delta_y);
  324.         distance_entre_boules = OBLIQUE_HAUTEUR_ENTRE_BOULES;
  325.     }
  326.     delta_x /= abs(delta_x);
  327.     for (i = 1; i < 3*compteur_max/4; i++) {
  328.         temps = system_time();
  329.         boule = m_PremiereBouleSelectionnee;
  330.         for (j = 0; j < nombre_de_boules_en_deplacement; j++) {
  331.             if (delta_y == 0 || (int(coef_dir*(i-1)) != int(coef_dir*i)))
  332.                 translation = 1;
  333.             else
  334.                 translation = 0;
  335.             // D├⌐placer les vues "Boule" (graphiquement)
  336.             rect_mis_a_jour = m_PlateauGraphique->DeplacerBoule(boule, delta_x*translation, delta_y);
  337.             
  338.             m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  339.  
  340.             boule = m_PlateauInterne->ValeurCaseSuivante(boule,m_Direction);    // Se positionner sur la case suivante
  341.  
  342.         }
  343.         while ((system_time() - temps) < DELAI_POUR_POUSSER );
  344.         if (i % distance_entre_boules == 0
  345.                 && nombre_de_boules_en_deplacement < nombre_de_boules_a_deplacer) {
  346.             nombre_de_boules_en_deplacement++;
  347.             if (m_SonPousser->InitCheck() == B_OK)
  348.                 m_SonPousser->StartPlaying();
  349.         } 
  350.     }
  351.  
  352.     boule = m_PremiereBouleSelectionnee;
  353.     for (j = 0; j < nombre_de_boules_en_deplacement; j++) {
  354.         position_boule += m_PlateauGraphique->DirectionGraphique(m_Direction);
  355.         if (j == (nombre_de_boules_en_deplacement-1) && ejection == true) {
  356.             position_boule += m_PlateauGraphique->DirectionGraphique(m_Direction);
  357. //            m_PlateauGraphique->SetBouleInvisible(boule);    // Cacher la boule qui est ├⌐ject├⌐e
  358.         }
  359.         // D├⌐placer les vues "Boule" (graphiquement)
  360.         rect_mis_a_jour = m_PlateauGraphique->SetPositionBoule(boule, position_boule);
  361.  
  362.         m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  363.         if (j != (nombre_de_boules_en_deplacement-1))
  364.             boule = m_PlateauInterne->ValeurCaseSuivante(boule,m_Direction);    // Se positionner sur la case suivante
  365.     }
  366.     if (m_SonTomber->InitCheck() == B_OK)
  367.         m_SonTomber->StartPlaying();
  368. }
  369.  
  370.   //////////////////////////////////////
  371.  // FONCTION "DeplacerBoulesPoussee" //
  372. //////////////////////////////////////-----------------
  373. // D├⌐place les boules pour un d├⌐placement en pouss├⌐e --
  374. // (avec ou sans une mise ├á jour graphique)          --
  375. //-----------------------------------------------------
  376. bool        // VALEUR DE RETOUR
  377. Deplacement::DeplacerBoulesPoussee(bool faire_glisser_les_boules, bool mise_a_jour_buffer_ecran)
  378. // 2 PARAMETRES :                                ENTREE                        ENTREE
  379. {
  380.     // Cr├⌐ation et initialisation ├⌐ventuelle des variables locales
  381.     int8 i;
  382.     int8 nombre_de_cases_a_pousser;
  383.     bool case_vide = false;
  384.     bool ejection = false;
  385.     int8 boule = m_PremiereBouleSelectionnee;
  386.     int8 boule_precedente = m_PremiereBouleSelectionnee;
  387.     BPoint delta = m_PlateauGraphique->DirectionGraphique(m_Direction);
  388.     BPoint position;
  389.     BRect rect_mis_a_jour;
  390.     int8 boules_ejectees;
  391.  
  392.     // Calculer le nombre de boules ├á pousser
  393.     //  et d├⌐terminer s'il y a une ├⌐jection 
  394.     for (i = 0; i < 5 && case_vide == false; i++) {
  395.         boule_precedente = boule;
  396.         // Se positionner sur la case suivante
  397.         boule = m_PlateauInterne->ValeurCaseSuivante(boule,m_Direction);
  398.         // Si on arrive ├á une case vide OU hors du plateau de jeu,
  399.         if (boule < 1) {
  400.             case_vide = true;            // on arr├¬te la boucle
  401.             if (boule == -1)    // Si on arrive au bord du plateau
  402.                 ejection = true;                //  de jeu, il y a une ├⌐jection
  403.         }
  404.     }
  405.     nombre_de_cases_a_pousser = i;
  406.  
  407.     m_CoupJoue.PremiereBouleSelectionnee = m_PremiereBouleSelectionnee;
  408.     m_CoupJoue.NombreBoulesADeplacer = nombre_de_cases_a_pousser;
  409.     m_CoupJoue.Direction = m_Direction;
  410.     m_CoupJoue.DirectionLaterale = -1;
  411.  
  412.     // D├⌐placer toutes les boules ├á pousser
  413.     if (faire_glisser_les_boules == true)
  414.         FaireGlisserLesBoulesPoussee(nombre_de_cases_a_pousser, ejection);
  415.  
  416.     boule = boule_precedente;
  417.     if (ejection == true) {
  418.         if (faire_glisser_les_boules == true)
  419.             RangerBouleEjectee(boule);
  420.         else {
  421.             boules_ejectees = m_PlateauInterne->BoulesEjectees(m_CouleurCourante);
  422.             rect_mis_a_jour = m_PlateauGraphique->Boule(boule);
  423.             position = m_PlateauGraphique->DirectionGraphique(1);
  424.             position.x = 2*position.x + ORIGINE_X - LARGEUR_CASE_BOULE * (5-m_CouleurCourante);
  425.             position.y = 2*position.y + ORIGINE_Y + (HAUTEUR_CASE_BOULE+1) * (6-boules_ejectees);
  426.             m_PlateauGraphique->SetPositionBoule(boule, position);
  427.             if (mise_a_jour_buffer_ecran == true)
  428.                 m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  429.             rect_mis_a_jour = m_PlateauGraphique->Boule(boule);
  430.             if (mise_a_jour_buffer_ecran == true)
  431.                 m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  432.         }
  433.         m_CoupJoue.BouleEjectee = boule;
  434.     }
  435.     else
  436.         m_CoupJoue.BouleEjectee = 0;
  437.     for (i = 0; i < nombre_de_cases_a_pousser; i++) {
  438.         boule_precedente = m_PlateauInterne->ValeurCasePrecedente(boule,m_Direction);    // Se positionner sur la case pr├⌐c├⌐dente
  439.         m_PlateauInterne->DeplacerBoule(boule, m_Direction);    // D├⌐placer la boule dans le tableau interne
  440.         if (faire_glisser_les_boules == false) {
  441.             if (!(i == 0 && ejection == true)) {
  442.                 rect_mis_a_jour = m_PlateauGraphique->DeplacerBoule(boule, delta.x, delta.y);
  443.                 if (mise_a_jour_buffer_ecran == true)
  444.                     m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  445.             }
  446.         }
  447.         boule = boule_precedente;
  448.     }
  449.     if (ejection == true) {
  450.         m_PlateauInterne->IncrementerBoulesEjectees(m_CouleurCourante);
  451.         if (mise_a_jour_buffer_ecran == true)
  452.             m_PlateauGraphique->MiseAJourBuffer(RECT_SCORE);
  453.     }
  454.     return ejection;
  455. }
  456.  
  457.   //////////////////////////////////////////
  458.  // FONCTION "DirectionLateralePossible" //
  459. //////////////////////////////////////////----------------------------------------------------------
  460. // Renvoie "vrai" si un d├⌐placement lat├⌐ral est possible dans une direction.                      --
  461. // Renseigne aussi ├⌐ventuellement sur le nombre de boules qui doivent ├¬tre d├⌐plac├⌐es lat├⌐ralement --
  462. //--------------------------------------------------------------------------------------------------
  463. bool        // VALEUR DE RETOUR
  464. Deplacement::DirectionLateralePossible(int8 direction, bool* ptr_deplacement_avec_2_boules)
  465. // 2 PARAMETRES :                            ENTREE                (ENTREE)/SORTIE
  466. {
  467.     // Cr├⌐ation et initialisation ├⌐ventuelle des variables locales
  468.     bool possible = true;
  469.     int8 i;
  470.     int8 boule;
  471.  
  472.     boule = m_PremiereBouleSelectionnee;
  473.     for (i = 0; i < m_NombreBoulesSelectionnees && possible == true; i++) {
  474.         possible = (m_PlateauInterne->ValeurCaseSuivante(boule,direction) == 0);
  475.         boule = m_PlateauInterne->ValeurCaseSuivante(boule,m_DirectionLaterale);    // Se positionner sur la case suivante
  476.     }
  477.     if (ptr_deplacement_avec_2_boules != NULL)
  478.         *ptr_deplacement_avec_2_boules = (i == 3);
  479.     return possible;
  480. }
  481.  
  482.   ///////////////////////////////////////////////
  483.  // FONCTION "FaireGlisserLesBoulesLaterales" //
  484. ///////////////////////////////////////////////-----------------------------------------------------------
  485. // Fait "glisser" les boules pour un d├⌐placement lat├⌐ral, c'est-├á-dire d├⌐place graphiquement les boules --
  486. // d'une fa├ºon r├⌐aliste                                                                                 --
  487. //--------------------------------------------------------------------------------------------------------
  488. void        // AUCUNE VALEUR DE RETOUR
  489. Deplacement::FaireGlisserLesBoulesLaterales()
  490. // AUCUN PARAMETRE
  491. {
  492.     // Cr├⌐ation et initialisation ├⌐ventuelle des variables locales
  493.     float coef_dir = LARGEUR_CASE_BOULE / (2.0 * HAUTEUR_CASE_BOULE);
  494.     int delta_x;
  495.     int delta_y;
  496.     BPoint delta = m_PlateauGraphique->DirectionGraphique(m_Direction);
  497.     int i, compteur_max, translation;
  498.     int8 j;
  499.     int nbre_delta_x = 0;
  500.     bigtime_t temps;
  501.     BRect rect_mis_a_jour;
  502.     int8 boule;
  503.  
  504.     delta_x = (int)delta.x;
  505.     delta_y = (int)delta.y;
  506.  
  507.     if (delta_y == 0)
  508.         compteur_max = abs(delta_x);
  509.     else {
  510.         compteur_max = abs(delta_y);
  511.         delta_y /= abs(delta_y);
  512.     }
  513.     delta_x /= abs(delta_x);
  514.     for (i = 1; i < 3*compteur_max/4; i++) {
  515.         temps = system_time();
  516.         if (delta_y == 0 || (int(coef_dir*(i-1)) != int(coef_dir*i))) {
  517.             translation = 1;
  518.             nbre_delta_x++;
  519.         }
  520.         else
  521.             translation = 0;
  522.         // D├⌐placer les vues "Boule" (graphiquement)
  523.         boule = m_PremiereBouleSelectionnee;
  524.         for (j = 0; j < m_NombreBoulesSelectionnees; j++) {
  525.             rect_mis_a_jour = m_PlateauGraphique->DeplacerBoule(boule, delta_x*translation, delta_y);
  526.             m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  527.             boule = m_PlateauInterne->ValeurCaseSuivante(boule,m_DirectionLaterale);    // Se positionner sur la case suivante
  528.         }
  529.         while ((system_time() - temps) < DELAI_POUR_POUSSER );
  530.     }
  531.  
  532.     if (delta_y != 0)
  533.         coef_dir = 2;
  534.     else
  535.         coef_dir = 1;
  536.     delta_x *= (int)(LARGEUR_CASE_BOULE/coef_dir) - nbre_delta_x;
  537.     delta_y *= compteur_max - (3*compteur_max/4)+1;
  538.     // D├⌐placer les vues "Boule" (graphiquement)
  539.     boule = m_PremiereBouleSelectionnee;
  540.     for (j = 0; j < m_NombreBoulesSelectionnees; j++) {
  541.         rect_mis_a_jour = m_PlateauGraphique->DeplacerBoule(boule, delta_x, delta_y);
  542.         m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  543.         boule = m_PlateauInterne->ValeurCaseSuivante(boule,m_DirectionLaterale);    // Se positionner sur la case suivante
  544.     }
  545.     if (m_SonTomber->InitCheck() == B_OK)
  546.         m_SonTomber->StartPlaying();
  547. }
  548.  
  549.   ////////////////////////////////////////
  550.  // FONCTION "DeplacerBoulesLaterales" //
  551. ////////////////////////////////////////------------
  552. // D├⌐place les boules pour un d├⌐placement lateral --
  553. // (avec ou sans une mise ├á jour graphique)       --
  554. //--------------------------------------------------
  555. void        // AUCUNE VALEUR DE RETOUR
  556. Deplacement::DeplacerBoulesLaterales(bool faire_glisser_les_boules, bool mise_a_jour_buffer_ecran)
  557. // 2 PARAMETRES :                                ENTREE                            ENTREE
  558. {
  559.     // Cr├⌐ation et initialisation ├⌐ventuelle des variables locales
  560.     int8 i;
  561.     int8 boule;
  562.     int8 boule_suivante;
  563.     BPoint delta = m_PlateauGraphique->DirectionGraphique(m_Direction);
  564.     BRect rect_mis_a_jour;
  565.  
  566.     m_CoupJoue.PremiereBouleSelectionnee = m_PremiereBouleSelectionnee;
  567.     m_CoupJoue.NombreBoulesADeplacer = m_NombreBoulesSelectionnees;
  568.     m_CoupJoue.Direction = m_Direction;
  569.     m_CoupJoue.DirectionLaterale = m_DirectionLaterale;
  570.     m_CoupJoue.BouleEjectee = 0;
  571.  
  572.     if (faire_glisser_les_boules == true)
  573.         FaireGlisserLesBoulesLaterales();
  574.  
  575.     boule = m_PremiereBouleSelectionnee;
  576.     for (i = 0; i < m_NombreBoulesSelectionnees; i++) {
  577.         boule_suivante = m_PlateauInterne->ValeurCaseSuivante(boule,m_DirectionLaterale);    // Se positionner sur la case suivante
  578.         m_PlateauInterne->DeplacerBoule(boule, m_Direction);    // D├⌐placer la boule dans le tableau interne
  579.         if (faire_glisser_les_boules == false) {
  580.             rect_mis_a_jour = m_PlateauGraphique->DeplacerBoule(boule, delta.x, delta.y);
  581.             if (mise_a_jour_buffer_ecran == true)
  582.                 m_PlateauGraphique->MiseAJourBuffer(rect_mis_a_jour);
  583.         }
  584.         boule = boule_suivante;
  585.     }
  586. }
  587.