BUVETTE POURSUITE VIRTUELLE

/*----------------------------------------------------------

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

};