home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Freelog 17
/
Freelog017.iso
/
BeOS
/
ababelone
/
Sources
/
PlateauDeJeuGraphique.cpp
< prev
next >
Wrap
C/C++ Source or Header
|
2000-11-22
|
26KB
|
663 lines
/*
Copyright (C) 2000 by Hervé PHILIPPE <rv@bemail.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "PlateauDeJeuGraphique.h"
#include "FenetreAbabelone.h" // Pour faire appel aux fonctions "SourisBouton..."
// de la fenêtre FenetreAbabelone
//////////////////////////////////////////////
// CONSTANTE "m_kTableauDirectionGraphique" //
//////////////////////////////////////////////------------------------------------------
// Constante membre en "static" pour définir les 6 déplacements possibles (en pixels) --
//--------------------------------------------------------------------------------------
const BPoint PlateauDeJeuGraphique::m_kTableauDirectionGraphique[6]={
BPoint(-LARGEUR_CASE_BOULE,0),
BPoint(-LARGEUR_CASE_BOULE/2,-HAUTEUR_CASE_BOULE),
BPoint(LARGEUR_CASE_BOULE/2,-HAUTEUR_CASE_BOULE),
BPoint(LARGEUR_CASE_BOULE,0),
BPoint(LARGEUR_CASE_BOULE/2,HAUTEUR_CASE_BOULE),
BPoint(-LARGEUR_CASE_BOULE/2,HAUTEUR_CASE_BOULE)
};
/////////////////////////////////////////////
// CONSTRUCTEUR de "PlateauDeJeuGraphique" //
/////////////////////////////////////////////----------------------------------------------------
// Construit les tableaux dynamiques et les Bitmap, et initialise toutes les variables membres --
//-----------------------------------------------------------------------------------------------
PlateauDeJeuGraphique::PlateauDeJeuGraphique(BRect rect, char *name, TextesDuLogiciel* textes, MenuDynamique* menu_plateau, uint8 nombre_boules, uint8 nombre_joueurs)
// 5 PARAMETRES : ENTREE ENTREE ENTREE ENTREE ENTREE
: PlateauDeJeu(0, nombre_joueurs), // 0 pour pouvoir utiliser "ChangerNombre..." !
BView(rect, name, B_FOLLOW_ALL, B_WILL_DRAW | B_SUBPIXEL_PRECISE /* | B_FULL_UPDATE_ON_RESIZE | B_FRAME_EVENTS*/)
{
int8 i; // Compteur
char chaine_nom_fichier[100]; // Pour le chargement des fichiers Bitmap
m_Textes = textes;
m_MenuPlateauDeJeu = menu_plateau;
m_PlateauBitmap = NULL;
m_TableauBoules = NULL;
ChangerNombreBoules(nombre_boules);
m_TableauSelect = new BRect[3](BOULE_CACHEE);
m_TableauFleches = new BRect[6](BOULE_CACHEE);
m_TableauBoulesEjectees = NULL;
m_CouronneDeLaurier = false;
m_Pause = false;
m_Echelle = 1;
m_BouleCouleurAJouer = -1;
m_TableauChainesJoueurs = NULL;
m_TableauBoulesJoueursBitmap = new (BBitmap*)[NOMBRE_JOUEURS_MAXI];
// Lire les fichiers image pour les images des boules
for (i = 0; i < NOMBRE_JOUEURS_MAXI; i++) {
sprintf(chaine_nom_fichier,"Images/Boule joueur n┬░%d",i+1);
m_TableauBoulesJoueursBitmap[i] = BTranslationUtils::GetBitmap(chaine_nom_fichier);
}
m_TableauFlechesBitmap = new (BBitmap*)[6];
// Lire les fichiers image pour les images des flèches
for (i = 0; i < 6; i++) {
sprintf(chaine_nom_fichier,"Images/Flèche n°%d",i);
m_TableauFlechesBitmap[i] = BTranslationUtils::GetBitmap(chaine_nom_fichier);
}
m_TableauSelectBitmap = new (BBitmap*)[3];
// Lire les fichiers image pour les images des sélections
for (i = 0; i < 3; i++) {
sprintf(chaine_nom_fichier,"Images/Sélection n°%d",i);
m_TableauSelectBitmap[i] = BTranslationUtils::GetBitmap(chaine_nom_fichier);
}
m_CouronneDeLaurierBitmap = BTranslationUtils::GetBitmap("Images/Couronne de laurier");
m_BufferBitmap = new BBitmap(rect, B_RGB32, true);
ChangerPlateauDeJeu();
SetViewColor(B_TRANSPARENT_COLOR);
}
////////////////////////////////////////////
// DESTRUCTEUR de "PlateauDeJeuGraphique" //
////////////////////////////////////////////-------
// Détruit les tableaux dynamiques et les Bitmap --
//-------------------------------------------------
PlateauDeJeuGraphique::~PlateauDeJeuGraphique()
// AUCUN PARAMETRE
{
int i;
// Détruire "m_TableauChainesJoueurs" s'il a été créé
ChangerTypeJoueurs(m_NombreJoueurs, NULL, NULL);
// Détruire les fichiers Bitmap des images des sélections
for (i = 0; i < 3; i++)
delete m_TableauSelectBitmap[i];
delete m_TableauSelectBitmap;
// Détruire les fichiers Bitmap des images des flèches
for (i = 0; i < 6; i++)
delete m_TableauFlechesBitmap[i];
delete m_TableauFlechesBitmap;
// Détruire les fichiers Bitmap des images des boules
for (i = 0; i < NOMBRE_JOUEURS_MAXI; i++)
delete m_TableauBoulesJoueursBitmap[i];
delete m_TableauBoulesJoueursBitmap;
delete m_BufferBitmap;
delete m_PlateauBitmap;
delete m_TableauBoules;
}
/////////////////////
// FONCTION "Draw" //
/////////////////////------------------------------------------------------------------
// Redessine une partie (ou la totalité) du plateau de jeu (en se servant du buffer) --
//-------------------------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::Draw(BRect updateRect)
// 1 PARAMETRE : ENTREE
{
if (m_BufferBitmap != NULL && m_BufferBitmap->Lock()) {
DrawBitmap(m_BufferBitmap,updateRect,updateRect);
m_BufferBitmap->Unlock();
}
}
//////////////////////////////////////
// FONCTION "MiseAJourBufferEntier" //
//////////////////////////////////////---------------------------------
// Met à jour TOUT le buffer servant à l'affichage du plateau de jeu --
//---------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::MiseAJourBufferEntier()
// AUCUN PARAMETRE
{
MiseAJourBuffer(m_PlateauBitmap->Bounds());
}
////////////////////////////////
// FONCTION "MiseAJourBuffer" //
////////////////////////////////--------------------------------------------------------------
// Met à jour une partie du buffer (ou la totalité) servant à l'affichage du plateau de jeu --
//--------------------------------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::MiseAJourBuffer(BRect updateRect)
// 1 PARAMETRE : ENTREE
{
int i;
BPoint position_texte;
if (Window()->Lock()) {
BView vue(Bounds(), NULL, B_FOLLOW_ALL, B_WILL_DRAW | B_SUBPIXEL_PRECISE);
if (m_BufferBitmap->Lock()) {
vue.SetViewColor(B_TRANSPARENT_COLOR);
vue.SetDrawingMode(B_OP_ALPHA);
vue.SetBlendingMode(B_PIXEL_ALPHA,B_ALPHA_OVERLAY);
m_BufferBitmap->AddChild(&vue);
vue.SetScale(m_Echelle);
vue.DrawBitmapAsync(m_PlateauBitmap, updateRect, updateRect);
if (m_BouleCouleurAJouer != -1 && updateRect.Intersects(RECT_BOULE_COULEUR_A_JOUER)) {
vue.DrawBitmapAsync(m_TableauBoulesJoueursBitmap[m_BouleCouleurAJouer], RECT_BOULE_COULEUR_A_JOUER);
if (m_CouronneDeLaurier == true)
vue.DrawBitmapAsync(m_CouronneDeLaurierBitmap, RECT_COURONNE_DE_LAURIER);
else
if (m_Pause == true) {
vue.SetFontSize(20);
vue.SetHighColor(255,0,0);
position_texte = RECT_BOULE_COULEUR_A_JOUER.LeftBottom();
position_texte.x += 10;
position_texte.y += -RECT_BOULE_COULEUR_A_JOUER.Height()/2+8;
vue.DrawString(m_Textes->Texte(26), position_texte);
}
}
if (m_TableauChainesJoueurs != NULL && updateRect.Intersects(RECT_JOUEURS)) {
vue.SetFontSize(20);
vue.SetHighColor(255,255,0);
position_texte = RECT_JOUEURS.LeftTop();
if (m_NombreJoueurs == 2)
position_texte.y += HAUTEUR_BOULE + 10;
for (i=0; i < m_NombreJoueurs; i++) {
vue.DrawBitmapAsync(m_TableauBoulesJoueursBitmap[i], BRect(position_texte.x,position_texte.y,position_texte.x+LARGEUR_PETITE_BOULE,position_texte.y+HAUTEUR_PETITE_BOULE));
position_texte.x += LARGEUR_PETITE_BOULE + 5;
position_texte.y += (HAUTEUR_BOULE+10)/2 - 10;
vue.DrawString(m_TableauChainesJoueurs[i], position_texte);
position_texte.x -= LARGEUR_PETITE_BOULE + 5;
position_texte.y += (HAUTEUR_BOULE+10)/2 + 10;
}
}
if (m_TableauBoulesEjectees != NULL) {
vue.SetFontSize(20);
vue.SetHighColor(255,255,0);
position_texte.y = 400;
position_texte.x = 40;
for (i=0; i < m_NombreJoueurs; i++) {
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));
vue.DrawChar(m_TableauBoulesEjectees[i]+'0', position_texte);
position_texte.x += LARGEUR_BOULE + 8;
}
}
for (i = 0; i < m_NombreBoules; i++)
if (m_TableauBoules[i] != BOULE_CACHEE && updateRect.Intersects(m_TableauBoules[i]))
vue.DrawBitmapAsync(m_TableauBoulesJoueursBitmap[CouleurBoule(i+1)], m_TableauBoules[i]);
for (i = 0; i < 3; i++)
if (m_TableauSelect[i] != BOULE_CACHEE && updateRect.Intersects(m_TableauSelect[i]))
vue.DrawBitmapAsync(m_TableauSelectBitmap[i], m_TableauSelect[i]);
for (i = 0; i < 6; i++)
if (m_TableauFleches[i] != BOULE_CACHEE && updateRect.Intersects(m_TableauFleches[i]))
vue.DrawBitmapAsync(m_TableauFlechesBitmap[i], m_TableauFleches[i]);
vue.Sync();
m_BufferBitmap->RemoveChild(&vue);
m_BufferBitmap->Unlock();
Draw(ConvertirAvecEchelle(updateRect));
}
Window()->Unlock();
}
}
///////////////////////////////
// FONCTION "ChangerEchelle" //
///////////////////////////////-------------
// Change l'échelle servant à l'affichage --
//------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::ChangerEchelle(float echelle)
// 1 PARAMETRE : ENTREE
{
m_Echelle = echelle;
}
//////////////////////////
// FONCTION "MouseDown" //
//////////////////////////---------------------------------------------------
// Traite le cas o├╣ l'utilisateur appuie sur un bouton de la souris --
// Si c'est le bouton gauche, la fonction "SourisBoutonGaucheAppuye" --
// de la classe "FenetreAbabelone" sera exécutée --
// Si c'est le bouton droit, ce sera la fonction "SourisBoutonDroitAppuye" --
//---------------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::MouseDown(BPoint where)
// 1 PARAMETRE : ENTREE
{
BPoint where_temp;
uint32 bouton;
GetMouse(&where_temp, &bouton);
if (bouton == B_PRIMARY_MOUSE_BUTTON)
((FenetreAbabelone*)Window())->SourisBoutonGaucheAppuye(ConvertirAvecEchelleInverse(where));
else
if (bouton == B_SECONDARY_MOUSE_BUTTON)
((FenetreAbabelone*)Window())->SourisBoutonDroitAppuye();
}
////////////////////////
// FONCTION "MouseUp" //
////////////////////////-------------------------------------------------------------
// Traite le cas où l'utilisateur relâche un bouton de la souris --
// La fonction "SourisBoutonRelache" de la classe "FenetreAbabelone" sera exécutée --
//-----------------------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::MouseUp(BPoint where)
// 1 PARAMETRE : ENTREE
{
((FenetreAbabelone*)Window())->SourisBoutonRelache(ConvertirAvecEchelleInverse(where));
}
///////////////////////////
// FONCTION "MouseMoved" //
///////////////////////////---------------------------------------------------------------
// Traite le cas o├╣ l'utilisateur bouge la souris en dehors de la vue du plateau de jeu --
// La fonction "SourisBoutonRelache" de la classe "FenetreAbabelone" sera exécutée --
//----------------------------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::MouseMoved(BPoint where, uint32 transit, const BMessage *message)
// 3 PARAMETRES : ENTREE ENTREE ENTREE
{
if (transit == B_EXITED_VIEW)
((FenetreAbabelone*)Window())->SourisBoutonRelache(ConvertirAvecEchelleInverse(where));
}
//////////////////////////////////
// FONCTION "SetBouleInvisible" //
//////////////////////////////////
// Rend une boule invisible --
//-----------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::SetBouleInvisible(int8 numero_boule)
// 1 PARAMETRE : ENTREE
{
m_TableauBoules[numero_boule-1] = BOULE_CACHEE;
}
/////////////////////////////
// FONCTION "BouleVisible" //
/////////////////////////////----------------------------------------------------------------
// Renvoie l'information selon laquelle une boule est visible (true) ou invisible (false) --
//-------------------------------------------------------------------------------------------
bool // VALEUR DE RETOUR
PlateauDeJeuGraphique::BouleVisible(int8 numero_boule)
// 1 PARAMETRE : ENTREE
{
return m_TableauBoules[numero_boule-1] != BOULE_CACHEE;
}
//////////////////////
// FONCTION "Boule" //
//////////////////////-------------------
// Renvoie les coordonnées d'une boule --
//---------------------------------------
BRect // VALEUR DE RETOUR
PlateauDeJeuGraphique::Boule(int8 numero_boule)
// 1 PARAMETRE : ENTREE
{
return m_TableauBoules[numero_boule-1];
}
//////////////////////////////
// FONCTION "DeplacerBoule" //
//////////////////////////////-----------------------------------------
// Déplace graphiquement une boule (avec delta_x et delta_y) --
// Renvoie le rectangle de mise à jour pour le buffer de la fenêtre --
//---------------------------------------------------------------------
BRect // VALEUR DE RETOUR
PlateauDeJeuGraphique::DeplacerBoule(int8 numero_boule, int delta_x, int delta_y)
// 3 PARAMETRES : ENTREE ENTREE ENTREE
{
BRect position_union = m_TableauBoules[numero_boule-1];
m_TableauBoules[numero_boule-1].OffsetBy(delta_x, delta_y);
return position_union | m_TableauBoules[numero_boule-1];
}
/////////////////////////
// FONCTION "SetBoule" //
/////////////////////////---------------
// Change les coordonnées d'une boule --
//--------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::SetBoule(int8 numero_boule, const BRect& rect)
// 2 PARAMETRES : ENTREE ENTREE (@)
{
m_TableauBoules[numero_boule-1] = rect;
}
/////////////////////////////////
// FONCTION "SetPositionBoule" //
/////////////////////////////////-------------------------------------
// Déplace graphiquement une boule (vers un BPoint) --
// Renvoie le rectangle de mise à jour pour le buffer de la fenêtre --
//--------------------------------------------------------------------
BRect // VALEUR DE RETOUR
PlateauDeJeuGraphique::SetPositionBoule(int8 numero_boule, const BPoint& point)
// 2 PARAMETRES : ENTREE ENTREE (@)
{
BRect position_union = m_TableauBoules[numero_boule-1];
m_TableauBoules[numero_boule-1].OffsetTo(point);
return position_union | m_TableauBoules[numero_boule-1];
}
///////////////////////////////
// FONCTION "AfficherSelect" //
///////////////////////////////------------------------------------------
// Affiche l'image de la sélection (n°1, 2 ou 3) au-dessus d'une boule --
// Met à jour le buffer de la fenêtre --
//-----------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::AfficherSelect(uint8 numero_select, int8 numero_boule)
// 2 PARAMETRES : ENTREE ENTREE
{
BRect position = Boule(numero_boule);
m_TableauSelect[numero_select-1] = position;
MiseAJourBuffer(position);
}
//////////////////////////////
// FONCTION "EffacerSelect" //
//////////////////////////////--------------------
// Efface l'image de la sélection (n°1, 2 ou 3) --
// Met à jour le buffer de la fenêtre --
//------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::EffacerSelect(uint8 numero_select)
// 1 PARAMETRE : ENTREE
{
BRect ancienne_position = m_TableauSelect[numero_select-1];
if (ancienne_position != BOULE_CACHEE) {
m_TableauSelect[numero_select-1] = BOULE_CACHEE;
MiseAJourBuffer(ancienne_position);
}
}
///////////////////////////////
// FONCTION "AfficherFleche" //
///////////////////////////////-------------------------
// Affiche l'image d'une flèche au-dessus d'une boule --
// Met à jour le buffer de la fenêtre --
//------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::AfficherFleche(uint8 numero_fleche, int8 numero_boule)
// 2 PARAMETRES : ENTREE ENTREE
{
BRect position = Boule(numero_boule);
position.OffsetBy(m_kTableauDirectionGraphique[numero_fleche]);
m_TableauFleches[numero_fleche] = position;
MiseAJourBuffer(position);
}
//////////////////////////////
// FONCTION "EffacerFleche" //
//////////////////////////////-----------
// Efface l'image d'une flèche --
// Met à jour le buffer de la fenêtre --
//---------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::EffacerFleche(uint8 numero_fleche)
// 1 PARAMETRE : ENTREE
{
BRect ancienne_position = m_TableauFleches[numero_fleche];
if (ancienne_position != BOULE_CACHEE) {
m_TableauFleches[numero_fleche] = BOULE_CACHEE;
MiseAJourBuffer(ancienne_position);
}
}
///////////////////////
// FONCTION "Fleche" //
///////////////////////------------------------------
// Renvoie les coordonnées graphiques d'une flèche --
//---------------------------------------------------
BRect // VALEUR DE RETOUR
PlateauDeJeuGraphique::Fleche(uint8 numero_fleche)
// 1 PARAMETRE : ENTREE
{
return m_TableauFleches[numero_fleche];
}
//////////////////////////////////////////
// FONCTION "EffacerToutSelectEtFleche" //
//////////////////////////////////////////-------------------------------
// Efface les images de toutes les sélections et de toutes les flèches --
//-----------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::EffacerToutSelectEtFleche()
// AUCUN PARAMETRE
{
int i;
for (i = 0; i < 6; i++)
EffacerFleche(i);
for (i = 1; i < 4; i++)
EffacerSelect(i);
}
//////////////////////////////////////////
// FONCTION "InitialiserSelectEtFleche" //
//////////////////////////////////////////------------------------------------------------
// Initialise les tableaux de coordonnées pour les images des sélections et des flèches --
//----------------------------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::InitialiserSelectEtFleche()
// AUCUN PARAMETRE
{
int8 i;
for (i = 0; i < 6; i++)
m_TableauFleches[i] = BOULE_CACHEE;
for (i = 0; i < 3; i++)
m_TableauSelect[i] = BOULE_CACHEE;
}
///////////////////////////////////
// FONCTION "DirectionGraphique" //
///////////////////////////////////---------------------
// Renvoie les coordonnées graphiques d'une direction --
//------------------------------------------------------
BPoint // VALEUR DE RETOUR
PlateauDeJeuGraphique::DirectionGraphique(int8 direction)
// 1 PARAMETRE : ENTREE
{
return m_kTableauDirectionGraphique[direction];
}
///////////////////////////////////////////
// FONCTION "AfficherBouleCouleurAJouer" //
///////////////////////////////////////////----------------
// Affiche la boule qui indique le joueur qui doit jouer --
// Met à jour le buffer de la fenêtre --
//---------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::AfficherBouleCouleurAJouer(int8 couleur, bool pause, bool couronne_de_laurier)
// 1 PARAMETRE : ENTREE ENTREE ENTREE
{
m_Pause = pause;
m_CouronneDeLaurier = couronne_de_laurier;
if (m_CouronneDeLaurier == false)
m_BouleCouleurAJouer = couleur;
MiseAJourBuffer(RECT_COURONNE_DE_LAURIER);
}
//////////////////////////////////////////
// FONCTION "EffacerBouleCouleurAJouer" //
//////////////////////////////////////////----------------
// Efface la boule qui indique le joueur qui doit jouer --
// Met à jour le buffer de la fenêtre --
//--------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::EffacerBouleCouleurAJouer()
// AUCUN PARAMETRE
{
m_BouleCouleurAJouer = -1;
MiseAJourBuffer(RECT_BOULE_COULEUR_A_JOUER);
}
////////////////////////////////////
// FONCTION "ChangerNombreBoules" //
////////////////////////////////////----------------------------------
// Change le nombre total de boules et change le tableau de boules --
//--------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::ChangerNombreBoules(uint8 nombre_boules)
// 1 PARAMETRE : ENTREE
{
if (nombre_boules != m_NombreBoules) {
PlateauDeJeu::ChangerNombreBoules(nombre_boules);
if (m_TableauBoules != NULL) {
delete m_TableauBoules;
m_TableauBoules = NULL; // Pas nécessaire
}
m_TableauBoules = new BRect[m_NombreBoules](BOULE_CACHEE);
}
}
///////////////////////////////////
// FONCTION "ChangerTypeJoueurs" //
///////////////////////////////////---------------------------------------------------------
// Change le tableau des chaînes de caractères des joueurs et change (éventuellement) le --
// nombre total de joueurs --
//------------------------------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::ChangerTypeJoueurs(uint8 nombre_joueurs, uint8* tableau_joueurs, uint8* tableau_boules_ejectees)
// 3 PARAMETRES : ENTREE ENTREE ENTREE
{
int i;
char chaine[100];
m_TableauBoulesEjectees = tableau_boules_ejectees;
if (m_TableauChainesJoueurs != NULL) {
for (i=0; i < m_NombreJoueurs; i++)
delete[] m_TableauChainesJoueurs[i];
delete[] m_TableauChainesJoueurs;
m_TableauChainesJoueurs = NULL; // Pas nécessaire
}
if (nombre_joueurs != m_NombreJoueurs)
PlateauDeJeu::ChangerNombreJoueurs(nombre_joueurs);
if (tableau_joueurs != NULL) {
m_TableauChainesJoueurs = new char*[m_NombreJoueurs];
for (i=0; i < m_NombreJoueurs; i++) {
if (tableau_joueurs[i] == 0)
sprintf(chaine,"%s%d : %s", m_Textes->Texte(32), i+1, m_Textes->Texte(24));
else
sprintf(chaine,"%s%d : %s %s %d", m_Textes->Texte(32), i+1, m_Textes->Texte(25), m_Textes->Texte(29), tableau_joueurs[i]);
m_TableauChainesJoueurs[i] = new char[strlen(chaine)+1];
strcpy(m_TableauChainesJoueurs[i], chaine);
}
MiseAJourBuffer(RECT_JOUEURS);
}
}
////////////////////////////////////
// FONCTION "ChangerPlateauDeJeu" //
////////////////////////////////////--------------------------------------------------------
// Change l'image du plateau de jeu --
//------------------------------------------------------------------------------------------
void // AUCUNE VALEUR DE RETOUR
PlateauDeJeuGraphique::ChangerPlateauDeJeu(uint8 numero_plateau_de_jeu)
// 1 PARAMETRE : ENTREE
{
BBitmap* ancien_plateau_de_jeu;
entry_ref entree_ref;
uint8 ancien_numero_fichier = m_MenuPlateauDeJeu->NumeroFichier();
ancien_plateau_de_jeu = m_PlateauBitmap;
(m_MenuPlateauDeJeu->SelectionnerFichier(numero_plateau_de_jeu)).GetRef(&entree_ref);
m_PlateauBitmap = BTranslationUtils::GetBitmap(&entree_ref);
if (m_PlateauBitmap == NULL) {
if (ancien_plateau_de_jeu == NULL)
m_PlateauBitmap = new BBitmap(m_BufferBitmap->Bounds(), B_RGB32, true);
else
m_PlateauBitmap = ancien_plateau_de_jeu;
m_MenuPlateauDeJeu->SelectionnerFichier(ancien_numero_fichier);
}
else {
if (numero_plateau_de_jeu != 0)
MiseAJourBufferEntier();
if (ancien_plateau_de_jeu != NULL)
delete ancien_plateau_de_jeu;
}
}
///////////////////////
// FONCTION "Buffer" //
///////////////////////--------------------------
// Renvoie le pointeur du buffer de la fenêtre --
//-----------------------------------------------
BBitmap* // VALEUR DE RETOUR
PlateauDeJeuGraphique::Buffer()
// AUCUN PARAMETRE
{
return m_BufferBitmap;
}
/////////////////////////////////////
// FONCTION "ConvertirAvecEchelle" //
/////////////////////////////////////--------------------------
// Calcule la taille d'un rectangle en fonction de l'échelle --
// Renvoie le rectangle convertit --
//-------------------------------------------------------------
BRect // VALEUR DE RETOUR
PlateauDeJeuGraphique::ConvertirAvecEchelle(const BRect& rect)
// 1 PARAMETRE : ENTREE (@)
{
BRect nouv_rect = rect;
nouv_rect.left *= m_Echelle;
nouv_rect.right *= m_Echelle;
nouv_rect.top *= m_Echelle;
nouv_rect.bottom *= m_Echelle;
return nouv_rect;
}
////////////////////////////////////////////
// FONCTION "ConvertirAvecEchelleInverse" //
////////////////////////////////////////////---------------------
// Calcule les coordonnées d'un point en fonction de l'échelle --
// Renvoie les coordonnées du point convertit --
//---------------------------------------------------------------
BPoint // VALEUR DE RETOUR
PlateauDeJeuGraphique::ConvertirAvecEchelleInverse(const BPoint& position)
// 1 PARAMETRE : ENTREE (@)
{
BPoint nouv_position = position;
nouv_position.x /= m_Echelle;
nouv_position.y /= m_Echelle;
return nouv_position;
}