home *** CD-ROM | disk | FTP | other *** search
/ Freelog 17 / Freelog017.iso / BeOS / ababelone / Sources / FenetreAbabelone.cpp < prev    next >
C/C++ Source or Header  |  2000-11-22  |  38KB  |  1,056 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 "FenetreAbabelone.h"
  20.  
  21.   ////////////////////////////////////////
  22.  // CONSTRUCTEUR de "FenetreAbabelone" //
  23. ////////////////////////////////////////---------------------------------------------------------------------------
  24. // Construit les objects et met ├á jour toutes les variables membres. Affiche aussi toutes les vues de la fen├¬tre --
  25. //-----------------------------------------------------------------------------------------------------------------
  26. FenetreAbabelone::FenetreAbabelone()
  27. // AUCUN PARAMETRE
  28.     : BWindow(BRect(0,24,0,24), VERSION_ABABELONE,B_TITLED_WINDOW,B_NORMAL_WINDOW_FEEL | B_NOT_V_RESIZABLE | B_OUTLINE_RESIZE /*| B_NOT_ZOOMABLE*/)
  29. {
  30.     BDirectory repertoire;
  31.     BPath chemin;
  32.     BEntry entree;
  33.     BRect rect;
  34.     int i;
  35.     uint8 langue = 1;
  36.     uint8 plateau_de_jeu = 1;
  37.  
  38.     m_AffichageAPropos = true;
  39.     m_NombreJoueurs = 2;
  40.     m_DeplacementRealiste = true;
  41.     m_TableauJoueurs = new uint8[NOMBRE_JOUEURS_MAXI];
  42.     m_TableauDeplacementJoueurs = new (Deplacement*)[NOMBRE_JOUEURS_MAXI];
  43.     m_JoueurCourant = 0;
  44.     for (i=0; i < NOMBRE_JOUEURS_MAXI; i++) {
  45.         m_TableauJoueurs[i] = 0;
  46.         m_TableauDeplacementJoueurs[i] = NULL;
  47.     }
  48.  
  49.     m_FichierPreferences = NULL;
  50.     find_directory(B_USER_SETTINGS_DIRECTORY, &chemin, true);
  51.     chemin.Append(REPERTOIRE_FICHIER_PREFERENCES);
  52.     repertoire.CreateDirectory(chemin.Path(), &repertoire);
  53.     repertoire.SetTo(chemin.Path());
  54.     if (repertoire.FindEntry(FICHIER_PREFERENCES, &entree) == B_NO_ERROR) {
  55.         m_FichierPreferences = new BFile(&entree, O_RDWR);
  56.         if (m_FichierPreferences->InitCheck() == B_NO_ERROR) {
  57.             m_FichierPreferences->Seek(0, 0);
  58.             m_FichierPreferences->Read(&m_NombreJoueurs, sizeof(uint8));
  59.             for (i=0; i < NOMBRE_JOUEURS_MAXI; i++)
  60.                 m_FichierPreferences->Read(&(m_TableauJoueurs[i]), sizeof(uint8));
  61.             m_FichierPreferences->Read(&m_DeplacementRealiste, sizeof(bool));
  62.             m_FichierPreferences->Read(&langue, sizeof(uint8));
  63.             m_FichierPreferences->Read(&plateau_de_jeu, sizeof(uint8));
  64.             m_FichierPreferences->ReadAttr("AfficherFen├¬treAuD├⌐but", B_BOOL_TYPE, 0, &m_AffichageAPropos, sizeof(bool));
  65.         }
  66.     }
  67.     else {
  68.         m_FichierPreferences = new BFile();
  69.         if (repertoire.CreateFile(FICHIER_PREFERENCES, m_FichierPreferences) != B_NO_ERROR) {
  70.             delete m_FichierPreferences;
  71.             m_FichierPreferences = NULL;
  72.         }
  73.     }
  74.  
  75.     chemin.Append(REPERTOIRE_PARTIES);
  76.     repertoire.CreateDirectory(chemin.Path(), &repertoire);
  77.  
  78.     // Initialisation des variables membre
  79.     m_Debut = true;
  80.     m_Textes = new TextesDuLogiciel;
  81.  
  82.     m_PartieTerminee = false;
  83.     m_PartieInterrompue = true;
  84.     m_PartieInterrompueTemporairement = false;
  85.  
  86.     m_NombreBoules = 0;
  87.  
  88.  
  89.     m_SemaphoreThread = create_sem(1, "SemaphoreThread");
  90.     m_MessagePourFenetre = new BMessage;
  91.  
  92.     m_ListeCoupsJoues = new BList;
  93.     m_ListeCoupsJoues->MakeEmpty();
  94.     m_NumeroCoupJoueCourant = 0;
  95.  
  96.  
  97.     m_ChargerFichier = new BFilePanel(B_OPEN_PANEL);
  98.     m_ChargerFichier->SetPanelDirectory(chemin.Path());
  99.     m_ChargerFichier->SetTarget(this);
  100.  
  101.     m_SauvegarderFichier = new BFilePanel(B_SAVE_PANEL);
  102.     m_SauvegarderFichier->SetPanelDirectory(chemin.Path());
  103.     m_SauvegarderFichier->SetTarget(this);
  104.  
  105.     CreerMenu(langue, plateau_de_jeu);    // Cr├⌐er le menu d├⌐roulant
  106.  
  107.     SetSizeLimits(275,LARGEUR_PLATEAU-1,200,HAUTEUR_PLATEAU-1+20);
  108.     Zoom();
  109.     rect = Bounds();
  110.     // Cr├⌐er l'objet "PlateauDeJeu" et lier la vue "Plateau" ├á la fen├¬tre
  111.     m_PlateauInterne = new PlateauDeJeuInterne(m_NombreBoules, m_NombreJoueurs);
  112.     m_PlateauGraphique = new PlateauDeJeuGraphique(BRect(0,20,LARGEUR_PLATEAU-1,HAUTEUR_PLATEAU-1+20), "PlateauDeJeuGraphique", m_Textes, m_MenuPlateauDeJeu, m_NombreBoules, m_NombreJoueurs);
  113.     AddChild(m_PlateauGraphique);
  114. //    m_PlateauGraphique->MiseAJourBufferEntier();    // Inutile car fait dans le FrameResized (appel├⌐ par Zoom)
  115.  
  116.     // Afficher la fen├¬tre
  117.     Show();
  118.     if (m_AffichageAPropos == true)
  119.         APropos();
  120. }
  121.  
  122.  
  123.   ///////////////////////////////////////
  124.  // DESTRUCTEUR de "FenetreAbabelone" //
  125. ///////////////////////////////////////-------------
  126. // D├⌐truit les objects cr├⌐├⌐s dans le constructeur --
  127. //--------------------------------------------------
  128. FenetreAbabelone::~FenetreAbabelone()
  129. // AUCUN PARAMETRE
  130. {
  131.     // D├⌐lier de la fen├¬tre la vue "Plateau"
  132.     RemoveChild(m_PlateauGraphique);
  133.     // D├⌐truire l'objet "PlateauDeJeu"
  134.     delete m_PlateauInterne;
  135.     delete m_PlateauGraphique;
  136.     if (m_FichierPreferences != NULL)
  137.         delete m_FichierPreferences;
  138.  
  139. }
  140.  
  141.   //////////////////////////////
  142.  // FONCTION "QuitRequested" //
  143. //////////////////////////////------
  144. // L'utilisateur ferme la fen├¬tre --
  145. //----------------------------------
  146. bool        // VALEUR DE RETOUR
  147. FenetreAbabelone::QuitRequested()
  148. // AUCUN PARAMETRE
  149. {
  150.     int i;
  151.     uint8 langue = m_MenuLangue->NumeroFichier();
  152.     uint8 plateau_de_jeu = m_MenuPlateauDeJeu->NumeroFichier();
  153.  
  154. //    if (m_PartieInterrompue == false)
  155. //        InterromprePartie();
  156.     if (m_FichierPreferences != NULL) {
  157.         m_FichierPreferences->Seek(0, 0);
  158.         m_FichierPreferences->Write(&m_NombreJoueurs, sizeof(uint8));
  159.         for (i=0; i < NOMBRE_JOUEURS_MAXI; i++)
  160.             m_FichierPreferences->Write(&(m_TableauJoueurs[i]), sizeof(uint8));
  161.         m_FichierPreferences->Write(&m_DeplacementRealiste, sizeof(bool));
  162.         m_FichierPreferences->Write(&langue, sizeof(uint8));
  163.         m_FichierPreferences->Write(&plateau_de_jeu, sizeof(uint8));
  164.         m_FichierPreferences->WriteAttr("AfficherFen├¬treAuD├⌐but", B_BOOL_TYPE, 0, &m_AffichageAPropos, sizeof(bool));
  165.     }
  166.     be_app->PostMessage(B_QUIT_REQUESTED);
  167.     return true;//BWindow::QuitRequested();        // ou "return true;"
  168. }
  169.  
  170.   /////////////////////////////
  171.  // FONCTION "FrameResized" //
  172. /////////////////////////////--------------------------------------------
  173. // Change la taille de la fen├¬tre et la r├⌐actualise ├á la bonne ├⌐chelle --
  174. //-----------------------------------------------------------------------
  175. void        // AUCUNE VALEUR DE RETOUR
  176. FenetreAbabelone::FrameResized(float width, float height)
  177. // 2 PARAMETRES :                ENTREE            ENTREE
  178. {
  179.     float echelle = (width+1.0)/LARGEUR_PLATEAU;
  180. //    float nouvelle_largeur = (echelle*LARGEUR_PLATEAU-1.0);
  181.     float nouvelle_hauteur = int(echelle*HAUTEUR_PLATEAU+19.0);
  182.  
  183.     if ((nouvelle_hauteur) == (height)) {
  184.         m_PlateauGraphique->ChangerEchelle(echelle);
  185.         m_PlateauGraphique->MiseAJourBufferEntier();
  186.     }
  187.     else {
  188.         ResizeTo(width, nouvelle_hauteur);
  189.     }
  190. }
  191.  
  192.   ////////////////////////////////
  193.  // FONCTION "MessageReceived" //
  194. ////////////////////////////////--------------------------------------
  195. // Re├ºoit et traite tous les messages pour la gestion de la fen├¬tre --
  196. //--------------------------------------------------------------------
  197. void        // AUCUNE VALEUR DE RETOUR
  198. FenetreAbabelone::MessageReceived(BMessage* message)
  199. // 1 PARAMETRE :                        ENTREE
  200. {
  201.     bool partie_a_reprendre = false;
  202.     int32 compteur;
  203.     void* adresse_donnee = NULL;
  204.  
  205.     if (message->what == MSG_QUITTER)
  206.         QuitRequested();
  207.     else {
  208.         get_sem_count(m_SemaphoreThread, &compteur);
  209.         if(compteur == 0) {
  210.             switch(message->what)
  211.             {
  212.                 case B_WINDOW_RESIZED:
  213.                 case MSG_PARTIE_PAUSE:
  214.                 case MSG_CHARGER:
  215.                 case B_REFS_RECEIVED:
  216.                 case B_SAVE_REQUESTED:
  217.                 case MSG_SAUVEGARDER:
  218.                 case MSG_NOUVELLE_PARTIE:
  219.                 case MSG_CHANGER_PARTIE:
  220.                 case MSG_COMMENCER_NOUVELLE_PARTIE:
  221.                 case MSG_COMMENCER_PARTIE:
  222.                 case MSG_COUP_PRECEDENT:
  223.                 case MSG_COUP_SUIVANT:
  224.                 case MSG_COUP_SUIVANT_REALISTE:
  225.                 case MSG_DEPLACEMENT_REALISTE:
  226.                 case MSG_A_PROPOS_DE:
  227.                     compteur = 1;
  228.                 break;
  229.             }
  230.             if (compteur == 1 || m_MenuLangue->Active(message->what)
  231.                         || m_MenuPlateauDeJeu->Active(message->what))
  232.                 if (!has_data(m_ThreadJouer)) {
  233.                     *m_MessagePourFenetre = *message;
  234.                     send_data(m_ThreadJouer,  message->what, adresse_donnee, 0);
  235.                 }
  236.         }
  237.         else {
  238.             acquire_sem(m_SemaphoreThread);
  239.             switch(message->what)
  240.             {
  241.                 case B_WINDOW_RESIZED:
  242.                     m_ChargerFichier->Show();
  243.                 break;
  244. /*                case MSG_QUITTER:
  245.                     QuitRequested();
  246.                 break;
  247. */                case MSG_PARTIE_PAUSE:
  248.                     if (m_PartieInterrompue == false)
  249.                         InterromprePartie();
  250.                     else
  251.                         ContinuerPartie();
  252.                 break;
  253.                 case MSG_CHARGER:
  254.                     m_ChargerFichier->Show();
  255.                 break;
  256.                 case B_REFS_RECEIVED:
  257.                     ChargerFichier(message);
  258.                 break;
  259.                 case B_SAVE_REQUESTED:
  260.                     SauvegarderFichier(message);
  261.                 break;
  262.                 case MSG_SAUVEGARDER:
  263.                     m_SauvegarderFichier->Show();
  264.                 break;
  265.                 case MSG_NOUVELLE_PARTIE:
  266.                     m_FenetreChangementDePartie = new FenetreChangementDePartie(this, m_TableauJoueurs, &m_NombreJoueurs, m_Textes, true);
  267.                 break;
  268.                 case MSG_CHANGER_PARTIE:
  269.                     m_FenetreChangementDePartie = new FenetreChangementDePartie(this, m_TableauJoueurs, &m_NombreJoueurs, m_Textes, false);
  270.                 break;
  271.                 case MSG_COMMENCER_NOUVELLE_PARTIE:
  272.                     m_FenetreChangementDePartie->PostMessage(B_QUIT_REQUESTED);
  273.                     if (m_PartieInterrompue == false)
  274.                         InterromprePartie();
  275.                     m_PlateauGraphique->AfficherBouleCouleurAJouer(m_JoueurCourant, m_PartieInterrompue);
  276.                     m_PartieInterrompue = false;
  277.                     m_PlateauGraphique->AfficherBouleCouleurAJouer(m_JoueurCourant, m_PartieInterrompue);
  278.                     CommencerPartie(true);
  279.                     ContinuerPartie();
  280.                     m_Debut = false;
  281.                 break;
  282.                 case MSG_COMMENCER_PARTIE:
  283.                     m_FenetreChangementDePartie->PostMessage(B_QUIT_REQUESTED);
  284.                     if (m_PartieInterrompue == false) {
  285.                         InterromprePartie();
  286.                         partie_a_reprendre = true;
  287.                     }
  288.                     CommencerPartie(false);
  289.                     if (partie_a_reprendre == true)
  290.                         ContinuerPartie();
  291.                     else {
  292.                         AfficherTitre(false);
  293.                     }
  294.                 break;
  295.                 case MSG_COUP_PRECEDENT:
  296.                     CoupPrecedent();
  297.                 break;
  298.                 case MSG_COUP_SUIVANT:
  299.                     CoupSuivant();
  300.                 break;
  301.                 case MSG_COUP_SUIVANT_REALISTE:
  302.                     CoupSuivant(true);
  303.                 break;
  304.                 case MSG_DEPLACEMENT_REALISTE:
  305.                     m_DeplacementRealiste = ! m_DeplacementRealiste;
  306.                     m_ItemDeplacementRealiste->SetMarked(m_DeplacementRealiste);
  307.                 break;
  308.                 case MSG_A_PROPOS_DE:
  309.                     APropos();
  310.                 break;
  311.                 default:
  312.                     if (m_MenuLangue->Active(message->what))
  313.                         ChangerTextes(message->what - MSG_LANGUE);
  314.                     else
  315.                         if (m_MenuPlateauDeJeu->Active(message->what))
  316.                             m_PlateauGraphique->ChangerPlateauDeJeu(message->what - MSG_PLATEAU_DE_JEU);
  317.                 break;
  318.             }
  319.             release_sem(m_SemaphoreThread);
  320.         }
  321.     }
  322. }
  323.  
  324.  
  325.   /////////////////////////////////////////
  326.  // FONCTION "SourisBoutonGaucheAppuye" //
  327. /////////////////////////////////////////-------------------
  328. // L'utilisateur appuie sur le bouton gauche de la souris --
  329. //----------------------------------------------------------
  330. void        // AUCUNE VALEUR DE RETOUR
  331. FenetreAbabelone::SourisBoutonGaucheAppuye(BPoint where)
  332. // 1 PARAMETRE :                                ENTREE
  333. {
  334.     if (Lock()) {
  335.         if (m_PartieInterrompue == false && m_HumainADejaJoue == false && m_TableauDeplacementJoueurs[m_JoueurCourant]->Ordinateur() == false)
  336.             ((DeplacementHumain*)m_TableauDeplacementJoueurs[m_JoueurCourant])->JoueurAppuieSouris(where);
  337.         Unlock();
  338.     }
  339. }
  340.  
  341.   ////////////////////////////////////////
  342.  // FONCTION "SourisBoutonDroitAppuye" //
  343. ////////////////////////////////////////-------------------
  344. // L'utilisateur appuie sur le bouton droit de la souris --
  345. //---------------------------------------------------------
  346. void        // AUCUNE VALEUR DE RETOUR
  347. FenetreAbabelone::SourisBoutonDroitAppuye()
  348. // AUCUN PARAMETRE
  349. {
  350.     if (Lock()) {
  351.         if (m_PartieInterrompue == false && m_HumainADejaJoue == false && m_TableauDeplacementJoueurs[m_JoueurCourant]->Ordinateur() == false)
  352.             ((DeplacementHumain*)m_TableauDeplacementJoueurs[m_JoueurCourant])->Deselectionner();
  353.         Unlock();
  354.     }
  355. }
  356.  
  357.   ////////////////////////////////////
  358.  // FONCTION "SourisBoutonRelache" //
  359. ////////////////////////////////////--------------
  360. // L'utilisateur rel├óche un bouton de la souris --
  361. //------------------------------------------------
  362. void        // AUCUNE VALEUR DE RETOUR
  363. FenetreAbabelone::SourisBoutonRelache(BPoint where)
  364. // 1 PARAMETRE :                        ENTREE
  365. {
  366.     // Cr├⌐ation et initialisation ├⌐ventuelle des variables locales
  367.     int8 deplacement_ejection;
  368.  
  369.     if (Lock()) {
  370.         if (m_PartieInterrompue == false && m_HumainADejaJoue == false && m_TableauDeplacementJoueurs[m_JoueurCourant]->Ordinateur() == false) {
  371.             deplacement_ejection = ((DeplacementHumain*)m_TableauDeplacementJoueurs[m_JoueurCourant])->JoueurRelacheSouris(where, m_DeplacementRealiste);
  372.             if (deplacement_ejection != -1) {    // Si d├⌐placement
  373.                 m_HumainADejaJoue = true;
  374.                 resume_thread(m_ThreadJouer);
  375.             }
  376.         }
  377.         Unlock();
  378.     }
  379. }
  380.  
  381.   //////////////////////////
  382.  // FONCTION "CreerMenu" //
  383. //////////////////////////----------------
  384. // Cr├⌐e le menu d├⌐roulant de la fen├¬tre --
  385. //----------------------------------------
  386. void        // AUCUNE VALEUR DE RETOUR
  387. FenetreAbabelone::CreerMenu(uint8 numero_langue, uint8 numero_plateau_de_jeu)
  388. // 2 PARAMETRES :                    ENTREE                    ENTREE
  389. {
  390.     // Cr├⌐ation des variables locales
  391.     BRect rect_menu;
  392.     BMenu* sous_menu;
  393.     BMenuItem* item;
  394.  
  395.     rect_menu = Bounds();
  396.     rect_menu.bottom = rect_menu.top+15;
  397.     m_MenuBar = new BMenuBar(rect_menu,"MenuBar");
  398.  
  399.     sous_menu = new BMenu("");
  400.     sous_menu->AddItem(item=new BMenuItem("",new BMessage(MSG_NOUVELLE_PARTIE),'N',B_COMMAND_KEY));
  401.     sous_menu->AddItem(m_ItemChangerJoueurs=new BMenuItem("",new BMessage(MSG_CHANGER_PARTIE),'C',B_COMMAND_KEY));
  402.     m_ItemChangerJoueurs->SetEnabled(false);
  403.     sous_menu->AddSeparatorItem();
  404.     sous_menu->AddItem(m_ItemCharger=new BMenuItem("",new BMessage(MSG_CHARGER),'O',B_COMMAND_KEY));
  405.     sous_menu->AddItem(m_ItemSauvegarder=new BMenuItem("",new BMessage(MSG_SAUVEGARDER),'S',B_COMMAND_KEY));
  406.     m_ItemSauvegarder->SetEnabled(false);
  407.     sous_menu->AddSeparatorItem();
  408.     sous_menu->AddItem(new BMenuItem("",new BMessage(MSG_QUITTER),'Q',B_COMMAND_KEY));
  409.     m_MenuBar->AddItem(sous_menu);
  410.     sous_menu = new BMenu("");
  411.     sous_menu->AddItem(m_ItemCoupPrecedent = new BMenuItem("",new BMessage(MSG_COUP_PRECEDENT), B_LEFT_ARROW,B_COMMAND_KEY));
  412.     m_ItemCoupPrecedent->SetEnabled(false);
  413.     sous_menu->AddItem(m_ItemCoupSuivant = new BMenuItem("",new BMessage(MSG_COUP_SUIVANT), B_RIGHT_ARROW,B_COMMAND_KEY));
  414.     m_ItemCoupSuivant->SetEnabled(false);
  415.     sous_menu->AddItem(m_ItemCoupSuivantRealiste = new BMenuItem("",new BMessage(MSG_COUP_SUIVANT_REALISTE), B_UP_ARROW,B_COMMAND_KEY));
  416.     m_ItemCoupSuivantRealiste->SetEnabled(false);
  417.     sous_menu->AddSeparatorItem();
  418.     sous_menu->AddItem(m_ItemDeplacementRealiste = new BMenuItem("",new BMessage(MSG_DEPLACEMENT_REALISTE), 'R',B_COMMAND_KEY));
  419.     m_ItemDeplacementRealiste->SetMarked(m_DeplacementRealiste);
  420.     sous_menu->AddSeparatorItem();
  421.     sous_menu->AddItem(m_ItemTerminer=new BMenuItem("",new BMessage(MSG_PARTIE_PAUSE),'P',B_COMMAND_KEY));
  422.     m_ItemTerminer->SetEnabled(false);
  423.     m_ItemTerminer->SetMarked(false);
  424.     m_MenuBar->AddItem(sous_menu);
  425.  
  426.     m_MenuBar->AddItem(sous_menu = new BMenu(""));
  427.     m_MenuLangue = new MenuDynamique(sous_menu, "Langues", MSG_LANGUE);
  428.  
  429.     m_MenuBar->AddItem(sous_menu = new BMenu(""));
  430.     m_MenuPlateauDeJeu = new MenuDynamique(sous_menu, "Images/Plateaux de jeu", MSG_PLATEAU_DE_JEU);
  431.  
  432.     m_MenuBar->AddItem(new BMenuItem("",new BMessage(MSG_A_PROPOS_DE)));
  433.  
  434.     ChangerTextes(numero_langue);
  435.  
  436.     m_MenuPlateauDeJeu->SelectionnerFichier(numero_plateau_de_jeu);
  437.  
  438.     m_MenuBar->ResizeToPreferred();
  439.     AddChild(m_MenuBar);
  440. }
  441.  
  442.   //////////////////////////////
  443.  // FONCTION "ChangerTextes" //
  444. //////////////////////////////------------------------------------------------
  445. //----------------------------------------------------------------------------
  446. void        // AUCUNE VALEUR DE RETOUR
  447. FenetreAbabelone::ChangerTextes(uint8 numero_langue)
  448. // 1 PARAMETRE :                        ENTREE
  449. {
  450.     BMenu* sous_menu;
  451.     BMenuItem* item;
  452.     BEntry entree_fichier;
  453.     int i = 0, j;
  454.     uint8 numero_texte;
  455.     char* chaine_fichier;
  456.     char* chaine;
  457.  
  458.     entree_fichier = m_MenuLangue->SelectionnerFichier(numero_langue);
  459.     m_Textes->ChargerFichier(&entree_fichier);
  460.     while ((sous_menu = m_MenuBar->SubmenuAt(i)) != NULL) {
  461.         sous_menu = m_MenuBar->SubmenuAt(i);
  462.         (m_MenuBar->ItemAt(i))->SetLabel(m_Textes->Texte(0));
  463.         j = 0;
  464.         while ((item = sous_menu->ItemAt(j)) != NULL) {
  465.             numero_texte = 0;
  466.             switch (i) {
  467.                 case 0:
  468.                     switch (j) {
  469.                         case 0:    (m_MenuBar->ItemAt(i))->SetLabel(m_Textes->Texte(0));
  470.                                 numero_texte = 1;break;
  471.                         case 1:    numero_texte = 2;break;
  472.                         case 3:    numero_texte = 3;break;
  473.                         case 4:    numero_texte = 4;break;
  474.                         case 6:    numero_texte = 5;break;
  475.                     }
  476.                 break;
  477.                 case 1:
  478.                     switch (j) {
  479.                         case 0:    (m_MenuBar->ItemAt(i))->SetLabel(m_Textes->Texte(6));
  480.                                 numero_texte = 7;break;
  481.                         case 1:    numero_texte = 8;break;
  482.                         case 2:    numero_texte = 9;break;
  483.                         case 4:    numero_texte = 10;break;
  484.                         case 6:    numero_texte = 11;break;
  485.                     }
  486.                 break;
  487.                 case 2:
  488.                     (m_MenuBar->ItemAt(i))->SetLabel(m_Textes->Texte(34));
  489.                 break;
  490.                 case 3:
  491.                     (m_MenuBar->ItemAt(i))->SetLabel(m_Textes->Texte(35));
  492.                 break;
  493.             }
  494.             if (numero_texte != 0)
  495.                 item->SetLabel(m_Textes->Texte(numero_texte));
  496.             j++;
  497.         }
  498.         i++;
  499.     }
  500.     (m_MenuBar->ItemAt(4))->SetLabel(m_Textes->Texte(12));
  501.  
  502.     m_ChargerFichier->SetButtonLabel(B_DEFAULT_BUTTON, m_Textes->Texte(22));
  503.     m_ChargerFichier->SetButtonLabel(B_CANCEL_BUTTON, m_Textes->Texte(28));
  504.     m_ChargerFichier->Window()->SetTitle(m_Textes->Texte(14));
  505.  
  506.     m_SauvegarderFichier->SetButtonLabel(B_DEFAULT_BUTTON, m_Textes->Texte(23));
  507.     m_SauvegarderFichier->SetButtonLabel(B_CANCEL_BUTTON, m_Textes->Texte(28));
  508.     m_SauvegarderFichier->Window()->SetTitle(m_Textes->Texte(15));
  509.  
  510.     chaine = m_Textes->Texte(13);
  511.     chaine_fichier = new char[strlen(chaine) + strlen(EXTENTION_FICHIER) + 1];
  512.     strcpy(chaine_fichier, chaine);
  513.     strcat(chaine_fichier, EXTENTION_FICHIER);
  514.     m_SauvegarderFichier->SetSaveText(chaine_fichier);
  515.     delete chaine_fichier;
  516.  
  517.     if (m_Debut == false) {
  518.         m_PlateauGraphique->ChangerTypeJoueurs(m_NombreJoueurs, m_TableauJoueurs, m_PlateauInterne->TableauBoulesEjectees());
  519.         AfficherTitre(m_PartieTerminee);
  520.     }
  521. }
  522.  
  523.   ////////////////////////////////////////////////////////
  524.  // FONCTION "RemplirTableauHexagonalPositionDeDepart" //
  525. ////////////////////////////////////////////////////////------------------------------------------------
  526. // Remplit le tableau interne et le tableau graphique.                                                --
  527. // Les valeurs correspondent ├á la position de d├⌐part du tableau hexagonal standard (5 boules de c├┤t├⌐) --
  528. //------------------------------------------------------------------------------------------------------
  529. void        // AUCUNE VALEUR DE RETOUR
  530. FenetreAbabelone::RemplirTableauHexagonalPositionDeDepart()
  531. // AUCUN PARAMETRE
  532. {
  533.     int i, j, x, y, numero_boule;
  534.  
  535.     for (i = 0; i < 11; i++)
  536.         for (j = 0; j < 11; j++) {
  537.             numero_boule = 0;            // Cases vides dans l'hexagone (valeur : 0)
  538.             if (i == 0 || j == 0 || i == 10 || j == 10 || (i+j) < 6 || (i+j) > 14)
  539.                 numero_boule = -1;        // Cases hors de l'hexagone (valeur : -1)
  540.             else
  541.                 switch(j) {
  542.                     case 1    :                    // Ligne horizontale  n┬░1
  543.                         numero_boule = i - 4;    //  avec 5 boules noires
  544.                         break;
  545.                     case 2    :                    // Ligne horizontale  n┬░2
  546.                         numero_boule = i + 2;    //  avec 6 boules noires
  547.                         break;
  548.                     case 3    :                    // Ligne horizontale  n┬░3
  549.                         if (m_NombreJoueurs == 2)
  550.                             if (i > 4 && i < 8)        //  avec 3 boules noires
  551.                                 numero_boule = i + 7;
  552.                         break;
  553.                     case 4    :                    // Ligne horizontale  n┬░4
  554.                         if (m_NombreJoueurs == 3) {
  555.                             if (i == 2)                //  avec x boules x
  556.                                 numero_boule = i + 10;
  557.                             if (i == 9)
  558.                                 numero_boule = i + 14;
  559.                         }
  560.                         break;
  561.                     case 5    :                    // Ligne horizontale  n┬░5
  562.                         if (m_NombreJoueurs == 3) {
  563.                             if (i == 1 || i == 2)    //  avec x boules x
  564.                                 numero_boule = i + 12;
  565.                             if (i == 8 || i == 9)
  566.                                 numero_boule = i + 16;
  567.                         }
  568.                         break;
  569.                     case 6    :                    // Ligne horizontale  n┬░6
  570.                         if (m_NombreJoueurs == 3) {
  571.                             if (i == 1 || i == 2)    //  avec x boules x
  572.                                 numero_boule = i + 14;
  573.                             if (i == 7 || i == 8)
  574.                                 numero_boule = i + 19;
  575.                         }
  576.                         break;
  577.                     case 7    :                    // Ligne horizontale  n┬░7
  578.                         if (m_NombreJoueurs == 2) {
  579.                             if (i > 2 && i < 6)        //  avec 3 boules blanches
  580.                                 numero_boule = i + 12;
  581.                         }
  582.                         else {
  583.                             if (i == 1 || i == 2)    //  avec x boules x
  584.                                 numero_boule = i + 16;
  585.                             if (i == 6 || i == 7)
  586.                                 numero_boule = i + 22;
  587.                         }
  588.                         break;
  589.                     case 8    :                    // Ligne horizontale  n┬░8
  590.                         if (m_NombreJoueurs == 2)
  591.                             numero_boule = i + 17;    //  avec 6 boules blanches
  592.                         else {
  593.                             if (i == 1 || i == 2)    //  avec x boules x
  594.                                 numero_boule = i + 18;
  595.                             if (i == 5 || i == 6)
  596.                                 numero_boule = i + 25;
  597.                         }
  598.                         break;
  599.                     case 9    :                    // Ligne horizontale  n┬░9
  600.                         if (m_NombreJoueurs == 2)
  601.                             numero_boule = i + 23;    //  avec 5 boules blanches
  602.                         else {
  603.                             if (i == 1 || i == 2)    //  avec x boules x
  604.                                 numero_boule = i + 20;
  605.                             if (i == 4 || i == 5)
  606.                                 numero_boule = i + 28;
  607.                         }
  608.                         break;
  609.                 }
  610.             if (numero_boule > 0) {
  611.                 x = ORIGINE_X + (2*i - 7 + j)*(LARGEUR_CASE_BOULE/2);
  612.                 y = ORIGINE_Y + (j-1)*HAUTEUR_CASE_BOULE;
  613.                 m_PlateauGraphique->SetBoule(numero_boule, BRect(x,y,x+LARGEUR_BOULE,y+HAUTEUR_BOULE));
  614.             }
  615.             m_PlateauInterne->SetCase(Coordonnees(i,j), numero_boule);        // Cases (valeur : numero_boule)
  616.         }
  617.     m_PlateauGraphique->InitialiserSelectEtFleche();
  618.     m_PlateauInterne->InitialiserBoulesEjectees();
  619. }
  620.  
  621.   //////////////////////
  622.  // FONCTION "Jouer" //
  623. //////////////////////-----------------------------------------------------------------------------------------
  624. // Thread qui permet de jouer. C'est la boucle qui fait jouer l'ordinateur et qui permet aux joueurs humains --
  625. // de jouer                                                                                                  --
  626. //-------------------------------------------------------------------------------------------------------------
  627. int32        // VALEUR DE RETOUR
  628. FenetreAbabelone::Jouer(void* ptr_objet)
  629. // 1 PARAMETRE :        ENTREE/SORTIE (en fait, correspond ├á "this")
  630. {
  631.     FenetreAbabelone* w = (FenetreAbabelone*) ptr_objet;
  632.     type_deplacement* coup_joue;
  633.     thread_id numero_thread;
  634.     void * adresse_donnee = NULL;
  635.     int32 code;
  636.  
  637.     while  (w->m_PartieTerminee == false) {
  638.         acquire_sem(w->m_SemaphoreThread);
  639.         if (w->m_TableauDeplacementJoueurs[w->m_JoueurCourant]->Ordinateur() == true)
  640.             ((DeplacementOrdinateur*)w->m_TableauDeplacementJoueurs[w->m_JoueurCourant])->Jouer(w->m_DeplacementRealiste);
  641.         else {
  642.             w->m_HumainADejaJoue = false;
  643.             release_sem(w->m_SemaphoreThread);
  644.             if (has_data(w->m_ThreadJouer))
  645.                 receive_data(&numero_thread, adresse_donnee, 0);
  646.             suspend_thread(w->m_ThreadJouer);
  647.             acquire_sem(w->m_SemaphoreThread);
  648.         }
  649.         w->PreparerListeAvantDeJouer();
  650.         coup_joue = new type_deplacement(w->m_TableauDeplacementJoueurs[w->m_JoueurCourant]->CoupJoue());
  651.         w->m_ListeCoupsJoues->AddItem(coup_joue);
  652.         w->m_NumeroCoupJoueCourant++;
  653.  
  654.         if (w->m_NumeroCoupJoueCourant > 0)
  655.             w->m_ItemCoupPrecedent->SetEnabled(true);
  656.         w->m_ItemCoupSuivant->SetEnabled(false);
  657.         w->m_ItemCoupSuivantRealiste->SetEnabled(false);
  658.         if (w->m_ListeCoupsJoues->CountItems() == 0)
  659.             w->m_ItemSauvegarder->SetEnabled(false);
  660.         else
  661.             w->m_ItemSauvegarder->SetEnabled(true);
  662.  
  663.         if (w->m_PlateauInterne->BoulesEjectees(w->m_JoueurCourant) == 6)
  664.             w->m_PartieTerminee = true;
  665.         w->m_JoueurCourant = w->m_PlateauInterne->JoueurSuivant(w->m_JoueurCourant);
  666. //        if (w->m_PartieTerminee == false)
  667. //            w->m_PlateauGraphique->AfficherBouleCouleurAJouer(w->m_JoueurCourant, w->m_PartieInterrompue);
  668. //        else
  669. //            w->m_PlateauGraphique->EffacerBouleCouleurAJouer();
  670.         w->m_PlateauGraphique->AfficherBouleCouleurAJouer(w->m_JoueurCourant, w->m_PartieInterrompue, w->m_PartieTerminee);
  671.         release_sem(w->m_SemaphoreThread);
  672.         if (has_data(w->m_ThreadJouer)) {
  673.             code = receive_data(&numero_thread, adresse_donnee, 0);
  674.             w->PostMessage(w->m_MessagePourFenetre);
  675.         }
  676.         snooze(1000);
  677.     }
  678.     w->InterromprePartie(false);
  679. }
  680.  
  681.   //////////////////////////////////
  682.  // FONCTION "InterromprePartie" //
  683. //////////////////////////////////-------------------------------------------------------------------------
  684. // Met en pause une partie. Si la pause est temporaire, les joueurs humains ├⌐ventuels peuvent jouer sans --
  685. // avoir besoin d'enlever la pause                                                                       --
  686. //---------------------------------------------------------------------------------------------------------
  687. void        // AUCUNE VALEUR DE RETOUR
  688. FenetreAbabelone::InterromprePartie(bool tuer_thread, bool interrompre_temporairement)
  689. // 2 PARAMETRES :                        ENTREE                    ENTREE
  690. {
  691.     if (m_PartieInterrompue == false) {
  692.         if (interrompre_temporairement == true && m_PartieInterrompueTemporairement == false)
  693.             m_PartieInterrompueTemporairement = true;
  694.         m_PartieInterrompue = true;
  695.         if (tuer_thread == true)
  696.             kill_thread(m_ThreadJouer);
  697. //        m_PlateauGraphique->AfficherPause();
  698.         m_PlateauGraphique->AfficherBouleCouleurAJouer(m_JoueurCourant, m_PartieInterrompue, m_PartieTerminee);
  699.         if (m_PartieTerminee == true)
  700.             m_ItemTerminer->SetEnabled(false);
  701.         AfficherTitre(m_PartieTerminee);
  702.         m_ItemTerminer->SetMarked(m_PartieInterrompue);
  703.     }
  704. }
  705.  
  706.   ////////////////////////////////
  707.  // FONCTION "ContinuerPartie" //
  708. ////////////////////////////////-----
  709. // Continue une partie interrompue --
  710. //-----------------------------------
  711. void        // AUCUNE VALEUR DE RETOUR
  712. FenetreAbabelone::ContinuerPartie()
  713. // AUCUN PARAMETRE
  714. {
  715.     if (m_PartieTerminee == true)
  716.         m_PartieTerminee = false;
  717.  
  718.     if (m_PartieInterrompueTemporairement == true)
  719.         m_PartieInterrompueTemporairement = false;
  720.     if (m_PartieInterrompue == true) {
  721.         m_PartieInterrompue = false;
  722.         m_ItemTerminer->SetMarked(m_PartieInterrompue);
  723.     }
  724.     AfficherTitre(false);
  725.  
  726.     m_PlateauGraphique->AfficherBouleCouleurAJouer(m_JoueurCourant, m_PartieInterrompue);
  727.     m_ThreadJouer = spawn_thread((FenetreAbabelone::Jouer), "JoueurSuivant", B_NORMAL_PRIORITY, (void*)this);
  728.     resume_thread(m_ThreadJouer);
  729. }
  730.  
  731.   ////////////////////////////////
  732.  // FONCTION "CommencerPartie" //
  733. ////////////////////////////////--------------------------------
  734. // Commence une nouvelle partie ou change le type des joueurs --
  735. //--------------------------------------------------------------
  736. void        // AUCUNE VALEUR DE RETOUR
  737. FenetreAbabelone::CommencerPartie(bool commencer_du_debut, bool mise_a_jour_buffer_ecran)
  738. // 2 PARAMETRES :                        ENTREE                        ENTREE
  739. {
  740.     int32 i, max;
  741.     void* coup_joue;
  742.  
  743.     if (commencer_du_debut == true) {
  744.         max = m_ListeCoupsJoues->CountItems();
  745.         for (i = 0; i < max; i++) {
  746.             coup_joue = m_ListeCoupsJoues->ItemAt(i);
  747.             delete ((type_deplacement*)coup_joue);
  748.         }
  749.         m_ListeCoupsJoues->MakeEmpty();
  750.         m_NumeroCoupJoueCourant = 0;
  751.     }
  752.  
  753.     for (i=0; i < NOMBRE_JOUEURS_MAXI; i++) {
  754.         if (m_TableauDeplacementJoueurs[i] != NULL) {
  755.             delete m_TableauDeplacementJoueurs[i];
  756.             m_TableauDeplacementJoueurs[i] = NULL;
  757.         }
  758.     }
  759.     AfficherTitre(false);
  760.     if (m_NombreJoueurs == 2)
  761.         m_NombreBoules = 28;
  762.     else
  763.         m_NombreBoules = 33;
  764.     m_PlateauInterne->ChangerNombreBoules(m_NombreBoules);
  765.     m_PlateauInterne->ChangerNombreJoueurs(m_NombreJoueurs);
  766.     m_PlateauGraphique->ChangerNombreBoules(m_NombreBoules);
  767.     m_PlateauGraphique->ChangerTypeJoueurs(m_NombreJoueurs, m_TableauJoueurs, m_PlateauInterne->TableauBoulesEjectees());
  768.  
  769.     if (commencer_du_debut == true) {
  770.         RemplirTableauHexagonalPositionDeDepart();
  771.         if (mise_a_jour_buffer_ecran == true)
  772.             m_PlateauGraphique->MiseAJourBufferEntier();
  773.         m_JoueurCourant = 0;
  774.         m_ItemTerminer->SetEnabled(true);
  775.         m_ItemSauvegarder->SetEnabled(true);
  776.         m_ItemChangerJoueurs->SetEnabled(true);
  777.         m_ItemCoupPrecedent->SetEnabled(false);
  778.         m_ItemCoupSuivant->SetEnabled(false);
  779.         m_ItemCoupSuivantRealiste->SetEnabled(false);
  780.     }
  781. }
  782.  
  783.   //////////////////////////////
  784.  // FONCTION "CoupPrecedent" //
  785. //////////////////////////////-----------------
  786. // Joue le coup pr├⌐c├⌐dent, si c'est possible --
  787. //---------------------------------------------
  788. void        // AUCUNE VALEUR DE RETOUR
  789. FenetreAbabelone::CoupPrecedent()
  790. // AUCUN PARAMETRE
  791. {
  792.     void* coup_joue;
  793.  
  794.     if (m_NumeroCoupJoueCourant > 0) {
  795.         coup_joue = m_ListeCoupsJoues->ItemAt(m_NumeroCoupJoueCourant-1);
  796.         m_JoueurCourant = m_PlateauInterne->JoueurPrecedent(m_JoueurCourant);
  797.         if (m_TableauDeplacementJoueurs[m_JoueurCourant]->Ordinateur() == true)
  798.             InterromprePartie(true, true);
  799.         else
  800.             if (m_PartieInterrompueTemporairement == true && m_PartieInterrompue == true)
  801.                 ContinuerPartie();
  802.         m_TableauDeplacementJoueurs[m_JoueurCourant]->JouerCoupPrecedent(*((type_deplacement*)coup_joue));
  803.         m_NumeroCoupJoueCourant--;
  804.         m_ItemCoupSuivant->SetEnabled(true);
  805.         m_ItemCoupSuivantRealiste->SetEnabled(true);
  806.         m_ItemTerminer->SetEnabled(true);
  807.         AfficherTitre(false);
  808.         if (m_NumeroCoupJoueCourant == 0)
  809.             m_ItemCoupPrecedent->SetEnabled(false);
  810.         m_PlateauGraphique->AfficherBouleCouleurAJouer(m_JoueurCourant, m_PartieInterrompue);
  811.     }
  812. }
  813.  
  814.   ////////////////////////////
  815.  // FONCTION "CoupSuivant" //
  816. ////////////////////////////-----------------
  817. // Joue le coup suivant, si c'est possible --
  818. //-------------------------------------------
  819. void        // AUCUNE VALEUR DE RETOUR
  820. FenetreAbabelone::CoupSuivant(bool faire_glisser_les_boules, bool mise_a_jour_buffer_ecran)
  821. // 2 PARAMETRES :                            ENTREE                        ENTREE
  822. {
  823.     void* coup_joue;
  824.  
  825.     if (m_NumeroCoupJoueCourant < m_ListeCoupsJoues->CountItems()) {
  826.         coup_joue = m_ListeCoupsJoues->ItemAt(m_NumeroCoupJoueCourant);
  827.         m_TableauDeplacementJoueurs[m_JoueurCourant]->JouerCoup(*((type_deplacement*)coup_joue), faire_glisser_les_boules, mise_a_jour_buffer_ecran);
  828.         m_JoueurCourant = m_PlateauInterne->JoueurSuivant(m_JoueurCourant);
  829.         if (m_TableauDeplacementJoueurs[m_JoueurCourant]->Ordinateur() == true)
  830.             InterromprePartie(true, true);
  831.         else
  832.             if (m_PartieInterrompueTemporairement == true && m_PartieInterrompue == true)
  833.                 ContinuerPartie();
  834.         m_NumeroCoupJoueCourant++;
  835.         m_ItemCoupPrecedent->SetEnabled(true);
  836.         if (m_NumeroCoupJoueCourant == m_ListeCoupsJoues->CountItems()) {
  837.             if (mise_a_jour_buffer_ecran == true)
  838.                 m_PlateauGraphique->AfficherBouleCouleurAJouer(m_JoueurCourant, m_PartieInterrompue, m_PartieTerminee);
  839.             m_ItemCoupSuivant->SetEnabled(false);
  840.             m_ItemCoupSuivantRealiste->SetEnabled(false);
  841.             if (m_PartieTerminee == true) {
  842.                 m_ItemTerminer->SetEnabled(false);
  843.                 if (mise_a_jour_buffer_ecran == true)
  844.                     AfficherTitre(true);
  845.             }
  846.         }
  847.         else
  848.             if (mise_a_jour_buffer_ecran == true)
  849.                 m_PlateauGraphique->AfficherBouleCouleurAJouer(m_JoueurCourant, m_PartieInterrompue);
  850.     }
  851. }
  852.  
  853.   ///////////////////////////////
  854.  // FONCTION "ChargerFichier" //
  855. ///////////////////////////////-----------------------------
  856. // Charge une partie sauv├⌐e pr├⌐alablement dans un fichier --
  857. //----------------------------------------------------------
  858. void        // AUCUNE VALEUR DE RETOUR
  859. FenetreAbabelone::ChargerFichier(BMessage* message)
  860. // 1 PARAMETRE :                        ENTREE
  861. {
  862.     BEntry entree;
  863.     BPath chemin;
  864.     BFile fichier;
  865.     entry_ref ref;
  866.     status_t statut;
  867.     int32 max;
  868.     int32 i;
  869.     bool partie_terminee;
  870.     void* coup_joue;
  871.     char chaine[500];
  872.  
  873.     message->FindRef("refs", 0, &ref);
  874.     entree.SetTo(&ref);
  875.     chemin.SetTo(&entree);
  876.     statut = fichier.SetTo(chemin.Path(), B_READ_ONLY);
  877.     if (statut != B_OK) {
  878.         sprintf(chaine, "%s \"%s\" %s", m_Textes->Texte(16), chemin.Path(), m_Textes->Texte(17));
  879.         (new BAlert("", chaine, m_Textes->Texte(21), NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT))->Go();
  880.     }
  881.     else {
  882.         if (fichier.Read(chaine, (strlen(ENTETE_FICHIER)+1)*sizeof(char)) != (signed)(strlen(ENTETE_FICHIER)+1) || strcmp(chaine, ENTETE_FICHIER) != 0) {
  883.             sprintf(chaine, "%s \"%s\" %s", m_Textes->Texte(16), chemin.Path(), m_Textes->Texte(18));
  884.             (new BAlert("", chaine, m_Textes->Texte(21), NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT))->Go();
  885.         }
  886.         else {
  887.             m_PartieInterrompueTemporairement = false;
  888. //            m_PartieInterrompue = false;
  889.             if (m_PartieInterrompue == false)
  890.                 InterromprePartie();
  891.             else
  892.                 m_ItemTerminer->SetMarked(m_PartieInterrompue);
  893.  
  894.             sprintf(chaine,"%s  -  %s", VERSION_ABABELONE, m_Textes->Texte(20));
  895.             SetTitle(chaine);
  896.     
  897.             fichier.Read(&m_NombreBoules, sizeof(uint8));
  898.             fichier.Read(&m_NombreJoueurs, sizeof(uint8));
  899.             for (i=0; i < m_NombreJoueurs; i++)
  900.                 fichier.Read(&(m_TableauJoueurs[i]), sizeof(uint8));
  901.             fichier.Read(&partie_terminee, sizeof(bool));
  902.             fichier.Read(&max, sizeof(int32));
  903.             CommencerPartie(true, false);
  904.             for (i=0; i < max; i++) {
  905.                 coup_joue = new type_deplacement;
  906.                 m_ListeCoupsJoues->AddItem(coup_joue);
  907.                 fichier.Read(coup_joue, sizeof(type_deplacement));
  908.                 CoupSuivant(false, false);
  909.             }
  910.             fichier.Unset();
  911.             m_PartieTerminee = partie_terminee;
  912.             AfficherTitre(m_PartieTerminee);
  913.             if (m_PartieTerminee == false)
  914.                 m_PlateauGraphique->AfficherBouleCouleurAJouer(m_JoueurCourant, m_PartieInterrompue);
  915.             else {
  916.                 m_PlateauGraphique->AfficherBouleCouleurAJouer(m_PlateauInterne->JoueurPrecedent(m_JoueurCourant), m_PartieInterrompue);
  917.                 m_PlateauGraphique->AfficherBouleCouleurAJouer(m_JoueurCourant, m_PartieInterrompue, true);
  918. //                m_PlateauGraphique->EffacerBouleCouleurAJouer();
  919.             }
  920.             if (m_TableauDeplacementJoueurs[m_JoueurCourant]->Ordinateur() == false)
  921.                 ContinuerPartie();
  922.             m_PlateauGraphique->MiseAJourBufferEntier();
  923.             m_Debut = false;
  924.         }
  925.     }
  926. }
  927.  
  928.   ///////////////////////////////////
  929.  // FONCTION "SauvegarderFichier" //
  930. ///////////////////////////////////---
  931. // Sauve une partie dans un fichier --
  932. //------------------------------------
  933. void        // AUCUNE VALEUR DE RETOUR
  934. FenetreAbabelone::SauvegarderFichier(BMessage* message)
  935. // 1 PARAMETRE :                            ENTREE
  936. {
  937.     BEntry entree;
  938.     BPath chemin;
  939.     BFile fichier;
  940.     entry_ref repertoire;
  941.     const char* nom_du_fichier;
  942.     status_t statut;
  943.     int32 max;
  944.     int32 i;
  945.     void* coup_joue;
  946.     char chaine[500];
  947.  
  948.     message->FindRef("directory", 0, &repertoire);
  949.     message->FindString("name", &nom_du_fichier);
  950.     entree.SetTo(&repertoire);
  951.     chemin.SetTo(&entree);
  952.     strcpy(chaine, nom_du_fichier);
  953.     if (strlen(chaine) < strlen(EXTENTION_FICHIER) || strcmp(&(chaine[strlen(chaine)-strlen(EXTENTION_FICHIER)]), EXTENTION_FICHIER))
  954.         strcat(chaine, EXTENTION_FICHIER);
  955.     chemin.Append(chaine);
  956.  
  957.     max = m_ListeCoupsJoues->CountItems();
  958.  
  959.     statut = fichier.SetTo(chemin.Path(), B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
  960.     if (statut != B_OK) {
  961.         sprintf(chaine, "%s \"%s\" %s", m_Textes->Texte(16), chemin.Path(), m_Textes->Texte(19));
  962.         (new BAlert("", chaine, m_Textes->Texte(21), NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT))->Go();
  963.     }
  964.     else {
  965.         strcpy(chaine, ENTETE_FICHIER);
  966.         fichier.Write(chaine, (strlen(ENTETE_FICHIER)+1)*sizeof(char));
  967.         fichier.Write(&m_NombreBoules, sizeof(uint8));
  968.         fichier.Write(&m_NombreJoueurs, sizeof(uint8));
  969.         for (i=0; i < m_NombreJoueurs; i++)
  970.             fichier.Write(&(m_TableauJoueurs[i]), sizeof(uint8));
  971.         fichier.Write(&m_PartieTerminee, sizeof(bool));
  972.         fichier.Write(&max, sizeof(int32));
  973.         for (i=0; i < max; i++) {
  974.             coup_joue = m_ListeCoupsJoues->ItemAt(i);
  975.             fichier.Write(coup_joue, sizeof(type_deplacement));
  976.         }
  977.         fichier.Unset();
  978.     }
  979. }
  980.  
  981.   //////////////////////////////////////////
  982.  // FONCTION "PreparerListeAvantDeJouer" //
  983. //////////////////////////////////////////----------------------------------------------------------------------
  984. // Pr├⌐pare la liste des coups jou├⌐s juste avant de recommencer la partie. C'est-├á-dire efface les coups jou├⌐s --
  985. // apr├¿s la position courante, puisque la partie recommence juste apr├¿s la position courante                  --
  986. //--------------------------------------------------------------------------------------------------------------
  987. void        // AUCUNE VALEUR DE RETOUR
  988. FenetreAbabelone::PreparerListeAvantDeJouer()
  989. // AUCUN PARAMETRE
  990. {
  991.     int32 i, max;
  992.  
  993.     m_ItemCoupSuivant->SetEnabled(false);
  994.     m_ItemCoupSuivantRealiste->SetEnabled(false);
  995.     max = m_ListeCoupsJoues->CountItems();
  996.     for (i = m_NumeroCoupJoueCourant; i < max; i++) {
  997.         m_NumeroCoupJoueCourant = m_ListeCoupsJoues->CountItems();
  998.         m_ListeCoupsJoues->RemoveItem(m_NumeroCoupJoueCourant-1);
  999.     }
  1000.     m_NumeroCoupJoueCourant = m_ListeCoupsJoues->CountItems();
  1001. }
  1002.  
  1003.   //////////////////////////////
  1004.  // FONCTION "AfficherTitre" //
  1005. //////////////////////////////------
  1006. // Affiche le titre de la fen├¬tre --
  1007. //----------------------------------
  1008. void        // AUCUNE VALEUR DE RETOUR
  1009. FenetreAbabelone::AfficherTitre(bool partie_finie)
  1010. // 1 PARAMETRE :                    ENTREE
  1011. {
  1012.     int i;
  1013.     char chaine_titre[500];
  1014.  
  1015.     sprintf(chaine_titre,"%s  -  ", VERSION_ABABELONE);
  1016.     for (i=0; i < m_NombreJoueurs; i++) {
  1017.         if (i != 0)
  1018.             sprintf(chaine_titre,"%s / ", chaine_titre);
  1019.         if (m_TableauJoueurs[i] == 0) {
  1020.             m_TableauDeplacementJoueurs[i] = (DeplacementHumain*)new DeplacementHumain(m_PlateauInterne, m_PlateauGraphique, i);
  1021.             sprintf(chaine_titre,"%s%s", chaine_titre, m_Textes->Texte(24));
  1022.         }
  1023.         else {
  1024.             m_TableauDeplacementJoueurs[i] = (DeplacementOrdinateur*)new DeplacementOrdinateur(m_PlateauInterne, m_PlateauGraphique, i, m_TableauJoueurs[i]);
  1025.             sprintf(chaine_titre,"%s%s", chaine_titre, m_Textes->Texte(25));
  1026.         }
  1027.     }
  1028.     if (partie_finie == true) {
  1029.         strcat(chaine_titre, " ----> ");
  1030.         strcat(chaine_titre, m_Textes->Texte(27));
  1031.         }
  1032.     else
  1033.         if (m_PartieInterrompue == true) {
  1034.             strcat(chaine_titre, " ---- ");
  1035.             strcat(chaine_titre, m_Textes->Texte(26));
  1036.             }
  1037.     SetTitle(chaine_titre);
  1038. }
  1039.  
  1040.   ////////////////////////
  1041.  // FONCTION "APropos" //
  1042. ////////////////////////--------------
  1043. // Affiche la fen├¬tre "A propos..." --
  1044. //------------------------------------
  1045. void        // AUCUNE VALEUR DE RETOUR
  1046. FenetreAbabelone::APropos()
  1047. // AUCUN PARAMETRE
  1048. {
  1049.     char* chaine;
  1050.  
  1051.     chaine = new char[strlen(VERSION_ABABELONE)+strlen(m_Textes->Texte(36))+5];
  1052.     sprintf(chaine,"\t\t%s\n\n%s", VERSION_ABABELONE, m_Textes->Texte(36));
  1053.     (new BAlert("", chaine, m_Textes->Texte(37)))->Go();
  1054.     delete chaine;
  1055. }
  1056.