Réplique du jeu de société buvette poursuite fait en vc++ 6 avec glut
Bien marrant pour commencer une soirée
Source / Exemple :
/*----------------------------------------------------------
--------------CGame-------------CPlateau------------CLaRoue-----------CQuartierRoue
| | | ^
| | | |
| | | -----------------------------------
| | | | | |
CMenu CPlayer CCase CQuartierTGenerale CQuartierTLMonde .....
^ ^
| |
-------------- ---------------------------
| | | | |
CMenuGlut CMenuConsole CCaseNoGage CCaseLaRoue ....
//-----------------------------------------------------------
v1.0.0 : 1/12/08
- Base du jeu
v1.1.0 : 2/12/08
- Gestion de plusieurs joueurs sur la meme case
(il ne se superpose plus) 5 joueurs max par case
v1.1.1 : 10/12/08
- Ajout des commentaires
- Amelioration du systeme de blocage du clavier
- Creation des classes menu et deplacement
du code dans ces classes
- Quelques autres corrections minimes
-------------------------------------------------------------
/*-------------------------------------------
Classe principale du jeu
elle contient les callback de glut et s'occupe
de gerer l'initialisation du jeu
--------------------------------------------*/
class CGame
{
public:
CGame();
virtual ~CGame();
//initialise le jeu (glut notament), demande
//demande le nbr et le nom(facultatif) des joueurs
void InitGame(int argc, char **argv);
//appeler a chaque fois que la callback display
//de glut est appelé, s'occupe d'afficher les informations
//(joueur en cour, score du des) et
//Apelle les fct draw des objets plateau, roue, joueur et case
void Draw();
//appeler lorsque le joueur appui sur j ou J
//lance la partie : cherche le joueur en cour puis
//appele sa methode joue
void Joue();
//met a jour la variable du score
void SetScore(int iScore);
//Bloque les touches lorsque une animation et en cour
//(sauf la touche q pour quitter)
void Block(bool bBlock);
//retourne vrai si les touches sot bloquer
bool IsBlocked() {return m_bBlock;}
//met a jour la variable du resultat de la roue
void SetRoueResult(std::string strRoueRsl);
//Apeller lorsqu'un joueur a gagner
void SetWinPlayer(CPlayer * pPlayer);
//gestion du menu
CMenu * GetGameMenu(){return m_pMenu;}
void SetShowMenu(bool bShow){m_bShowMenu = bShow;}
bool GetShowMenu() {return m_bShowMenu;}
private:
void DrawScore();//Affiche le dernier score du des
void DrawPlayerInGame();//affiche le nom du joueur en cour
void DrawPlayerLegend();//affiche le nom des joueur en face de leurs couleurs
void DrawRoueGage();//Affiche le dernier gage de la roue
private :
int m_iActPlayer;//Num du joueur actuel (pos ds la liste PlayerList)
std::vector<CPlayer*> m_PlayerList;//liste des joueurs
CPlayer * m_pActPlayer;//ptr vers le joueur en cour
CPlateau m_Plateau;//plateu du jeu
bool m_bShowMenu;//a vrai si on doit afficher le menu
bool m_bBlock;//a vrai si les touches sont bloquer
int m_bScore;//score du dernier lancer de des
CMenu * m_pMenu;//Menu du jeu
std::string m_strRoueRsl;//Rsl de la roue en texte
};
/*------------------------------------------------
Represente une case sur le jeu (il y en a 25)
Chaque case contient la liste des joueurs
actuelement posés sur elle
------------------------------------------------*/
class CPlayer;
class CCase
{
public:
CCase();
virtual ~CCase();
//Dessine la case
virtual void Draw(float x, float y);
//dessine le titre pour la case
virtual void DrawTitle() = 0;
//retourne le type de case
virtual int GetCaseType();
void GetCoord(float * x, float * y, CPlayer * pPlayer);
//Appeler lorsque un joueur arrive sur la case
void AddPlayer(CPlayer * pPlayer);
//Appeller lorsq'un joueur quitte la case
void DelPlayer(CPlayer * pPlayer);
private:
int m_NbPlayerOnCase;//nbr de joueur sur la case
protected :
//Coord de la case (par rapport au point de base)
float m_fXCoord;
float m_fYCoord;
char m_csTitle[20];//titre pour la case
//liste des joueurs actuellemnt sur la case
std::vector<CPlayer*> m_PlayerList;
};
/*************************************************/
class CCaseNoGage : public CCase
{
public:
CCaseNoGage() : CCase(){}
virtual void Draw(float x, float y)
{
glColor3f(1,1,0);//jaune
CCase::Draw(x,y);//appele le draw de la classe de base
}
virtual void DrawTitle()
{
return ; //on ecrit rien
}
virtual int GetCaseType(){return TYPE_NO_GAGE;}
};
/*************************************************/
class CCaseLaRoue : public CCase
{
public:
CCaseLaRoue() : CCase(){}
virtual void Draw(float x, float y)
{
glColor3f(1,0.5,0);//orange
CCase::Draw(x,y);
}
virtual void DrawTitle()
{
glColor3f(1,1,1);
strcpy(m_csTitle,"La roue");
CToolBox::render_string(m_fXCoord,m_fYCoord,GLUT_BITMAP_TIMES_ROMAN_24,m_csTitle);
}
virtual int GetCaseType(){return TYPE_LA_ROUE;}
};
/*************************************************/
class CCaseRecule : public CCase
{
public:
CCaseRecule() : CCase(){}
virtual void Draw(float x, float y)
{
glColor3f(0,0,1);//bleu
CCase::Draw(x,y);
}
virtual void DrawTitle()
{
glColor3f(1,1,1);
strcpy(m_csTitle,"Recule de 6 cases");
CToolBox::render_string(m_fXCoord,m_fYCoord,GLUT_BITMAP_TIMES_ROMAN_24,"Recule de");
glLoadIdentity();
CToolBox::render_string(m_fXCoord-0.9,m_fYCoord-0.48,GLUT_BITMAP_TIMES_ROMAN_24," 6 cases ");
}
virtual int GetCaseType(){return TYPE_RECULE_6_CASE;}
};
/*************************************************/
class CCaseAvance : public CCase
{
public:
CCaseAvance() : CCase(){}
virtual void Draw(float x, float y)
{
glColor3f(0,1,0);//Vert
CCase::Draw(x,y);
}
virtual void DrawTitle()
{
glColor3f(1,1,1);
strcpy(m_csTitle,"Avance de 3 cases");
CToolBox::render_string(m_fXCoord,m_fYCoord,GLUT_BITMAP_TIMES_ROMAN_24,"Avance de");
glLoadIdentity();
CToolBox::render_string(m_fXCoord-0.9,m_fYCoord-0.48,GLUT_BITMAP_TIMES_ROMAN_24," 3 cases ");
}
virtual int GetCaseType(){return TYPE_AVANCE_3_CASE;}
};
/*************************************************/
class CCasePasseTour : public CCase
{
public:
CCasePasseTour() : CCase(){}
virtual void Draw(float x, float y)
{
glColor3f(1,0,0);//Rouge
CCase::Draw(x,y);
}
virtual void DrawTitle()
{
glColor3f(1,1,1);
strcpy(m_csTitle,"Passe ton tour");
CToolBox::render_string(m_fXCoord,m_fYCoord,GLUT_BITMAP_TIMES_ROMAN_24,"Passe ton");
glLoadIdentity();
CToolBox::render_string(m_fXCoord-0.9,m_fYCoord-0.48,GLUT_BITMAP_TIMES_ROMAN_24," tour ");
}
virtual int GetCaseType(){return TYPE_PASSE_TOUR;}
};
/*************************************************/
class CCaseRetDepart : public CCase
{
public:
CCaseRetDepart() : CCase(){}
virtual void Draw(float x, float y)
{
glColor3f(1,0,1);
CCase::Draw(x,y);
}
virtual void DrawTitle()
{
glColor3f(1,1,1);
strcpy(m_csTitle,"Retour case depart");
CToolBox::render_string(m_fXCoord-0.02,m_fYCoord,GLUT_BITMAP_TIMES_ROMAN_24,"Retour case");
glLoadIdentity();
CToolBox::render_string(m_fXCoord-0.9,m_fYCoord-0.48,GLUT_BITMAP_TIMES_ROMAN_24," depart ");
}
virtual int GetCaseType(){return TYPE_RETOUR_DEPART;}
};
/*---------------------------------------------------
Classe la roue, affiche la roue et gere l'annimation
Contient les quartiers de la roue (8 en tout)
et le thread qui gere l'animation
---------------------------------------------------*/
class CPlayer;
class CPlateau;
class CRoueThread;
class CLaRoue
{
//permet a la classe CRoueThread
//d'acceder au membres priver de la roue
friend class CRoueThread;
public:
CLaRoue();
virtual ~CLaRoue();
//permet d'initialiser le ptr vers le plateau
void SetPlateau(CPlateau * pPlateau);
//lance la roue (l'animation)
void LanceRoue(CPlayer * pPlayer);
//Dessine la roue
void Draw();
private :
std::vector<CQuartierRoue*> m_ListQuartier;//Liste des quatier
int m_iRsl; // resultat de la roue
CPlateau * m_pPlateau;//ptr vers la plateau
CPlayer * m_pGamePlayer;//ptr vers le jeu
CRoueThread * m_pThread;//ptr ver le thread pour l'animation
};
//-------------------------------------------------------
class CRoueThread
{
public:
CRoueThread(CLaRoue * pLaRoue)
{
m_dwID = 0;
m_hThread = 0;
m_pLaRoue = pLaRoue;
}
~CRoueThread()
{
CloseHandle(m_hThread);
}
bool InitThread()
{
m_hThread = CreateThread(0,
0,
ThreadFunc,
this,
0,
&m_dwID);
if(!m_hThread)
{
// Impossible de créer le thread !
return false;
}
return true;
}
public:
HANDLE m_hThread;
private:
DWORD m_dwID;
CLaRoue * m_pLaRoue;
static DWORD WINAPI ThreadFunc(LPVOID pvParam);
};
/*-----------------------------------------------
Classe plateau, (gere les elements du plateau
cases et roue
Contient la liste des cases et la roue
Initialise et dessine les cases
-----------------------------------------------*/
class CPlayer;
class CGame;
class CPlateau
{
public:
CPlateau();
virtual ~CPlateau();
void SetGame(CGame * pGame);
CGame * GetGame();
//Dessine les cases
void Draw();
//retourne un ptr vers la case a la position iPos
CCase * GetCaseInPos(int iPos);
void SetScore(int iScore);
//bloque les touches
void Block(bool bBlock);
//appeler si un joueur tombe sur une case "la roue"
int LanceRoue(CPlayer * pPlayer);
private:
std::vector<CCase*> m_ListeCase;//liste des cases
CGame * m_pGame; // ptr vers le jeu
CLaRoue m_LaRoue;
};
/*----------------------------------------------------------
Classe player gere un joueur (representer par un rond)
analyse les resultats des cases ou de la roue
Gere le des (moyen devrait etre gerer par le plateau)
----------------------------------------------------------*/
class CPlayerThread;//forward declaration
class CPlayer
{
public:
//Param : ptr vers le plateau, couleur rgb, nom du joueur
CPlayer(CPlateau * pPlateau, float fR,float fG, float fB,std::string strPlayer);
virtual ~CPlayer();
//Dessine le joueur (le rond) a la postion qu'il faut
//definit par m_fPlayerPosY et m_fPlayerPosX
//cette fct et appeler a chaque redisplay de glut
void Draw();
//joue le tour (lance le des et met a jour la pos du joueur)
void Joue();
//dessine la legende (en bas a droite)
void DrawLegend(float x,float y);
//analyse le resultat apres avoir joué
void AnalyseRsl();
//appeler lorsque la roue a été lancer (aux cas ou
//il faille réactualiser la pos du joueur)
void SetRoueResult(int iRsl);
//dessine l'animation lorsque le joueur arrive sur un case
//(le rond qui rapettise)
void DrawAnim();
//retourne vrai si le joueur doit passer sont tour
bool GetIsPasseTour();
//remet a jour le joueur pour une nouvelle partie
void Restart();
//retourne un ptr vers le plateau
CPlateau * GetPlateau () {return m_pPlateau;}
//initialise le ptr vers le plateau
void SetPlateau(CPlateau * pPlateau){m_pPlateau = pPlateau;}
//retourne le nom du joueur
std::string GetPlayerName(){ return m_strPlayer;}
private:
int LanceLeDes();
//Met a jour la position du joueur
void SetPlayerPos(int iNbDes);
private:
bool m_bPasseTour;//a vrai si le joueur passe son tour
std::string m_strPlayer;//nom du joueur
//position par rapport aux coord reference
float m_fPlayerPosY;
float m_fPlayerPosX;
int m_iPosPlayer;//pos du joueur (en nbr de case)
CCase * m_pCase;//ptr vers la case actuelle du joueur
CPlateau * m_pPlateau;// ptr vers le plateau
//Couleur du joueur RGB
float m_fR;
float m_fG;
float m_fB;
float m_fSphereOffset;
//thread associer au joueur (pour l'animation)
CPlayerThread * m_pThread;
};
//-------------------------------------------------------
class CPlayerThread
{
public:
CPlayerThread(CPlayer * pPlayer)
{
m_dwID = 0;
m_hThread = 0;
m_pPlayer = pPlayer;
}
~CPlayerThread()
{
CloseHandle(m_hThread);
}
bool InitThread()
{
m_hThread = CreateThread(0,
0,
ThreadFunc,
this,
0,
&m_dwID);
if(!m_hThread)
{
// Impossible de créer le thread !
return false;
}
return true;
}
public:
HANDLE m_hThread;
private:
DWORD m_dwID;
CPlayer * m_pPlayer;
static DWORD WINAPI ThreadFunc(LPVOID pvParam);
};
/*---------------------------------------------
Represente un quartier de la roue
chaque type de quartier et representer par
une classe (herité de celle la) et un type
-----------------------------------------------*/
class CQuartierRoue
{
public:
CQuartierRoue(float x, float y,float xOffset, float yOffset);
virtual ~CQuartierRoue();
virtual void Draw() = 0;
virtual int GetType() = 0;
void DrawLed();
void SetDrawLed(bool bDraw);
//Dessine l'animation de fin
void DrawIsEnd();
std::string GetGageStr();
private:
bool GetDrawLed();
protected:
//Offset sur le diametere de la led
float m_fSphereOffset;
//Coord du quartier (pour ecrire le titre du quartier)
float m_fXCoord;
float m_fYCoord;
//Offset pour la position de la led
float m_fXLedOffset;
float m_fYLedOffset;
//a vrai si on dessine la led sur le quartier
bool m_bDrawLed;
//Titre du gage
std::string m_strNomGage;
};
//----------------------------------------------------
class CQuartierCulSec : public CQuartierRoue
{
public:
CQuartierCulSec(float x, float y,float xOffset, float yOffset) : CQuartierRoue(x,y,xOffset,yOffset)
{
m_strNomGage = "Boit ton verre cul sec";
}
virtual int GetType() {return QUATIER_CULSEC;}
virtual void Draw()
{
glTranslatef(m_fXCoord,m_fYCoord,0);
glColor3f(1, 0, 0);
CToolBox::render_string(0,0,GLUT_BITMAP_HELVETICA_18,"Boit ton ");
CToolBox::render_string(0,-0.07,GLUT_BITMAP_HELVETICA_18,"verre cul sec");
}
};
//----------------------------------------------------
class CQuartier3Fois : public CQuartierRoue
{
public:
CQuartier3Fois(float x, float y,float xOffset, float yOffset) : CQuartierRoue(x,y,xOffset,yOffset)
{
m_strNomGage = "Boit ton verre en 3 fois";
}
virtual int GetType() {return QUATIER_3FOIS;}
virtual void Draw()
{
glTranslatef(m_fXCoord,m_fYCoord,0);
glColor3f(1, 0, 0);
CToolBox::render_string(0,0,GLUT_BITMAP_HELVETICA_18,"Boit ton verre");
CToolBox::render_string(0,-0.07,GLUT_BITMAP_HELVETICA_18," en 3 fois ");
}
};
//----------------------------------------------------
class CQuartierTGenerale : public CQuartierRoue
{
public:
CQuartierTGenerale(float x, float y,float xOffset, float yOffset) : CQuartierRoue(x,y,xOffset,yOffset)
{
m_strNomGage = "Tournée Generale";
}
virtual int GetType() {return QUATIER_TGENERALE;}
virtual void Draw()
{
glTranslatef(m_fXCoord,m_fYCoord,0);
glColor3f(1, 0, 0);
CToolBox::render_string(0,0,GLUT_BITMAP_HELVETICA_18,"Tournée Generale");
}
};
//----------------------------------------------------
class CQuartierTLMonde : public CQuartierRoue
{
public:
CQuartierTLMonde(float x, float y,float xOffset, float yOffset) : CQuartierRoue(x,y,xOffset,yOffset)
{
m_strNomGage = "Boit le verre de tous le monde";
}
virtual int GetType() {return QUATIER_TLMONDE;}
virtual void Draw()
{
glTranslatef(m_fXCoord,m_fYCoord,0);
glColor3f(1, 0, 0);
CToolBox::render_string(0,-0.02,GLUT_BITMAP_HELVETICA_18,"Boit ");
CToolBox::render_string(-0.08,-0.1,GLUT_BITMAP_HELVETICA_18,"le verre");
CToolBox::render_string(-0.2,-0.2,GLUT_BITMAP_HELVETICA_18,"de tous le monde");
}
};
//----------------------------------------------------
class CQuartierRecule3Case : public CQuartierRoue
{
public:
CQuartierRecule3Case(float x, float y,float xOffset, float yOffset) : CQuartierRoue(x,y,xOffset,yOffset)
{
m_strNomGage = "Recule de 3 cases";
}
virtual int GetType() {return QUATIER_RECULE;}
virtual void Draw()
{
glTranslatef(m_fXCoord,m_fYCoord,0);
glColor3f(1, 0, 0);
CToolBox::render_string(0,-0.02,GLUT_BITMAP_HELVETICA_18,"Recule de");
CToolBox::render_string(0,-0.1,GLUT_BITMAP_HELVETICA_18,"3 cases");
}
};
//----------------------------------------------------
class CQuartierRetDepart: public CQuartierRoue
{
public:
CQuartierRetDepart(float x, float y,float xOffset, float yOffset) : CQuartierRoue(x,y,xOffset,yOffset)
{
m_strNomGage = "Retour au depart";
}
virtual int GetType() {return QUATIER_RETDEPART;}
virtual void Draw()
{
glTranslatef(m_fXCoord,m_fYCoord,0);
glColor3f(1, 0, 0);
CToolBox::render_string(0,0,GLUT_BITMAP_HELVETICA_18,"Retour au ");
CToolBox::render_string(0,-0.1,GLUT_BITMAP_HELVETICA_18,"depart");
}
};
//----------------------------------------------------
class CQuartierVoisGage : public CQuartierRoue
{
public:
CQuartierVoisGage(float x, float y,float xOffset, float yOffset) : CQuartierRoue(x,y,xOffset,yOffset)
{
m_strNomGage = "Le voisin choisi ton gage";
}
virtual int GetType() {return QUATIER_VOISIN;}
virtual void Draw()
{
glTranslatef(m_fXCoord,m_fYCoord,0);
glColor3f(1, 0, 0);
CToolBox::render_string(0,-0.04,GLUT_BITMAP_HELVETICA_18,"Le voisin");
CToolBox::render_string(0,-0.12,GLUT_BITMAP_HELVETICA_18,"choisi");
CToolBox::render_string(0,-0.20,GLUT_BITMAP_HELVETICA_18,"ton gage");
}
};
//----------------------------------------------------
class CQuartierNoGage : public CQuartierRoue
{
public:
CQuartierNoGage(float x, float y,float xOffset, float yOffset) : CQuartierRoue(x,y,xOffset,yOffset)
{
m_strNomGage = "Pas de gage";
}
virtual int GetType() {return QUATIER_VOISIN;}
virtual void Draw()
{
glTranslatef(m_fXCoord,m_fYCoord,0);
glColor3f(1, 0, 0);
CToolBox::render_string(0,0,GLUT_BITMAP_HELVETICA_18,"Pas de gage");
}
};
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.