Buvette poursuite virtuelle

Soyez le premier à donner votre avis sur cette source.

Vue 7 364 fois - Téléchargée 644 fois

Description

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");
	}

};

Codes Sources

A voir également

Ajouter un commentaire Commentaires
jujube97434 Messages postés 1 Date d'inscription samedi 29 octobre 2011 Statut Membre Dernière intervention 29 octobre 2011
29 oct. 2011 à 10:39
bonjour j'aimerai bien installer et jouer à ce jeu mais malheureusement je ne suis pas du tout bon en informatique
quelqu'un pourrais t'il m'expliquer svp
kts_system Messages postés 25 Date d'inscription vendredi 1 décembre 2006 Statut Membre Dernière intervention 27 novembre 2018
5 janv. 2009 à 16:54
c'est vrai que sa peut etre pas mal, je rajouterai sa des que je retourne en cour dans 1 mois (en ce moment je suis au taf j'ai pas trop le temps)

bonne année
a la prochaine
LeFauve42 Messages postés 239 Date d'inscription vendredi 20 octobre 2006 Statut Membre Dernière intervention 20 avril 2009
5 janv. 2009 à 10:47
Puisque tu es en OpenGL, tu peux peut-etre en profiter pour ajouter des effets speciaux comme faire trembler l'ecran apres quelques verres :o) (ou des effets encore plus psychadeliques)
kts_system Messages postés 25 Date d'inscription vendredi 1 décembre 2006 Statut Membre Dernière intervention 27 novembre 2018
25 déc. 2008 à 20:39
j'ai utiliser opengl parce que je connais et j'ai fait ça vite fait, j'ai pas vu la simplicité du truc au départ
LeFauve42 Messages postés 239 Date d'inscription vendredi 20 octobre 2006 Statut Membre Dernière intervention 20 avril 2009
10 déc. 2008 à 11:28
Utiliser OpenGL pour afficher des cases ? Chapeau !! :o)

Un petit jeu marrant (quand on ne conduit pas) et une implementation bien faite (j'aime bien ton choix "un type de case = une classe").

Bravo !

Eric
Afficher les 9 commentaires

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.