CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 02 05 04:16:34

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

JEU : CASSE BRIQUE 3D

Information sur la source

Note :

10,00 / 10

Catégorie :OpenGL Classé sous :casse, brique, 3d, jeu, game Niveau :Débutant Date de création :06/07/2005 Date de mise à jour :26/10/2005 19:24:39 Vu / téléchargé :31 537 / 954

Auteur : goygoy

Ecrire un message privé

Site perso

Commentaire sur cette source (22)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

J'ai fait une mauvaise manip et j'ai perdu tout ce que j'avais ecris alors je vais pas tout réécrire.
En gros, pendant le jeu taper sur F1 et vous aurez toutes les explications sur les touches et la souris.

Dans le zip, il y a glut32.dll et glaux.dll, il faut les laisser dans le dossier du casse brique.
Par contre glut.h et glaux.h doivent etre placer dans le meme dossier que gl.h et glu.h(les debutants, faut chercher un peu sur votre pc :-) )

nb: ça été fait sous windows

Source

#include<GL/glaux.h>
#include<GL/glut.h>
#include<GL/glu.h>
#include<GL/gl.h>
#include<math.h>
//============================================
# define BRIQUE 1
# define RAQUETTE 2
# define CADRE 3
# define AXES 4
//--------prototype des fonctions
void creer_objet_brique(GLfloat color[4]);
void creer_objet_RAQUETTE();
void creer_objet_cadre();
void creer_objet_axes3d( void );
void initialisation( void );
void rectangle(GLfloat largeur,GLfloat hauteur,GLfloat x,GLfloat y,GLfloat z);
void calcul_1_afficheur( int p, int n );
void calcul( int n );
void afficher_score( void );
void timer( int duree );
static void afficher( void );
static void ecrire(void *font, const char* string);
static void redessiner( int width, int height);
static void clavier( unsigned char k, int x, int y );
static void clavier_special( int k, int x, int y );
static void souris_bouton( int button, int state, int x, int y);
static void souris_deplacement( int x, int y);
void gerer_menu_jeu(int item);
GLint largeur=600, hauteur=600; //taille fenetre
int memxy[2],cliquex,cliquey;
GLint etat=0;
int key,memkey=1;
int i,j,k;
int angle=90,angle2;
int NbBrique[3]={6,6,6};
int brique[6][6][6]; //tableau representant l'etat de chaque brique (visible ou caché)
int BriqueATester[3]; //indices pour brique[][][]
GLfloat color[4]={0,0,1,1};
//affichage du score
GLfloat c[35];
GLfloat L1=.75, L2=.25, tabulation=2;
int A[5];
int score=0;
//========== DIMENSION ==========
GLfloat DimBrique[3]={2,1,1};
GLfloat DimBoule[3]={0.5,10,10};
GLfloat DimRaquette[3]={2,.6,1};
GLfloat DimCadre[3];
//========== POSITION ==========
GLfloat PosBrique[3]={0,10,0};
GLfloat PosBoule[3]={4,6,0.5};
GLfloat PosRaquette[3]={4,0,0};
GLfloat PosLight1[4] = {6, 6, 5, 1};
GLfloat PosCamera[3]={13,2*M_PI/5,0}; // rayon, theta, phi
GLfloat PosCible[3]={6,8,3};
//========== DEPLACEMENT ==========
GLfloat DirBoule[3]={.05,.07,.05};
GLfloat pasBoule=0.05;
GLfloat PasRaquette[3]={0,0,0};
GLfloat PasCamera[3]={0,0,0}; // increment de rayon, theta, phi
//========== PROJECTIONS ==========
//projection sur z
GLfloat projMat[16]={ 1,0,0,0,
0,1,0,0,
0,0,0,0,
0,0,0,1};
//projection sur y
GLfloat projMat2[16]={ 1,0,0,0,
0,0,0,0,
0,0,1,0,
0,0,0,1};
//projection sur x
GLfloat projMat3[16]={ 0,0,0,0,
0,1,0,0,
0,0,1,0,
0,0,0,1};
//-------choix des couleurs des materiaux------
GLfloat no_mat[4] = { 0.0, 0.0, 0.0, 1.0 };
float Mat_Amb[4] = {0, 1, 0, 1};
float Mat_Dif[4] = {1, 0, 0, 1};
float Mat_Spec[4] = {0, 0, 1, 1};
//-------choix des couleurs des lumieres-------
float Light1_Amb[4] = {1, 1, 1, 1};
float Light1_Dif[4] = {1, 1, 1, 1};
float Light1_Spec[4] = {1, 1, 1, 1};
float Spot1_Dir[3] = {0.0f, 0.0f, -1.0f};
//============================================
AUX_RGBImageRec * texture;
void initialisation( void ){
// printf("initialisation:\n");
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);//GL_CLAMP
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); //(...,...,GL_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); //GL_DECAL
texture = auxDIBImageLoad("metal sheet64.bmp");
glTexImage2D(GL_TEXTURE_2D,0,3,
texture->sizeX,texture->sizeY,0,GL_RGB,
GL_UNSIGNED_BYTE,
texture->data);
//========== ==========
for(i=0;i<3;i++) DimCadre[i]=PosBrique[i]+NbBrique[i]*DimBrique[i];
//========== CREATION ==========
//-------creation des objets-------------------
glNewList(BRIQUE, GL_COMPILE);
creer_objet_brique(color);
glEndList();
glNewList(RAQUETTE, GL_COMPILE);
creer_objet_RAQUETTE();
glEndList();
glNewList(CADRE, GL_COMPILE);
creer_objet_cadre();
glEndList();
glNewList(AXES, GL_COMPILE);
creer_objet_axes3d();
glEndList();
//-------creation des materiaux----------------
glMaterialfv(GL_FRONT,GL_AMBIENT,Mat_Amb);
glMaterialfv(GL_FRONT,GL_DIFFUSE,Mat_Dif);
glMaterialfv(GL_FRONT,GL_SPECULAR,Mat_Spec);
//-------creation des lumieres-----------------
glLightfv(GL_LIGHT0, GL_DIFFUSE, Light1_Dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, Light1_Spec);
glLightfv(GL_LIGHT0, GL_AMBIENT, Light1_Amb);
glLighti(GL_LIGHT0, GL_SPOT_CUTOFF, 180); //90-> angle d'ouverture du spot
//========== AUTRE ==========
//init des briques
for(k=0;k<NbBrique[2];k++)
for(j=0;j<NbBrique[1];j++)
for(i=0;i<NbBrique[0];i++)
brique[i][j][k] = (int) floor(rand()*4/RAND_MAX);
//-------initialisation des transparences------
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glPolygonMode(GL_BACK,GL_LINE);
glPolygonMode(GL_FRONT,GL_FILL);
//--------activation des fonctionnalites--------
//glShadeModel( GL_FLAT );
//glutSetCursor( GLUT_CURSOR_SPRAY );
}
//============================================
static void afficher( void ){
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glClearColor( 0,0,0,0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt( PosCible[0]+PosCamera[0]*cos(PosCamera[2])*cos(PosCamera[1]),
PosCible[1]-PosCamera[0]*sin(PosCamera[2]),
PosCible[2]+PosCamera[0]*cos(PosCamera[2])*sin(PosCamera[1]),
PosCible[0],
PosCible[1],
PosCible[2],
0,1,0);
//affichage de la lumiere
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, PosLight1);
//affichage du cadre
glCallList(CADRE);
//affichage score
glPushMatrix();
glTranslatef( 1.5,5,0 );
afficher_score();
glPopMatrix();
glEnable( GL_BLEND );
//Projection à l'aide de la matrice d'ombre
glPushMatrix();
glMultMatrixf(projMat);
glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
glColor4f(.5, .5, .5, .4);
glutSolidSphere ( 0.5, 10, 10);
glPopMatrix();
//Projection à l'aide de la matrice d'ombre
glPushMatrix();
glMultMatrixf(projMat2);
glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
glColor4f(.5, .5, .5, .4);
glutSolidSphere ( 0.5, 10, 10);
glPopMatrix();
//Projection à l'aide de la matrice d'ombre
glPushMatrix();
glMultMatrixf(projMat3);
glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
glColor4f(.5, .5, .5, .4);
glutSolidSphere ( 0.5, 10, 10);
glPopMatrix();
glEnable(GL_DEPTH_TEST);
//affichage des briques
for(k=0;k<NbBrique[2];k++)
for(j=0;j<NbBrique[1];j++)
for(i=0;i<NbBrique[0];i++){
// printf("%d,%d,%d",i,j,k);
if(brique[i][j][k]){
//printf("brique[i][j][k]:%d",brique[i][j][k]);
glPushMatrix();
glTranslatef( PosBrique[0]+i*DimBrique[0], PosBrique[1]+j*DimBrique[1], PosBrique[2]+k*DimBrique[2] );
if(brique[i][j][k]==1) glColor4f( 0, 0, 1, 1);
if(brique[i][j][k]==2) glColor4f( 0, 1, 0, 1);
if(brique[i][j][k]==3) glColor4f( 1, 0, 0, 1);
glCallList(BRIQUE);
glPopMatrix();
}
}
glDisable( GL_BLEND );
//affichage de la boule
glPushMatrix();
glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
glColor3d(.5, .5, .5);
glutSolidSphere ( 0.5, 10, 10);
glPopMatrix();
//affichage de Raquette
glEnable(GL_TEXTURE_2D);
glPushMatrix();
glTranslatef( PosRaquette[0], PosRaquette[1], PosRaquette[2] );
glCallList(RAQUETTE);
glPopMatrix();
glDisable(GL_TEXTURE_2D);
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
glDisable(GL_DEPTH_TEST);
//affichage des axes
//glCallList(AXES);
//simule une lampe
glPushMatrix();
glTranslatef (PosLight1[0],PosLight1[1],PosLight1[2]);
glMaterialfv(GL_FRONT, GL_EMISSION, Light1_Dif);
glutSolidSphere(0.1, 16, 16);
glPopMatrix();
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
//affichage
glPushMatrix();
glColor4f(1, .7, .7, 1);
glRasterPos3f( PosCible[0], PosCible[1], PosCible[2] );
if(etat==2) ecrire(GLUT_BITMAP_TIMES_ROMAN_24, "PAUSE");
if(etat==3) ecrire(GLUT_BITMAP_TIMES_ROMAN_24, "PERDU");
glPopMatrix();
glFinish(); //mise à l'ecran
glutSwapBuffers(); //changement de buffer(car on est en double buffering)
}
//============================================
static void ecrire(void *font, const char* string){
while (*string) glutBitmapCharacter(font, *string++);
}
//============================================
static void redessiner( int width, int height){
largeur = width;
hauteur = height;
glViewport( 0, 0, (GLint)width, (GLint)height );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(largeur>hauteur) gluPerspective(angle,largeur/hauteur,1,100 );
else gluPerspective(angle,hauteur/largeur,1,100 );
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
//============================================
static void clavier( unsigned char k, int x, int y ){
//printf("touche: %c\n",k);
switch (k){
//------------------
//aide
case 'a':
clavier_special( GLUT_KEY_F1, 0, 0 ); break;
break;
//------------------
//zoomer
case 'z':
angle2=angle-2;
if(50<angle2 && angle2<110) angle=angle2;
break;
//------------------
//dezoomer
case 'e':
angle2=angle+2;
if(50<angle2 && angle2<110) angle=angle2;
break;
//------------------
//arret du programme
case 'q':
case 27: //touche Echap
//glutLeaveMainLoop();
//glutDestroyWindow();
exit(0);
break;
//------------------
//start new game
case 's':
PosBoule[0]=4;
PosBoule[1]=6;
PosBoule[2]=.5;
DirBoule[0]=0;
DirBoule[1]=.07;
DirBoule[2]=0;
initialisation();
etat=1;
score=0;
glutTimerFunc( 100, timer, 0 );
break;
//------------------
//pause
case 'p':
if(etat==2){etat=0; printf("reprise du jeu\n"); }
else if(etat==0 || etat==1){etat=2; printf("pause\n");}
break;
//------------------
case '7':
PosLight1[0]-= 0.5;
break;
//------------------
case '8':
PosLight1[0]+= 0.5;
break;
//------------------
case '4':
PosLight1[1]-= 0.5;
break;
//------------------
case '5':
PosLight1[1]+= 0.5;
break;
//------------------
case '1':
PosLight1[2]-= 0.5;
break;
//------------------
case '2':
PosLight1[2]+= 0.5;
break;
}
redessiner(largeur, hauteur);
glutPostRedisplay();
}
//============================================
static void clavier_special( int k, int x, int y ){
switch (k){
case GLUT_KEY_F1:
printf("\nCOMMANDES DU CLAVIER:\n");
printf(" -- Echap: permet de quitter le jeu.\n");
printf(" -- F1: Afficher les commandes du clavier et de la souris.\n");
printf(" -- F2: Vue de face.\n");
printf(" -- F3: Vue 3/4 droite.\n");
printf(" -- F4: Vue de droite.\n");
printf(" -- F5: Vue de dessous.\n");
printf(" -- F6: Mettre le jeu en plein ecran (attention: non reversible).\n");
printf(" -- p : Mettre/Enlever la pause.\n");
printf(" -- a : Aide.\n");
printf(" -- z : Zoomer.\n");
printf(" -- e : Dezoomer.\n");
printf(" -- q : Quitter.\n");
printf(" -- s : Start nouveau jeu.\n");
printf(" -- 7/8 : deplacer la lampe sur l'axe x.\n");
printf(" -- 4/5 : deplacer la lampe sur l'axe y.\n");
printf(" -- 1/2 : deplacer la lampe sur l'axe z.\n");
printf("\nCOMMANDES DE LA SOURIS:\n");
printf(" -- Bouton gauche enfonce: le deplacement de la souris permet de deplacer la raquette.\n");
printf(" -- Bouton droit enfonce: le deplacement de la souris permet de deplacer la camera.\n");
printf(" -- Bouton centre appuye: permet d'acceder au menu du jeu (Nouveau Jeu,..., Quitter).\n");
break;
//------------------
case GLUT_KEY_F2:
PosCamera[1]=M_PI/2;
PosCamera[2]=0;
break;
//------------------
case GLUT_KEY_F3:
PosCamera[1]=M_PI/5;
PosCamera[2]=0;
break;
//------------------
case GLUT_KEY_F4:
PosCamera[1]=0;
PosCamera[2]=0;
break;
//------------------
case GLUT_KEY_F5:
PosCamera[1]=M_PI/2;
PosCamera[2]=M_PI/2-.01;
break;
//------------------
case GLUT_KEY_F6:
glutFullScreen();
break;
/* autres touches:
GLUT_KEY_F1, GLUT_KEY_F2, ..., GLUT_KEY_F12 - F1 through F12 keys
GLUT_KEY_PAGE_UP, GLUT_KEY_PAGE_DOWN - Page Up and Page Down keys
GLUT_KEY_HOME, GLUT_KEY_END - Home and End keys
GLUT_KEY_LEFT, GLUT_KEY_RIGHT, GLUT_KEY_UP, GLUT_KEY_DOWN - Arrow keys
GLUT_KEY_INSERT - Insert key */
}
}
//============================================
static void souris_bouton( int button, int state, int x, int y){
switch (button){
case GLUT_LEFT_BUTTON:
if (state==GLUT_DOWN) key=1;
if (state==GLUT_UP) {
PasRaquette[0]=0;
PasRaquette[2]=0;
memxy[0]=0;
memxy[1]=0;
key=0;}
break;
case GLUT_MIDDLE_BUTTON:
break;
case GLUT_RIGHT_BUTTON:
//printf("souris appuyee en: (%d,%d)\n",x,y);
if (state==GLUT_DOWN) key=2;
if (state==GLUT_UP) key=0;
break;
}
cliquex=x; cliquey=y;
}
//============================================
float signe( GLfloat a){ return a>0 ? 1 : -1;}
static void souris_deplacement( int x, int y){
if(!memxy[0])memxy[0]=cliquex;
if(!memxy[1])memxy[1]=cliquey;
switch(key){
case 1:
PasRaquette[0] = (sin(PosCamera[1])*(x-memxy[0])+
cos(PosCamera[1])*(y-memxy[1]))/
27.;
PasRaquette[2] = signe(sin(M_PI/4-PosCamera[2]))*
(-cos(PosCamera[1])*(x-memxy[0])+
sin(PosCamera[1])*(y-memxy[1]))/
27.;
if( PosRaquette[0]+PasRaquette[0]>=0 &&
PosRaquette[2]+PasRaquette[2]>=0 &&
PosRaquette[0]+PasRaquette[0]+DimRaquette[0]<=DimCadre[0] &&
PosRaquette[2]+PasRaquette[2]+DimRaquette[2]<=DimCadre[2])
{PosRaquette[0]+=PasRaquette[0];
PosRaquette[2]+=PasRaquette[2];}
break;
case 2:
PasCamera[1]=(x-cliquex)/5000.;
PasCamera[2]=(cliquey-y)/5000.;
break;
}
memxy[0]=x; memxy[1]=y;
redessiner(largeur, hauteur);
glutPostRedisplay();
}
//============================================
void rectangle(GLfloat largeur,GLfloat hauteur,GLfloat x,GLfloat y,GLfloat z){
glBegin( GL_QUADS );
glVertex3f( x,y,z );
glVertex3f( x+largeur,y,z );
glVertex3f( x+largeur,y+hauteur,z );
glVertex3f( x,y+hauteur,z );
glEnd();
}
//============================================
void afficher_score(){
calcul(score);
for(i=0;i<5;i++){
glColor3f(0,c[0+i*7],0);
rectangle(L1,L2, i*tabulation+L2, 0 ,0);
glColor3f(0,c[1+i*7],0);
rectangle(L1,L2, i*tabulation+L2, L1+L2 ,0);
glColor3f(0,c[2+i*7],0);
rectangle(L1,L2, i*tabulation+L2, 2*(L1+L2) ,0);
glColor3f(0,c[3+i*7],0);
rectangle(L2,L1, i*tabulation, L2 ,0);
glColor3f(0,c[4+i*7],0);
rectangle(L2,L1, i*tabulation, 2*L2+L1 ,0);
glColor3f(0,c[5+i*7],0);
rectangle(L2,L1, i*tabulation+L2+L1, L2 ,0);
glColor3f(0,c[6+i*7],0);
rectangle(L2,L1, i*tabulation+L2+L1, 2*L2+L1 ,0);
}
}
//============================================
void calcul_1_afficheur(int p,int n){
if (n==0 | n==2 | n==3 | n==5 | n==6 | n==8 | n==9 ) c[0+(4-p)*7]=1; //centre,bas
if ( n==2 | n==3 | n==4 | n==5 | n==6 | n==8 | n==9 ) c[1+(4-p)*7]=1; //centre,milieu
if (n==0 | n==2 | n==3 | n==5 | n==6 | n==7 | n==8 | n==9 ) c[2+(4-p)*7]=1; //centre,haut
if (n==0 | n==2 | n==6 | n==8 ) c[3+(4-p)*7]=1; //gauche,bas
if (n==0 | n==4 | n==5 | n==6 | n==8 | n==9 ) c[4+(4-p)*7]=1; //gauche,haut
if (n==0 | n==1 | n==3 | n==4 | n==5 | n==6 | n==7 | n==8 | n==9 ) c[5+(4-p)*7]=1; //droite,bas
if (n==0 | n==1 | n==2 | n==3 | n==4 | n==7 | n==8 | n==9 ) c[6+(4-p)*7]=1; //droite,haut
}
//============================================
void calcul (int n){
A[4]=n/10000;
A[3]=(n-A[4]*10000)/1000;
A[2]=(n-A[4]*10000-A[3]*1000)/100;
A[1]=(n-A[4]*10000-A[3]*1000-A[2]*100)/10;
A[0]=(n-A[4]*10000-A[3]*1000-A[2]*100-A[1]*10);
for(i=0;i<35;i++) c[i]=0;
for(i=0;i<5;i++) calcul_1_afficheur(i,A[i]);
// for(i=0;i<5;i++) printf("%d\n",A[i]);
}
//============================================
void timer( int duree ){
if(etat!=2 && etat!=3){
//BriqueATester contiendra les indices(pour le tableau brique) de la brique à tester
for(i=0;i<3;i++){
PosBoule[i]+=DirBoule[i];
BriqueATester[i] = floor(PosBoule[i]-PosBrique[i])/DimBrique[i];
}
//le rebond sur S
if(PosBoule[1]-DimBoule[0]<DimRaquette[1] &&
PosBoule[0]>PosRaquette[0] &&
PosBoule[0]<PosRaquette[0]+DimRaquette[0] &&
PosBoule[2]>PosRaquette[2] &&
PosBoule[2]<PosRaquette[2]+DimRaquette[2] )
{DirBoule[0]+=PasRaquette[0]/2;
DirBoule[1]=-DirBoule[1];
DirBoule[2]+=PasRaquette[2]/2;}
//le rebond sur les briques
if(BriqueATester[1]>=0)
if( k = brique[BriqueATester[0]][BriqueATester[1]][BriqueATester[2]]){
if(k!=3){ // 3=> incassable
score+=k;
brique[BriqueATester[0]][BriqueATester[1]][BriqueATester[2]]=0;
}
DirBoule[1]=-DirBoule[1];}
//si la boule est descendue trop bas => perdu
if(PosBoule[1]-DimBoule[0]<0){etat=3; return;}
//rebondir sur les murs
for(i=0;i<3;i++)
if(PosBoule[i]-DimBoule[0]<0 || PosBoule[i]+DimBoule[0]>DimCadre[i])
DirBoule[i]=-DirBoule[i];
}
//rotation de la camera
if(key==2){
PosCamera[1]+=PasCamera[1];
PosCamera[2]+=PasCamera[2];
//printf("%f\n",PosCamera[2]);
}
glutPostRedisplay();
//si on demande une nouvelle partie, le timer s'arrete dans les 30 ms qui suivent la demande
//pendant la demande de nouvelle partie(voir la fonction 'gerer_menu_jeu' case:1)
//if(etat!=1)
glutTimerFunc( 30, timer, 0 );
// else etat=0;
}
//============================================
void gerer_menu_principal(int item){
switch(item){
//pause
case 1: clavier('p',0,0); break;
//aide
case 2: clavier_special( GLUT_KEY_F1, 0, 0 ); break;
}
}
//============================================
void gerer_menu_jeu(int item){
switch(item){
//start new game
case 1: clavier('s',0,0); break;
//quitter
case 2: clavier('q',0,0); break;
}
}
//============================================
int main( int argc, char *argv[] ){
glutInit( &argc, argv );
glutInitWindowPosition( 100, 100 );
glutInitWindowSize( largeur, hauteur );
glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow( "CASSE BRIQUE" );
int jeu = glutCreateMenu( gerer_menu_jeu );
glutAddMenuEntry( "Nouveau", 1 );
glutAddMenuEntry( "Quitter", 2 );
int menu = glutCreateMenu( gerer_menu_principal );
glutAddSubMenu( "JEU", jeu );
glutAddMenuEntry( "PAUSE", 1 );
glutAddMenuEntry( "AIDE", 2 );
glutAttachMenu( GLUT_MIDDLE_BUTTON );
initialisation();
glutDisplayFunc( afficher );
glutReshapeFunc( redessiner );
glutKeyboardFunc( clavier );
glutSpecialFunc( clavier_special );
glutMouseFunc( souris_bouton );
glutMotionFunc( souris_deplacement );
glutTimerFunc( 30, timer, 0 );
glutMainLoop();
return 0;
}
//============================================
void creer_objet_brique(GLfloat color[4]){
glBegin( GL_QUADS );
//devant
// glColor4f( 0 , 0, 1, 1);
glVertex3f( 0, 0, DimBrique[2]);
// glColor4f( 0.5 , 0, 0.5, 1);
glVertex3f( DimBrique[0], 0, DimBrique[2]);
// glColor4f( 0 , 0, 1, 1);
glVertex3f( DimBrique[0], DimBrique[1], DimBrique[2]);
glColor4f( 0.5 , 0.2, 0.5, 1);
glVertex3f( 0, DimBrique[1], DimBrique[2]);
//derriere
glColor4f( 1 , 0, 1, .6);
glVertex3f( 0, 0, 0);
glVertex3f( 0, DimBrique[1], 0);
glVertex3f( DimBrique[0], DimBrique[1], 0);
glVertex3f( DimBrique[0], 0, 0);
//dessous
glColor4f( 0 , 1, 1, .9);
glVertex3f( 0, 0, 0);
glColor4f( 0 , 0.7, 0, .9);
glVertex3f( DimBrique[0], 0, 0);
glColor4f( 0 , 1, 1, .9);
glVertex3f( DimBrique[0], 0, DimBrique[2]);
glColor4f( 0 , 0.7, 0, .9);
glVertex3f( 0, 0, DimBrique[2]);
//dessus
glColor4f( 0 , 1, 1, .9);
glVertex3f( 0, DimBrique[1], 0);
glColor4f( 0 , 0.7, 0, .9);
glVertex3f( 0, DimBrique[1], DimBrique[2]);
glColor4f( 0 , 1, 1, .9);
glVertex3f( DimBrique[0], DimBrique[1], DimBrique[2]);
glColor4f( 0 , 0.7, 0, .9);
glVertex3f( DimBrique[0], DimBrique[1], 0);
//cotes
glColor4f( 1 , 1, 1, .8);
glVertex3f( 0, 0, 0);
glVertex3f( 0, 0, DimBrique[2]);
glVertex3f( 0, DimBrique[1], DimBrique[2]);
glVertex3f( 0, DimBrique[1], 0);
glVertex3f( DimBrique[0], 0, 0);
glVertex3f( DimBrique[0], DimBrique[1], 0);
glVertex3f( DimBrique[0], DimBrique[1], DimBrique[2]);
glVertex3f( DimBrique[0], 0, DimBrique[2]);
glEnd();
}
//============================================
void creer_objet_RAQUETTE(){
glBegin( GL_QUADS );
glColor3f( 1 , 0, 0);
glTexCoord2f(1.0,0.0);
glVertex3f( 0, 0, 0);
glTexCoord2f(1.0,1.0);
glVertex3f( 0, DimRaquette[1], 0);
glTexCoord2f(0.0,1.0);
glVertex3f( DimRaquette[0], DimRaquette[1], 0);
glTexCoord2f(0.0,0.0);
glVertex3f( DimRaquette[0], 0, 0);
glColor3f( 0 , 0, 0);
glTexCoord2f(1.0,0.0);
glVertex3f( 0, 0, 0);
glTexCoord2f(1.0,1.0);
glVertex3f( DimRaquette[0], 0, 0);
glTexCoord2f(0.0,1.0);
glVertex3f( DimRaquette[0], 0, DimRaquette[2]);
glTexCoord2f(0.0,0.0);
glVertex3f( 0, 0, DimRaquette[2]);
glColor3f( .5 , 1, .5);
glTexCoord2f(1.0,0.0);
glVertex3f( 0, DimRaquette[1], 0);
glTexCoord2f(1.0,1.0);
glVertex3f( 0, DimRaquette[1], DimRaquette[2]);
glTexCoord2f(0.0,1.0);
glVertex3f( DimRaquette[0], DimRaquette[1], DimRaquette[2]);
glTexCoord2f(0.0,0.0);
glVertex3f( DimRaquette[0], DimRaquette[1], 0);
glColor3f( 0 , 0, 0);
glTexCoord2f(1.0,0.0);
glVertex3f( 0, 0, 0);
glTexCoord2f(1.0,1.0);
glVertex3f( 0, 0, DimRaquette[2]);
glTexCoord2f(0.0,1.0);
glVertex3f( 0, DimRaquette[1], DimRaquette[2]);
glTexCoord2f(0.0,0.0);
glVertex3f( 0, DimRaquette[1], 0);
glTexCoord2f(1.0,0.0);
glVertex3f( DimRaquette[0], 0, 0);
glTexCoord2f(1.0,1.0);
glVertex3f( DimRaquette[0], DimRaquette[1], 0);
glTexCoord2f(0.0,1.0);
glVertex3f( DimRaquette[0], DimRaquette[1], DimRaquette[2]);
glTexCoord2f(0.0,0.0);
glVertex3f( DimRaquette[0], 0, DimRaquette[2]);
glColor3f( 0 , 0, 1);
glTexCoord2f(1.0,0.0);
glVertex3f( 0, 0, DimRaquette[2]);
glTexCoord2f(1.0,1.0);
glVertex3f( DimRaquette[0], 0, DimRaquette[2]);
glTexCoord2f(0.0,1.0);
glVertex3f( DimRaquette[0], DimRaquette[1], DimRaquette[2]);
glTexCoord2f(0.0,0.0);
glVertex3f( 0, DimRaquette[1], DimRaquette[2]);
glEnd();
}
//============================================
void creer_objet_cadre(){
glBegin( GL_QUADS );
glColor4f( .6 , .6, .9, 1);
glVertex3f( -.01, -.01, -.01);
glVertex3f( DimCadre[0]+.01, -.01, -.01);
glVertex3f( DimCadre[0]+.01, DimCadre[1], -.01);
glVertex3f( -.01, DimCadre[1], -.01);
glColor4f( .6 , .6, .7, 1);
glVertex3f( -.01, -.01, -.01);
glVertex3f( -.01, -.01, DimCadre[2]);
glVertex3f( DimCadre[0]+.01, -.01, DimCadre[2]);
glVertex3f( DimCadre[0]+.01, -.01, -.01);
glColor4f( .9 , .6, .9, 1);
glVertex3f( -.01, -.01, -.01);
glVertex3f( -.01, DimCadre[1], -.01);
glVertex3f( -.01, DimCadre[1], DimCadre[2]);
glVertex3f( -.01, -.01, DimCadre[2]);
glColor4f( .9 , .6, .9, 1);
glVertex3f( DimCadre[0]+.01, -.01, -.01);
glVertex3f( DimCadre[0]+.01, -.01, DimCadre[2]);
glVertex3f( DimCadre[0]+.01, DimCadre[1], DimCadre[2]);
glVertex3f( DimCadre[0]+.01, DimCadre[1], -.01);
glEnd();
}
//============================================
void creer_objet_axes3d( void ){
glLineWidth( 2 );
glBegin( GL_LINES );
glColor3f( 1, 0, 0 );
glVertex3f( 0., 0., 0. );
glVertex3f( 1., 0., 0. );
glColor3f( 0, 1, 0);
glVertex3f( 0., 0., 0. );
glVertex3f( 0., 1., 0. );
glColor3f( 0, 0, 1 );
glVertex3f( 0., 0., 0. );
glVertex3f( 0., 0., 1. );
glEnd();
glLineWidth( 1 );
}

#include<GL/glaux.h> 
#include<GL/glut.h>
#include<GL/glu.h>
#include<GL/gl.h>
#include<math.h>

//============================================
# define BRIQUE  1
# define RAQUETTE 2
# define CADRE   3
# define AXES    4
//--------prototype des fonctions
void creer_objet_brique(GLfloat color[4]);
void creer_objet_RAQUETTE();
void creer_objet_cadre();
void creer_objet_axes3d( void );
void initialisation( void );
void rectangle(GLfloat largeur,GLfloat hauteur,GLfloat x,GLfloat y,GLfloat z);
void calcul_1_afficheur( int p, int n );
void calcul( int n );
void afficher_score( void );
void timer( int duree );
static void afficher( void );
static void ecrire(void *font, const char* string);
static void redessiner( int width, int height);
static void clavier( unsigned char k, int x, int y );
static void clavier_special( int k, int x, int y );
static void souris_bouton( int button, int state, int x, int y);
static void souris_deplacement( int x, int y);
void gerer_menu_jeu(int item);

    GLint largeur=600, hauteur=600;   //taille fenetre
    int memxy[2],cliquex,cliquey;
    GLint etat=0;
    int key,memkey=1;
    int i,j,k;
    int angle=90,angle2;
    int NbBrique[3]={6,6,6};
    int brique[6][6][6]; //tableau representant l'etat de chaque brique (visible ou caché)
    int BriqueATester[3]; //indices pour brique[][][]
    GLfloat color[4]={0,0,1,1};
    
    //affichage du score
    GLfloat c[35];
    GLfloat L1=.75, L2=.25, tabulation=2;
    int A[5];
    int score=0;
     //========== DIMENSION ==========
     GLfloat DimBrique[3]={2,1,1};
     GLfloat DimBoule[3]={0.5,10,10};
     GLfloat DimRaquette[3]={2,.6,1};
     GLfloat DimCadre[3];
     //========== POSITION ==========
     GLfloat PosBrique[3]={0,10,0};
     GLfloat PosBoule[3]={4,6,0.5};
     GLfloat PosRaquette[3]={4,0,0};
     GLfloat PosLight1[4] = {6, 6, 5, 1};
     GLfloat PosCamera[3]={13,2*M_PI/5,0}; // rayon, theta, phi
     GLfloat PosCible[3]={6,8,3};
     //========== DEPLACEMENT ==========
     GLfloat DirBoule[3]={.05,.07,.05};
     GLfloat pasBoule=0.05;
     GLfloat PasRaquette[3]={0,0,0};
     GLfloat PasCamera[3]={0,0,0}; // increment de rayon, theta, phi
     //========== PROJECTIONS ==========
     //projection sur z
     GLfloat projMat[16]={  1,0,0,0,
                            0,1,0,0,
                            0,0,0,0,
                            0,0,0,1};
     //projection sur y
     GLfloat projMat2[16]={ 1,0,0,0,
                            0,0,0,0,
                            0,0,1,0,
                            0,0,0,1};
     //projection sur x  
     GLfloat projMat3[16]={ 0,0,0,0,
                            0,1,0,0,
                            0,0,1,0,
                            0,0,0,1}; 
     //-------choix des couleurs des materiaux------
     GLfloat no_mat[4] = { 0.0, 0.0, 0.0, 1.0 };
     float Mat_Amb[4] = {0, 1, 0, 1};     
     float Mat_Dif[4] = {1, 0, 0, 1};
     float Mat_Spec[4] = {0, 0, 1, 1};
     //-------choix des couleurs des lumieres-------
     float Light1_Amb[4] = {1, 1, 1, 1};
     float Light1_Dif[4] = {1, 1, 1, 1};
     float Light1_Spec[4] = {1, 1, 1, 1};
     float Spot1_Dir[3] = {0.0f, 0.0f, -1.0f};
//============================================
AUX_RGBImageRec * texture;
void initialisation( void ){
//     printf("initialisation:\n");

     glPixelStorei(GL_UNPACK_ALIGNMENT,1);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);//GL_CLAMP
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); //(...,...,GL_LINEAR)
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); //GL_DECAL

     texture = auxDIBImageLoad("metal sheet64.bmp");
     glTexImage2D(GL_TEXTURE_2D,0,3,
                  texture->sizeX,texture->sizeY,0,GL_RGB,
                  GL_UNSIGNED_BYTE,
                  texture->data);

     //==========  ==========
     for(i=0;i<3;i++) DimCadre[i]=PosBrique[i]+NbBrique[i]*DimBrique[i];


     //========== CREATION ==========
     //-------creation des objets-------------------
     glNewList(BRIQUE, GL_COMPILE);
       creer_objet_brique(color);
     glEndList();
     glNewList(RAQUETTE, GL_COMPILE);
       creer_objet_RAQUETTE();
     glEndList();
     glNewList(CADRE, GL_COMPILE);
       creer_objet_cadre();
     glEndList();
     glNewList(AXES, GL_COMPILE);
       creer_objet_axes3d();
     glEndList();
     //-------creation des materiaux----------------
     glMaterialfv(GL_FRONT,GL_AMBIENT,Mat_Amb);
     glMaterialfv(GL_FRONT,GL_DIFFUSE,Mat_Dif);     
     glMaterialfv(GL_FRONT,GL_SPECULAR,Mat_Spec);
     //-------creation des lumieres-----------------
     glLightfv(GL_LIGHT0, GL_DIFFUSE, Light1_Dif);
     glLightfv(GL_LIGHT0, GL_SPECULAR, Light1_Spec);
     glLightfv(GL_LIGHT0, GL_AMBIENT, Light1_Amb);
     glLighti(GL_LIGHT0, GL_SPOT_CUTOFF, 180);  //90-> angle d'ouverture du spot

     //========== AUTRE ==========
//init des briques
	for(k=0;k<NbBrique[2];k++)
		for(j=0;j<NbBrique[1];j++)
        	for(i=0;i<NbBrique[0];i++)
				brique[i][j][k] = (int) floor(rand()*4/RAND_MAX);

    //-------initialisation des transparences------
     glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
     glPolygonMode(GL_BACK,GL_LINE);
     glPolygonMode(GL_FRONT,GL_FILL);
    //--------activation des fonctionnalites--------
    //glShadeModel( GL_FLAT );
	//glutSetCursor( GLUT_CURSOR_SPRAY );
}

//============================================
static void afficher( void ){
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
	glClearColor( 0,0,0,0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(    PosCible[0]+PosCamera[0]*cos(PosCamera[2])*cos(PosCamera[1]),
                  PosCible[1]-PosCamera[0]*sin(PosCamera[2]),
                  PosCible[2]+PosCamera[0]*cos(PosCamera[2])*sin(PosCamera[1]),
                  PosCible[0],
                  PosCible[1],
                  PosCible[2],
                  0,1,0);

//affichage de la lumiere
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    glLightfv(GL_LIGHT0, GL_POSITION, PosLight1);

//affichage du cadre
    glCallList(CADRE);
  
//affichage score
    glPushMatrix();
    glTranslatef( 1.5,5,0 );
    afficher_score();
    glPopMatrix();

    glEnable( GL_BLEND );

  //Projection à l'aide de la matrice d'ombre
    glPushMatrix();
    glMultMatrixf(projMat);
    glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
    glColor4f(.5, .5, .5, .4);
    glutSolidSphere ( 0.5, 10, 10);  
    glPopMatrix();
  //Projection à l'aide de la matrice d'ombre
    glPushMatrix();
    glMultMatrixf(projMat2);
    glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
    glColor4f(.5, .5, .5, .4);
    glutSolidSphere ( 0.5, 10, 10);  
    glPopMatrix();
  //Projection à l'aide de la matrice d'ombre
    glPushMatrix();
    glMultMatrixf(projMat3);
    glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
    glColor4f(.5, .5, .5, .4);
    glutSolidSphere ( 0.5, 10, 10);  
    glPopMatrix();    


    glEnable(GL_DEPTH_TEST);
//affichage des briques
	for(k=0;k<NbBrique[2];k++)
		for(j=0;j<NbBrique[1];j++)
        	for(i=0;i<NbBrique[0];i++){
        // printf("%d,%d,%d",i,j,k);
				if(brique[i][j][k]){
                    //printf("brique[i][j][k]:%d",brique[i][j][k]);               
                	glPushMatrix();
                	glTranslatef( PosBrique[0]+i*DimBrique[0], PosBrique[1]+j*DimBrique[1], PosBrique[2]+k*DimBrique[2] );
                    if(brique[i][j][k]==1) glColor4f( 0, 0, 1, 1);
                    if(brique[i][j][k]==2) glColor4f( 0, 1, 0, 1);
                    if(brique[i][j][k]==3) glColor4f( 1, 0, 0, 1);
                	glCallList(BRIQUE);
                	glPopMatrix();
		        }
            }
    glDisable( GL_BLEND );


//affichage de la boule
    glPushMatrix();
    glTranslatef( PosBoule[0], PosBoule[1], PosBoule[2] );
    glColor3d(.5, .5, .5);
    glutSolidSphere ( 0.5, 10, 10);
    glPopMatrix();
//affichage de Raquette
    glEnable(GL_TEXTURE_2D);
	glPushMatrix();
    glTranslatef( PosRaquette[0], PosRaquette[1], PosRaquette[2] );
    glCallList(RAQUETTE);
    glPopMatrix();
    glDisable(GL_TEXTURE_2D);

    glDisable(GL_COLOR_MATERIAL);
    glDisable(GL_LIGHTING);
    glDisable(GL_LIGHT0);
    glDisable(GL_DEPTH_TEST);
//affichage des axes
    //glCallList(AXES);

//simule une lampe
   glPushMatrix();
   glTranslatef (PosLight1[0],PosLight1[1],PosLight1[2]);
   glMaterialfv(GL_FRONT, GL_EMISSION, Light1_Dif);
   glutSolidSphere(0.1, 16, 16);
   glPopMatrix();
   glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);

//affichage
	glPushMatrix();
    glColor4f(1, .7, .7, 1);
    glRasterPos3f( PosCible[0], PosCible[1], PosCible[2] );
    if(etat==2) ecrire(GLUT_BITMAP_TIMES_ROMAN_24, "PAUSE");
    if(etat==3) ecrire(GLUT_BITMAP_TIMES_ROMAN_24, "PERDU");
    glPopMatrix();
    
	glFinish();  //mise à l'ecran
	glutSwapBuffers();   //changement de buffer(car on est en double buffering)
}
//============================================
static void ecrire(void *font, const char* string){
    while (*string)  glutBitmapCharacter(font, *string++);
}
//============================================
static void redessiner( int width, int height){
    largeur = width;
    hauteur = height;
	glViewport( 0, 0, (GLint)width, (GLint)height );
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	if(largeur>hauteur)	gluPerspective(angle,largeur/hauteur,1,100 );
	else gluPerspective(angle,hauteur/largeur,1,100 );
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

//============================================
static void clavier( unsigned char k, int x, int y ){
    //printf("touche: %c\n",k);   
	switch (k){

  //------------------
  //aide
        case 'a':
             clavier_special( GLUT_KEY_F1, 0, 0 ); break;
             break;
  //------------------
  //zoomer
        case 'z': 
             angle2=angle-2;
             if(50<angle2 && angle2<110) angle=angle2;
             break;
  //------------------  
  //dezoomer
        case 'e': 
             angle2=angle+2;
             if(50<angle2 && angle2<110) angle=angle2;
             break;
  //------------------
  //arret du programme
        case 'q':
		case 27: //touche Echap
			//glutLeaveMainLoop();
			//glutDestroyWindow();
			exit(0);
			break;
  //------------------
  //start new game
        case 's':
             PosBoule[0]=4;
             PosBoule[1]=6;
             PosBoule[2]=.5;
             DirBoule[0]=0;
             DirBoule[1]=.07;
             DirBoule[2]=0;
             initialisation();
             etat=1;
             score=0;
             glutTimerFunc( 100, timer, 0 );
             break;
  //------------------
  //pause     
        case 'p':
             if(etat==2){etat=0; printf("reprise du jeu\n"); }
             else if(etat==0 || etat==1){etat=2; printf("pause\n");}
             break;
  //------------------  
        case '7': 
             PosLight1[0]-= 0.5;
             break;
  //------------------  
        case '8': 
             PosLight1[0]+= 0.5;
             break;
  //------------------  
        case '4': 
             PosLight1[1]-= 0.5;
             break;
  //------------------  
        case '5': 
             PosLight1[1]+= 0.5;
             break;
  //------------------  
        case '1': 
             PosLight1[2]-= 0.5;
             break;
  //------------------  
        case '2': 
             PosLight1[2]+= 0.5;
             break;

	}
	redessiner(largeur, hauteur);
    glutPostRedisplay();
}
//============================================
static void clavier_special( int k, int x, int y ){
       switch (k){
              case GLUT_KEY_F1:
                   printf("\nCOMMANDES DU CLAVIER:\n");
                   printf(" -- Echap: permet de quitter le jeu.\n");
                   printf(" -- F1: Afficher les commandes du clavier et de la souris.\n");
                   printf(" -- F2: Vue de face.\n");
                   printf(" -- F3: Vue 3/4 droite.\n");
                   printf(" -- F4: Vue de droite.\n");                   
                   printf(" -- F5: Vue de dessous.\n");
                   printf(" -- F6: Mettre le jeu en plein ecran (attention: non reversible).\n");
                   printf(" -- p : Mettre/Enlever la pause.\n");
                   printf(" -- a : Aide.\n");
                   printf(" -- z : Zoomer.\n");
                   printf(" -- e : Dezoomer.\n");
                   printf(" -- q : Quitter.\n");
                   printf(" -- s : Start nouveau jeu.\n");
                   printf(" -- 7/8 : deplacer la lampe sur l'axe x.\n");
                   printf(" -- 4/5 : deplacer la lampe sur l'axe y.\n");
                   printf(" -- 1/2 : deplacer la lampe sur l'axe z.\n");
                   printf("\nCOMMANDES DE LA SOURIS:\n");
                   printf(" -- Bouton gauche enfonce: le deplacement de la souris permet de deplacer la raquette.\n");
                   printf(" -- Bouton droit  enfonce: le deplacement de la souris permet de deplacer la camera.\n");
                   printf(" -- Bouton centre  appuye: permet d'acceder au menu du jeu (Nouveau Jeu,..., Quitter).\n");
                   break;
      //------------------         
              case GLUT_KEY_F2:
                   PosCamera[1]=M_PI/2;
                   PosCamera[2]=0;
                   break;
      //------------------         
              case GLUT_KEY_F3:
                   PosCamera[1]=M_PI/5;
                   PosCamera[2]=0;
                   break;
      //------------------         
              case GLUT_KEY_F4:
                   PosCamera[1]=0;
                   PosCamera[2]=0;
                   break;
      //------------------         
              case GLUT_KEY_F5:
                   PosCamera[1]=M_PI/2;
                   PosCamera[2]=M_PI/2-.01;
                   break;
      //------------------         
              case GLUT_KEY_F6:
                   glutFullScreen();
                   break;
/* autres touches:
GLUT_KEY_F1, GLUT_KEY_F2, ..., GLUT_KEY_F12 - F1 through F12 keys 
GLUT_KEY_PAGE_UP, GLUT_KEY_PAGE_DOWN - Page Up and Page Down keys 
GLUT_KEY_HOME, GLUT_KEY_END - Home and End keys 
GLUT_KEY_LEFT, GLUT_KEY_RIGHT, GLUT_KEY_UP, GLUT_KEY_DOWN - Arrow keys 
GLUT_KEY_INSERT - Insert key */
       }
}
//============================================
static void souris_bouton( int button, int state, int x, int y){
       switch (button){
              case GLUT_LEFT_BUTTON:
                   if (state==GLUT_DOWN) key=1;
                   if (state==GLUT_UP) {
                                       PasRaquette[0]=0;
                                       PasRaquette[2]=0;
                                       memxy[0]=0;
                                       memxy[1]=0;        
                                       key=0;}              
                   break;
              case GLUT_MIDDLE_BUTTON:
                   break;
              case GLUT_RIGHT_BUTTON:
                   //printf("souris appuyee en: (%d,%d)\n",x,y);
                   if (state==GLUT_DOWN) key=2;
                   if (state==GLUT_UP) key=0;
                   break;
       }
       cliquex=x;   cliquey=y;
}
//============================================
float signe( GLfloat a){ return a>0 ? 1 : -1;}

static void souris_deplacement( int x, int y){
       if(!memxy[0])memxy[0]=cliquex;
       if(!memxy[1])memxy[1]=cliquey;
       
       switch(key){
                   case 1:
                        PasRaquette[0] = (sin(PosCamera[1])*(x-memxy[0])+
                                        cos(PosCamera[1])*(y-memxy[1]))/
                                        27.;
                        PasRaquette[2] = signe(sin(M_PI/4-PosCamera[2]))*
                                       (-cos(PosCamera[1])*(x-memxy[0])+
                                        sin(PosCamera[1])*(y-memxy[1]))/
                                        27.;
                        if( PosRaquette[0]+PasRaquette[0]>=0 &&
                            PosRaquette[2]+PasRaquette[2]>=0 &&
                            PosRaquette[0]+PasRaquette[0]+DimRaquette[0]<=DimCadre[0] &&
                            PosRaquette[2]+PasRaquette[2]+DimRaquette[2]<=DimCadre[2])
                            {PosRaquette[0]+=PasRaquette[0];
                             PosRaquette[2]+=PasRaquette[2];}
                        break;
                   case 2:
                        PasCamera[1]=(x-cliquex)/5000.;
                        PasCamera[2]=(cliquey-y)/5000.;
                        break;
       }
       memxy[0]=x;   memxy[1]=y;
       redessiner(largeur, hauteur);
       glutPostRedisplay();
}
//============================================
void rectangle(GLfloat largeur,GLfloat hauteur,GLfloat x,GLfloat y,GLfloat z){
		glBegin( GL_QUADS ); 
		         glVertex3f( x,y,z  );
    	         glVertex3f( x+largeur,y,z );
                 glVertex3f( x+largeur,y+hauteur,z );
    		     glVertex3f( x,y+hauteur,z );
		glEnd();
}
//============================================
void afficher_score(){
	calcul(score);
	for(i=0;i<5;i++){
		glColor3f(0,c[0+i*7],0);
		rectangle(L1,L2,        i*tabulation+L2,    0    ,0);
		glColor3f(0,c[1+i*7],0);
		rectangle(L1,L2,        i*tabulation+L2,    L1+L2    ,0);
		glColor3f(0,c[2+i*7],0);
		rectangle(L1,L2,        i*tabulation+L2,    2*(L1+L2)    ,0);
		glColor3f(0,c[3+i*7],0);
		rectangle(L2,L1,        i*tabulation,       L2    ,0);
		glColor3f(0,c[4+i*7],0);
		rectangle(L2,L1,        i*tabulation,       2*L2+L1    ,0);
		glColor3f(0,c[5+i*7],0);
		rectangle(L2,L1,        i*tabulation+L2+L1, L2    ,0);
		glColor3f(0,c[6+i*7],0);
		rectangle(L2,L1,        i*tabulation+L2+L1, 2*L2+L1    ,0);
	}
}
//============================================
void calcul_1_afficheur(int p,int n){
     if (n==0 |        n==2 | n==3 |        n==5 | n==6 |        n==8 | n==9 )  c[0+(4-p)*7]=1; //centre,bas
     if (              n==2 | n==3 | n==4 | n==5 | n==6 |        n==8 | n==9 )  c[1+(4-p)*7]=1; //centre,milieu
     if (n==0 |        n==2 | n==3 |        n==5 | n==6 | n==7 | n==8 | n==9 )  c[2+(4-p)*7]=1; //centre,haut
     if (n==0 |        n==2 |                      n==6 |        n==8        )  c[3+(4-p)*7]=1; //gauche,bas
     if (n==0 |                      n==4 | n==5 | n==6 |        n==8 | n==9 )  c[4+(4-p)*7]=1; //gauche,haut
     if (n==0 | n==1 |        n==3 | n==4 | n==5 | n==6 | n==7 | n==8 | n==9 )  c[5+(4-p)*7]=1; //droite,bas
     if (n==0 | n==1 | n==2 | n==3 | n==4 |               n==7 | n==8 | n==9 )  c[6+(4-p)*7]=1; //droite,haut
}
//============================================
void calcul (int n){
     A[4]=n/10000;
     A[3]=(n-A[4]*10000)/1000;
     A[2]=(n-A[4]*10000-A[3]*1000)/100;
     A[1]=(n-A[4]*10000-A[3]*1000-A[2]*100)/10;
     A[0]=(n-A[4]*10000-A[3]*1000-A[2]*100-A[1]*10);
     for(i=0;i<35;i++)  c[i]=0;
     for(i=0;i<5;i++) calcul_1_afficheur(i,A[i]);
//     for(i=0;i<5;i++) printf("%d\n",A[i]);
}
//============================================
void timer( int duree ){
    if(etat!=2 && etat!=3){
         //BriqueATester contiendra les indices(pour le tableau brique) de la brique à tester
         for(i=0;i<3;i++){
             PosBoule[i]+=DirBoule[i];
             BriqueATester[i] = floor(PosBoule[i]-PosBrique[i])/DimBrique[i];
         }
         //le rebond sur S
         if(PosBoule[1]-DimBoule[0]<DimRaquette[1] &&
            PosBoule[0]>PosRaquette[0]             &&
            PosBoule[0]<PosRaquette[0]+DimRaquette[0]     &&
            PosBoule[2]>PosRaquette[2]             &&
            PosBoule[2]<PosRaquette[2]+DimRaquette[2]       )
            {DirBoule[0]+=PasRaquette[0]/2;
             DirBoule[1]=-DirBoule[1];
             DirBoule[2]+=PasRaquette[2]/2;}
         
         //le rebond sur les briques      
         if(BriqueATester[1]>=0)
            if( k = brique[BriqueATester[0]][BriqueATester[1]][BriqueATester[2]]){
                if(k!=3){ // 3=> incassable
                     score+=k;
                     brique[BriqueATester[0]][BriqueATester[1]][BriqueATester[2]]=0;
                }
               DirBoule[1]=-DirBoule[1];}
         
         //si la boule est descendue trop bas => perdu
         if(PosBoule[1]-DimBoule[0]<0){etat=3; return;}
         
         //rebondir sur les murs
         for(i=0;i<3;i++)
             if(PosBoule[i]-DimBoule[0]<0 || PosBoule[i]+DimBoule[0]>DimCadre[i])
                  DirBoule[i]=-DirBoule[i];
     }

     //rotation de la camera 
     if(key==2){
          PosCamera[1]+=PasCamera[1];
          PosCamera[2]+=PasCamera[2];
          //printf("%f\n",PosCamera[2]);
     }

     glutPostRedisplay();
     //si on demande une nouvelle partie, le timer s'arrete dans les 30 ms qui suivent la demande
     //pendant la demande de nouvelle partie(voir la fonction 'gerer_menu_jeu' case:1)
     //if(etat!=1) 
     glutTimerFunc( 30, timer, 0 );
    // else etat=0;
}
//============================================
void gerer_menu_principal(int item){
     switch(item){
                  //pause
                  case 1: clavier('p',0,0); break;
                  //aide
                  case 2: clavier_special( GLUT_KEY_F1, 0, 0 ); break;
     }
}
//============================================
void gerer_menu_jeu(int item){
     switch(item){
                  //start new game
                  case 1: clavier('s',0,0); break;
                  //quitter
                  case 2: clavier('q',0,0); break;             
     }
     
}
//============================================
int main( int argc, char *argv[] ){
	glutInit( &argc, argv );
	glutInitWindowPosition( 100, 100 );
	glutInitWindowSize( largeur, hauteur );
	glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
	glutCreateWindow( "CASSE BRIQUE" );

    int jeu = glutCreateMenu( gerer_menu_jeu );
    glutAddMenuEntry( "Nouveau", 1 );
    glutAddMenuEntry( "Quitter", 2 );

    int menu = glutCreateMenu( gerer_menu_principal );
    glutAddSubMenu( "JEU", jeu );
    glutAddMenuEntry( "PAUSE", 1 );
    glutAddMenuEntry( "AIDE", 2 );
    glutAttachMenu( GLUT_MIDDLE_BUTTON );


	initialisation();
	glutDisplayFunc( afficher );
	glutReshapeFunc( redessiner );
	glutKeyboardFunc( clavier );
	glutSpecialFunc( clavier_special );
	glutMouseFunc( souris_bouton );
	glutMotionFunc( souris_deplacement );
	glutTimerFunc( 30, timer, 0 );
	glutMainLoop();
	return 0;
}
//============================================
void creer_objet_brique(GLfloat color[4]){
    	glBegin( GL_QUADS );

     //devant
//    	glColor4f( 0 , 0, 1, 1);
    	glVertex3f( 0, 0, DimBrique[2]);
//    	glColor4f( 0.5 , 0, 0.5, 1);
    	glVertex3f( DimBrique[0], 0, DimBrique[2]);
//    	glColor4f( 0 , 0, 1, 1);
    	glVertex3f( DimBrique[0], DimBrique[1], DimBrique[2]);
    	glColor4f( 0.5 , 0.2, 0.5, 1);
    	glVertex3f( 0, DimBrique[1], DimBrique[2]);

     //derriere
    	glColor4f( 1 , 0, 1, .6);
    	glVertex3f( 0, 0, 0);
    	glVertex3f( 0, DimBrique[1], 0);
    	glVertex3f( DimBrique[0], DimBrique[1], 0);
    	glVertex3f( DimBrique[0], 0, 0);

     //dessous
    	glColor4f( 0 , 1, 1, .9);
    	glVertex3f( 0, 0, 0);
    	glColor4f( 0 , 0.7, 0, .9);
    	glVertex3f( DimBrique[0], 0, 0);
    	glColor4f( 0 , 1, 1, .9);
    	glVertex3f( DimBrique[0], 0, DimBrique[2]);
    	glColor4f( 0 , 0.7, 0, .9);
    	glVertex3f( 0, 0, DimBrique[2]);

     //dessus    	
    	glColor4f( 0 , 1, 1, .9);
    	glVertex3f( 0, DimBrique[1], 0);
    	glColor4f( 0 , 0.7, 0, .9);
    	glVertex3f( 0, DimBrique[1], DimBrique[2]);
    	glColor4f( 0 , 1, 1, .9);
    	glVertex3f( DimBrique[0], DimBrique[1], DimBrique[2]);
    	glColor4f( 0 , 0.7, 0, .9);
    	glVertex3f( DimBrique[0], DimBrique[1], 0);

     //cotes
    	glColor4f( 1 , 1, 1, .8);    	
    	glVertex3f( 0, 0, 0);
    	glVertex3f( 0, 0, DimBrique[2]);
    	glVertex3f( 0, DimBrique[1], DimBrique[2]);
    	glVertex3f( 0, DimBrique[1], 0);
    	
    	glVertex3f( DimBrique[0], 0, 0);
    	glVertex3f( DimBrique[0], DimBrique[1], 0);
    	glVertex3f( DimBrique[0], DimBrique[1], DimBrique[2]);
    	glVertex3f( DimBrique[0], 0, DimBrique[2]);

    	glEnd();
}

//============================================
void creer_objet_RAQUETTE(){
    	glBegin( GL_QUADS );
    	
    	glColor3f( 1 , 0, 0);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, 0, 0);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( 0, DimRaquette[1], 0);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], 0);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( DimRaquette[0], 0, 0);
    	
    	glColor3f( 0 , 0, 0);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, 0, 0);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( DimRaquette[0], 0, 0);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], 0, DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( 0, 0, DimRaquette[2]);

    	glColor3f( .5 , 1, .5);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, DimRaquette[1], 0);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( 0, DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], 0);
   
    	glColor3f( 0 , 0, 0);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, 0, 0);
        glTexCoord2f(1.0,1.0);
    	glVertex3f( 0, 0, DimRaquette[2]);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( 0, DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( 0, DimRaquette[1], 0);
    	
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( DimRaquette[0], 0, 0);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], 0);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( DimRaquette[0], 0, DimRaquette[2]);
    	
    	glColor3f( 0 , 0, 1);
    	glTexCoord2f(1.0,0.0);
    	glVertex3f( 0, 0, DimRaquette[2]);
    	glTexCoord2f(1.0,1.0);
    	glVertex3f( DimRaquette[0], 0, DimRaquette[2]);
    	glTexCoord2f(0.0,1.0);
    	glVertex3f( DimRaquette[0], DimRaquette[1], DimRaquette[2]);
    	glTexCoord2f(0.0,0.0);
    	glVertex3f( 0, DimRaquette[1], DimRaquette[2]);

    	glEnd();
}

//============================================
void creer_objet_cadre(){
    	glBegin( GL_QUADS );

    	glColor4f( .6 , .6, .9, 1);
    	glVertex3f( -.01, -.01, -.01);
    	glVertex3f( DimCadre[0]+.01, -.01, -.01);
    	glVertex3f( DimCadre[0]+.01, DimCadre[1], -.01);
    	glVertex3f( -.01, DimCadre[1], -.01);
   
    	glColor4f( .6 , .6, .7, 1);
    	glVertex3f( -.01, -.01, -.01);
    	glVertex3f( -.01, -.01, DimCadre[2]);
    	glVertex3f( DimCadre[0]+.01, -.01, DimCadre[2]);
    	glVertex3f( DimCadre[0]+.01, -.01, -.01);
 
    	glColor4f( .9 , .6, .9, 1);
    	glVertex3f( -.01, -.01, -.01);
    	glVertex3f( -.01, DimCadre[1], -.01);
    	glVertex3f( -.01, DimCadre[1], DimCadre[2]);
    	glVertex3f( -.01, -.01, DimCadre[2]);

    	glColor4f( .9 , .6, .9, 1);
    	glVertex3f( DimCadre[0]+.01, -.01, -.01);
    	glVertex3f( DimCadre[0]+.01, -.01, DimCadre[2]);
    	glVertex3f( DimCadre[0]+.01, DimCadre[1], DimCadre[2]);   	
    	glVertex3f( DimCadre[0]+.01, DimCadre[1], -.01);

        glEnd();
}

//============================================
void creer_objet_axes3d( void ){
 	   glLineWidth( 2 );
       glBegin( GL_LINES );
       glColor3f( 1, 0, 0 );
       glVertex3f( 0., 0., 0. );
       glVertex3f( 1., 0., 0. );
       glColor3f( 0, 1, 0);
       glVertex3f( 0., 0., 0. );
       glVertex3f( 0., 1., 0. );
       glColor3f( 0, 0, 1 );
       glVertex3f( 0., 0., 0. );
       glVertex3f( 0., 0., 1. );
       glEnd();
       glLineWidth( 1 );
}

Conclusion

c'est un projet fait à la demande du prof d'infographie.
On n'as eut que 6 cours donc le niveau est debutant cependant il y a beaucoup de petites choses interessantes à copier: utilisation de transparence, de lumiere, de texture etc...

Le code est commenté et structuré, il est donc relativement facil de trouver le bout de programme que l'on cherche.

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

CasseBrique.dev932 octets
CasseBrique6.c 28 531 octets
devcpp_glut.zip93 701 octets
glaux.dll1 386 496 octets
glaux.h 12 026 octets
glut32.dll221 184 octets
metal sheet64.bmp 5 174 octets

Télécharger le zip

Historique

26 octobre 2005 19:24:39 :: Comme l'indique l'un des commentaires, il y a un bug si on essait de compiler le fichier tel quel sous 'dev-cpp'. Il faut l'inclure dans un projet et aller dans 'option du projet' puis changer certaines choses. Je rajoute donc le fichier 'CasseBrique.dev' au zip. Il suffit de l'ouvrir et de cliquer sur compiler. Et ça devrait marcher... En tout cas je croise les doigts pour vous.

Sources de la même categorie

AFFICHER DES COURBES DE BEZIER par shorzy

BASE/MOTEUR 3D EN QT/OPENGL (COMPLET ET FONCTIONNEL!) POUR U... par envi33

CLASSE AVEC OPENGL - OBJETS 3D ET ANIMATIONS par rasta63

LETTRES 3D AVEC OPENGL ET QT par opossum_farceur

CUBE 3D GLUT32 VC++ ET DEVC++ par bobby03

Toutes les sources de la catégorie OpenGL

Sources en rapport avec celle ci

BASE/MOTEUR 3D EN QT/OPENGL (COMPLET ET FONCTIONNEL!) POUR U... par envi33

JEU DE COMBAT 3D GAME STUDIO par prankblack

ASTEROID DIRECT X par f_l_a_s_h_b_a_c_k

UN CASSE BRIQUE AVEC UN MENU (CONSOLE) par crazy lapinou

JEU DE CASSE-BRIQUES [DEV-C++] par Neo020585

Commentaires et avis

Commentaire de skinia le 11/07/2005 10:44:07

avoir des cours d'opengl, quelle chance mon gars

Commentaire de LordBob le 11/07/2005 20:08:01

SKINIA << je ne sais pas qu'elle age tu as... enfin pour avoir des cours d'OpenGL faut déjà choisir un cursus informatique et avoir un bon niveau en math ! comme j'ai dit je ne connais pas ton age, mais il n'est peut etre pas trop tard encore !!!

Commentaire de skinia le 12/07/2005 10:27:30

si malheureusement il est trop tard, j'ai fini les etudes d'informatique mais j'ai jamais eu de cours en opengl. parce que contrairement à ce que tu crois on n'a pas des cours d'opengl dans tous les cursus, c'est même très rare et c'est souvent en début d'etude (1ère année d'iut par ex).
tu verras qu'après tu vas vite oublier l'opengl :)

Commentaire de dletozeun le 12/07/2005 19:26:31

"tu verras qu'après tu vas vite oublier l'opengl :) "

c'est a dire?

Commentaire de Tellmarch le 13/07/2005 19:58:07

bah je suis en licence, et j'ai aussi eu des cours d'opengl...
Je pense que c'est assez fréquent.

Commentaire de iopiopiop le 03/08/2005 13:06:55

Je n'aie pas eu de cours Open Gl, je te remercie donc de nous faire profité de ton savoir faire...
MERCI

Commentaire de skinia le 03/08/2005 15:53:21

juste par curiosité,
licence de koi exactement tellmarch?

Commentaire de Tellmarch le 19/08/2005 11:30:48

informatique fondamentale il me semble :-)
mais bon c'est juste un nom, on suit les cours qu'on veut ou presque :-)

Commentaire de barbichette le 27/09/2005 08:42:00

Profitez les gars, car moi, je n'est que 25 ans et quand j'était en cours, il y a juste 5 à 6 ans, il n'y avait pas de cours d'OPENGL, c'était encore le temps des cours d'info en ligne de commande sous linux (pour éviter le piratage).
D'ailleur, j'ai vite arrêter le massacre des cours de cobol (c'était encore la mode...).
Alors le graphique, c'était rare, mais en 3D en plus...

Barbichette

Commentaire de Tellmarch le 27/09/2005 10:41:31

t'as pas choisi la bonne fac alors... ça fait plus de 20 ans qu'il y a des cours d'image et de 3d en info :-)

Commentaire de skinia le 27/09/2005 12:59:39

20 ans et puis quoi encore
désolé mais maintenant les études d'info sont plus tournées vers
les entreprises donc plus vers les nouvelles technologies style
J2EE ou .NET alors il peut y avoir quelques cours de programation
3D en début de cursus mais plus on va dans les études, plus ca disparait

Commentaire de Tellmarch le 27/09/2005 16:48:51

c'est toi qui choisit ce que tu veux faire comme info, si tu choisis des cours de BDD forcement y aura pas de 3d... Mais va pas te plaindre de ça :-)

Commentaire de RM50Man le 25/10/2005 23:34:55

Si en licence art et technique de l image ya des cours de 3D !!
Programmation graphique que ca...

Commentaire de RM50Man le 26/10/2005 00:03:32

J arrive pas a faire marcher ton code avec dev cpp
le compilateur me met:
[Build error][Project1]error1

Commentaire de goygoy le 26/10/2005 19:28:35

J'ai rajouté le fichier 'CasseBrique.dev' qui contient tous les parametres qu'il faut pour la compilation.

Commentaire de RM50Man le 26/10/2005 20:09:20

Maintenant ca me met
`M_PI' undeclared here (not in a function)

`RAND_MAX' undeclared (first use in this function)

Commentaire de goygoy le 27/10/2005 13:02:45

M_PI et RAND_MAX sont deux constantes que j'ai du trouvé dans un package de math(mais je sais plus où).
Donc tu peux rajouter la ligne: 'int M_PI=3.14159;'

Par contre je ne sais pas si le RAND_MAX est necessaire à la ligne 'brique[i][j][k] = (int) floor(rand()*4/RAND_MAX);'

Le but de cette instruction est d'associer à chaque brique un nombre {0,1,2,ou 3}. Par ex. le numero 3 rend la brique incassable. On pourrait dire qu'une brique de numero 2 rapporte plus de points qu'une brique 1 ou 0.

Le numero de brique est testé dans le timer, lorsque la boule rebondi sur la brique.

En conclusion: je crois que 'brique[i][j][k] = (int) floor(rand()*4);' est suffisant.

Commentaire de rei3 le 17/11/2005 10:11:12

Si vous voulez faire des études dans ce domaine, il exsite des licence informatique imagerie 3D temps réel. Au programme synthèse d'image avec 3ds max(100h) programmation DirectX(30h), OpenGL(30h) et CG(30h). Il faut juste prendre la bonne voix :p

Commentaire de dletozeun le 18/11/2005 22:17:09

c'est interessant ca! Mais comment s'appellent ces licences? c'est juste une spécialisation? Parce que la en tout ca fait pas enorme comme nombre d'heure...

Commentaire de rei3 le 19/11/2005 14:28:13

Ben la licence que j'ai fais étais en alternance donc y peuvent pas mettre non plus trop d'heures. Ca s'appel licence pro informatique option imagerie numérique. Mais y a pas que ca, il y en a pour tout les niveaux des formations, si tu veut y a des master spécialisé dans ce dommaine et de la prog 3D tu va bouffé que de ca. Sinon y a des iut info option imagerie numérique ou tu fais pas mal de 3D aussi.

Commentaire de dletozeun le 20/11/2005 15:10:45

merci pour l'information! :)

Commentaire de Je sais pas le 20/12/2006 14:50:57

Bonjour !!!

Je n'arrive pas à lancer ton programme casses briques.J'ai des erreurs sur le M_PI et sur la variable jeu dans le main (int jeu = glutCreateMenu( gerer_menu_jeu );

Je rencontre l'erreur sur la ligne glutAddSubMenu("JEU",jeu);

Si tu pouvais m'aider !

Merci d'avance

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

un ptit jeu [ par BLaFarD ] euh, je viens de me pondre un petit moteur 3d de merde en opengldonc, si qlqun veut me filer des model 3d k'il a fait (sous 3dsmax si possible), bah, Faire un jeu (Voiture) [ par skone007 ] Voilà depuis peu le modeuleur 3D du projet nous a quitter. Nous recherchons des personnes capables de faires des voitures et des circuits en 3D. Nou chaos game 2 en c++ [ par clira82 ] coucou je recherche de l aide pour programmer un jeu en visual c++c'est un triangle de sierpinski en recursif:Il y a un point a chaque sommet du grand casse brique pb collision [ par mat74 ] voila je suis en train de faire un casse brique et je n'arrive pas a gerer les collisions entre les briques et la balle "correctement" .je connais le projet jeu voiture 3D [ par supergrey ] Bonjour a tous.Dans le cadre de notre dernier projet de développement, nous proposons au modéliste 3D un partenariat des plus simples.En effet nous vo Pipe Game ? [ par loicus ] J'ai absolument besoin de votre aide,Je recherche le code source d'un pipe game (jeu ou il faut construire une tuyauterie au fur et a mesur que l'eau Projet de jeu sur quimper [ par vini123 ] ça y est après avoir fini mes études et connaissant une petite période de chômage j'en profite pour me lancer dans la programmation d'un moteur 3D. J' jeu casse_briques [ par ghounaya ] je veut obtenir le code sources et la simulation du jeu casse_briques en langage c++...merci lancement d'un .exe externe dans un jeu (3d, fmod) [ par aubry ] Bonjour, j'ai un problème et  c'est assez urgent...c'est pour le collège j'ai un sujet d'arts plastiques ou il faut illustrer l'ex pb lancer executable [ par mat74 ] salut a ts voila je suis en train de faire un casse brique . j'ai également fais un éditeur de niveauce sont 2 exe différent mais j'aim

Nos sponsors

Derniers Blogs

CSS CONTENT STATE SELECTORS (PERSONNAL DRAFT) par FREMYCOMPANY

MBA : POURQUOI FAIRE ET COMMENT LE CHOISIR ? par ROMELARD Fabrice

Y'A DES ERREURS QUI PEUVENT RENDRE LE DéVELOPPEUR VIOLENT par Aleks

[HYPER-V 3] PRéSENTATION DES COMMANDLETS POWERSHELL par Pierrick CATRO-BROUILLET

IIS7 - COMPRESSION GZIP par cyril

Forum

RE : CRéATION D'UN AGENDA éLECTRONIQUE par taghssa

RE : [QT]JEUX SIMILAIRE à ZELDA EN MULTIJOUEUR par Neckara

AIDE PROBLEM DE COMPILATION par pboscaiolo

ARBRE BINAIRE par pacotheking

RE : RéCUPéRER UN CHAMP D'UN QTABLEVIEW DANS UN QLINEEDIT par mature

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Cherche referenceur astucieux
Budget : 1 500€
Recherche expert advisor sous mql4 hedging
Budget : 200€
Creation boutique en ligne iphone- android - Republication.
Budget : 4 000€

Logiciels

Easy-Planning (1.0.0.1)
EASY-PLANNING (1.0.0.1)

Basé sur les mêmes principes que MyPlanning, Easy-Planning permet de créer des plannings sous la ...

Cliquez pour télécharger Easy-Planning
Academy System (17.1.3.0)
ACADEMY SYSTEM (17.1.3.0)

Logiciel de gestion des établissements. - élèves/étudiants (inscription, dossier, absence...) -...

Cliquez pour télécharger Academy System
COLLECTOR PLUS (3.00B)
COLLECTOR PLUS (3.00B)

COLLECTOR PLUS version 3.00B est un logiciel utilisant une base de données alimentée par : - L...

Cliquez pour télécharger COLLECTOR PLUS
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)

PONAMEDIA TV DEVIENS HELLLOOO FLASH LA TV SUR VOTRE ORDINATEUR. Toute une plateforme Multi...

Cliquez pour télécharger PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO
LettresFaciles 2011 (8.0.0.1)
LETTRESFACILES 2011 (8.0.0.1)

LettresFaciles est un logiciel facilitant la création et la rédaction de lettres types. Son inte...

Cliquez pour télécharger LettresFaciles 2011