es ce que tu peux compiler ca:
/////////////////////////
// Tetris
// Borland C++
// (c)2000 David Tanguy
/////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <iostream.h>
#include <dos.h>
#include <bios.h>
#include <time.h>
/////////////////////
// Variable globale
/////////////////////
int tableau[16][21];
int x_max=15;
int y_max=19;
int X,Y;
int position_brique; // position_brique= 0,1,2 ou 3
int type_brique; // type_brique=0 ==> Brique double escalier
int niveau=0; // nb de 1/20e de seconde pour chaque intervalle
int score=0;
//////////////
// Fonctions
//////////////
void initialise_graphique(void);
void informations(void);
void jouer(void);
void init_tableau(void);
int mouvement(int);
void modif_tableau(int, int, int);
void modif_brique(int);
void nouvelle_brique(void);
void efface_ligne(void);
void verifie_game_over(void);
void augmente_niveau(void);
void augmente_score(void);
////////////////////////////
// Fonctions de validation
////////////////////////////
int valide_rotation(void);
int valide_gauche(void);
int valide_droite(void);
int valide_fixation(void);
int verifie_gauche(int, int);
int verifie_droite(int, int);
int verifie_fixation(int, int);
/////////////////
// Fonction main
/////////////////
void main(void)
{
// Efface l'ecran en mode texte
clrscr();
// Initialise et bascule en mode graphique
initialise_graphique();
// Appel de la fonction jouer()
jouer();
// Quitte le mode graphique
closegraph();
}
//////////////////////////////////////////////
// Initialise et bascule en mode graphique
//////////////////////////////////////////////
void initialise_graphique(void)
{
// Auto-detection du driver graphique
int gdriver = DETECT, gmode, errorcode;
// Initialise les graphiques et les variables locales
initgraph(&gdriver, &gmode, "" );
// Lit les resultat de l'initialisation
errorcode = graphresult();
if (errorcode != grOk) // Si erreur
{
clrscr();
cout << "***************************************\n";
cout << "Programme Tetris - (c)2000 David Tanguy\n";
cout << "***************************************\n\n";
cout << "Petite erreur graphique dont voici le d‚tail :\n";
cout << "==> " << grapherrormsg(errorcode) << "\n";
cout << "\nAppuyer sur une touche pour quitter le programme...";
getch();
exit(1);
}
}
////////////////
// Informations
////////////////
void informations(void)
{
// Divers
cout << "(c)2000 David Tanguy" << endl;
cout << "n : new" << endl;
cout << "q : quit" << endl;
cout << "+ : Aug. niveau" << endl << endl;
cout << "Niveau = " << niveau << endl << endl;
cout << "Score = " << score;
// Affiche le message "Tetris"
int x, y;
x = 295;
y = 17;
moveto(x, y);
outtext("Tetris" );
// Dessine une ellipse entre 0ø et 360ø
int x_ellipse=getmaxx() / 2;
int y_ellipse=20;
int debut_angle = 0, fin_angle = 360;
int x_rayon = 30, y_rayon = 16;
setcolor(10);
ellipse(x_ellipse, y_ellipse, debut_angle, fin_angle, x_rayon, y_rayon);
int i,j;
setcolor(6);
// Remarque : ecran 480*640 - ordonne 0-->479 - abscisse : 0 --> 639
// Dessine les lignes horizontales : ordonn‚e : 60 ==> 460
for (j=60;j<=460;j+=20)
{
line(160, j, 480, j);
}
// Dessine les lignes verticale : abcsisee : 160 ==> 480
for (i=160;i<=480;i+=20)
{
line(i, 60, i, 460);
}
}
//////////////////
// Fonction jouer
//////////////////
void jouer(void)
{
int i, difference, touche, temp;
clock_t debut;
niveau=0;
score=0;
// Afficher les informations
informations();
// Initialisation du tableau
init_tableau();
// Apparition de la 1ere brique (d'ou le 0)
nouvelle_brique();
// Attends la frappe d'une touche
debut = clock();
// q=7793 ; Q=7761
// n=12654 ; N=12622
do
{
// bioskey(1) renvoie 0 jusqu'a ce qu'une touche soit press‚
// Descente automatique durant l'attente
while (bioskey(1) == 0)
{
difference = ((clock() - debut) / CLK_TCK)*20;
if (difference > 10-niveau)
{
mouvement('b');
debut = clock();
}
}
// bioskey(0) renvoie la touche tape
touche=bioskey(0);
switch(touche)
{
case 14624 :
{
while ( mouvement('b') );
break;
}
case 18432 : temp = mouvement('r'); break;
case 19200 : temp = mouvement('g'); break;
case 19712 : temp = mouvement('d'); break;
case 20480 : temp = mouvement('b'); break;
case 20011 : augmente_niveau(); break;
default : debut = clock();
}
}
while (touche!=7793 && touche!=7761 && touche !=12654 && touche!=12622);
if (touche == 12654 || touche == 12622)
// New
{
closegraph();
initialise_graphique();
niveau=15;
jouer();
}
}
/////////////////
// Init Tableau
/////////////////
void init_tableau(void)
{
int i,j;
for (i=0;i<=x_max;i++)
{
for (j=0;j<=y_max;j++)
{
tableau[i][j]=0;
}
}
}
//////////////
// Mouvement
//////////////
int mouvement(int sens_mouvement)
{
int type_case;
// type_case = 0 si vide 1 si occupe, 2 si fige
// sens_mouvement='d' si droite, 'g' si gauche, 'b' si bas, 'r' si rotation
// Rappel : position_brique=0,1,2 ou 3 suivant le degre de rotation
/////////////
// ROTATION
/////////////
if ( sens_mouvement == 'r' && valide_rotation() )
{
//Ancienne position_brique a effacer
modif_brique(0);
//Rotation simple
position_brique=(++position_brique)%4;
modif_brique(1);
return(1);
}
////////////
//A GAUCHE
////////////
if ( sens_mouvement == 'g' && valide_gauche() )
{
//Ancienne position_brique a effacer
modif_brique(0);
//A gauche simple
X--;
modif_brique(1);
return(1);
}
////////////
//A DROITE
////////////
// ==> A droite simple
if ( sens_mouvement == 'd' && valide_droite() )
{
//Ancienne position_brique a effacer
modif_brique(0);
//A gauche simple
X++;
modif_brique(1);
return(1);
}
////////////////////////////////////////////
// FIXATION LORS D'UNE TENTATIVE DE DECENTE
////////////////////////////////////////////
if ( sens_mouvement == 'b' && valide_fixation() )
{
//On fige
modif_brique(type_brique);
// Apparition d'une nouvelle brique (d'ou le 1)
nouvelle_brique();
return(0);
}
/////////////
// DESCENTE
/////////////
//Si la fixation precedente n'a pas fonctionne...
if ( sens_mouvement =='b' )
{
//Ancienne position_brique a effacer
modif_brique(0);
//Descente simple
Y--;
modif_brique(1);
return(1);
}
}
////////////////////
// Nouvelle brique
////////////////////
void nouvelle_brique(void)
{
// Type aleatoire pour une brique (5 types de briques dispo);
type_brique=random(7)+2;
// Position aleatoire pour une brique (4 positions);
position_brique=random(4);
//Verifie si on peut effacer une ligne
efface_ligne();
// Position initiale
X=7;
switch(type_brique)
{
case 2 : // Brique en double escalier
{
switch (position_brique)
{
case 0 : Y=18; break;
case 1 : Y=18; break;
case 2 : Y=19; break;
case 3 : Y=18; break;
}
verifie_game_over();
modif_brique(1);
break;
}
case 3 : // Brique en carre
{
Y=19;
verifie_game_over();
modif_brique(1);
break;
}
case 4 : // Brique en L normal
{
switch (position_brique)
{
case 0 : Y=18; break;
case 1 : Y=19; break;
case 2 : Y=18; break;
case 3 : Y=18; break;
}
verifie_game_over();
modif_brique(1);
break;
}
case 5 : // Brique en L inverse
{
switch (position_brique)
{
case 0 : Y=18; break;
case 1 : Y=18; break;
case 2 : Y=18; break;
case 3 : Y=19; break;
}
verifie_game_over();
modif_brique(1);
break;
}
case 6 : // Brique en barre
{
switch (position_brique%2)
{
case 0 : Y=18; break;
case 1 : Y=19; break;
}
verifie_game_over();
modif_brique(1);
break;
}
case 7 : // Brique en escalier droit
{
switch (position_brique%2)
{
case 0 : Y=19; break;
case 1 : Y=18; break;
}
verifie_game_over();
modif_brique(1);
break;
}
case 8 : // Brique en escalier gauche
{
switch (position_brique%2)
{
case 0 : Y=19; break;
case 1 : Y=18; break;
}
verifie_game_over();
modif_brique(1);
break;
}
}
}
///////////////////////////////////////////////
// Fonction modifiant et affichant le tableau
///////////////////////////////////////////////
void modif_tableau(int i, int j, int valeur)
{
tableau[i][j]=valeur;
// Dessin d'une croix de couleur aux coordonne (i,j)
int x,y;
x=166+20*i;
y=446-20*j;
switch (tableau[i][j])
{
case 0 : setcolor(0); break; // Couleur noire
case 1 : // Brique en mouvement
{
switch(type_brique)
{
case 2 : setcolor(9); break;
case 3 : setcolor(10); break;
case 4 : setcolor(11); break;
case 5 : setcolor(13); break;
case 6 : setcolor(14); break;
case 7 : setcolor(2); break;
case 8 : setcolor(3); break;
}
break;
}
case 2 : setcolor(9); break;
case 3 : setcolor(10); break;
case 4 : setcolor(11); break;
case 5 : setcolor(13); break;
case 6 : setcolor(14); break;
case 7 : setcolor(2); break;
case 8 : setcolor(3); break;
}
moveto(x, y);
outtext("x" );
}
///////////////////////
// Modifie une brique
///////////////////////
void modif_brique(int type_case)
{
switch (type_brique)
{
case 2 : // Brique en escalier
{
switch (position_brique)
{
case 0 :
{
modif_tableau(X-1, Y , type_case);
modif_tableau( X ,Y+1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1, Y , type_case);
break;
}
case 1 :
{
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau( X ,Y+1, type_case);
modif_tableau(X+1, Y , type_case);
break;
}
case 2 :
{
modif_tableau(X-1, Y , type_case);
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1, Y , type_case);
break;
}
case 3 :
{
modif_tableau(X-1, Y , type_case);
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau( X ,Y+1, type_case);
break;
}
}
break;
}
case 3 : // Brique en carre
{
// Les 4 position_briques sont identiques
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1,Y-1, type_case);
modif_tableau(X+1, Y , type_case);
break;
}
case 4 : // Brique en L
{
switch (position_brique)
{
case 0 :
{
modif_tableau(X-1,Y+1, type_case);
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau( X ,Y+1, type_case);
break;
}
case 1 :
{
modif_tableau(X-1,Y-1, type_case);
modif_tableau(X-1, Y , type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1, Y , type_case);
break;
}
case 2 :
{
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau( X ,Y+1, type_case);
modif_tableau(X+1,Y-1, type_case);
break;
}
case 3 :
{
modif_tableau(X-1, Y , type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1, Y , type_case);
modif_tableau(X+1,Y+1, type_case);
break;
} }
break;
}
case 5 : // Brique en L inverve
{
switch (position_brique)
{
case 0 :
{
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau( X ,Y+1, type_case);
modif_tableau(X+1,Y+1, type_case);
break;
}
case 1 :
{
modif_tableau(X-1,Y+1, type_case);
modif_tableau(X-1, Y , type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1, Y , type_case);
break;
}
case 2 :
{
modif_tableau(X-1,Y-1, type_case);
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau( X ,Y+1, type_case);
break;
}
case 3 :
{
modif_tableau(X-1, Y , type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1, Y , type_case);
modif_tableau(X+1,Y-1, type_case);
break;
}
}
break;
}
case 6 : // Brique en barre
{
switch (position_brique%2)
{
case 0 :
{
modif_tableau( X ,Y-2, type_case);
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau( X ,Y+1, type_case);
break;
}
case 1 :
{
modif_tableau(X-1, Y , type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1, Y , type_case);
modif_tableau(X+2, Y , type_case);
break;
}
}
break;
}
case 7 : // Brique en escalier droit
{
switch (position_brique%2)
{
case 0 :
{
modif_tableau(X-1,Y-1, type_case);
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1, Y , type_case);
break;
}
case 1 :
{
modif_tableau( X , Y , type_case);
modif_tableau( X ,Y+1, type_case);
modif_tableau(X+1,Y-1, type_case);
modif_tableau(X+1, Y , type_case);
break;
}
}
break;
}
case 8 : // Brique en escalier gauche
{
switch (position_brique%2)
{
case 0 :
{
modif_tableau(X-1, Y , type_case);
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1,Y-1, type_case);
break;
}
case 1 :
{
modif_tableau( X ,Y-1, type_case);
modif_tableau( X , Y , type_case);
modif_tableau(X+1, Y , type_case);
modif_tableau(X+1,Y+1 , type_case);
break;
}
}
break;
}
}
}
/////////////////////////////////////////////
// Efface une (des) ligne(s) si neccessaire
/////////////////////////////////////////////
void efface_ligne(void)
{
int i,j;
int i0,j0;
int nb_case_fige;
int ligne_a_supprimer;
for (j=0;j<=y_max;j++)
{
nb_case_fige=0;
for (i=0;i<=x_max;i++)
{
if (tableau[i][j] >= 2) nb_case_fige++;
}
if (nb_case_fige==16)
{
// Efface la ligne
for (j0=j;j0<=y_max-1;j0++)
{
for (i0=0;i0<=x_max;i0++)
{
modif_tableau(i0 ,j0 ,tableau[i0][j0+1]);
}
}
j--; //Permet de rexaminer la ligne en question
// Augmente le score
augmente_score();
}
}
}
////////////////////////
// Verifie si Game Over
////////////////////////
void verifie_game_over(void)
{
// position_brique represente la position_brique de la brique a apparaitre
Y--;
int touche;
int resultat=0;
switch(type_brique)
{
case 2 : // Brique en escalier
{
switch (position_brique)
{
case 0 :
{
if (
tableau[ X ][Y+1] >= 2 ||
tableau[X-1][ Y ] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][ Y ] >= 2 )
resultat=1;
break;
}
case 1 :
{
if (
tableau[ X ][Y-1] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[ X ][Y+1] >= 2 ||
tableau[X+1][ Y ] >= 2 )
resultat=1;
break;
}
case 2 :
{
if (
tableau[ X ][Y-1] >= 2 ||
tableau[X-1][ Y ] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][ Y ] >= 2
)
resultat=1;
break;
}
case 3 :
{
if (
tableau[ X ][Y-1] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[ X ][Y+1] >= 2 ||
tableau[X-1][ Y ] >= 2 )
resultat=1;
break;
}
}
break;
}
case 3 : // Brique en carre
{
// Les 4 position_briques sont identiques
if (
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][ Y ] >= 2 ||
tableau[ X ][Y-1] >= 2 ||
tableau[X+1][Y-1] >= 2 )
resultat=1;
break;
}
case 4 : // Brique en L
{
switch (position_brique)
{
case 0 :
{
if (
tableau[X-1][Y+1] >= 2 ||
tableau[ X ][Y-1] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[ X ][Y+1] >= 2
)
resultat=1;
break;
}
case 1 :
{
if (
tableau[X-1][Y-1] >= 2 ||
tableau[X-1][ Y ] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][ Y ] >= 2 )
resultat=1;
break;
}
case 2 :
{
if (
tableau[X+1][Y-1] >= 2 ||
tableau[ X ][Y-1] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[ X ][Y+1] >= 2 )
resultat=1;
break;
}
case 3 :
{
if (
tableau[X+1][Y+1] >= 2 ||
tableau[X-1][ Y ] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][ Y ] >= 2 )
resultat=1;
break;
}
}
break;
}
case 5 : // Brique en L inverve
{
switch (position_brique)
{
case 0 :
{
if (
tableau[X+1][Y+1] >= 2 ||
tableau[ X ][Y-1] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[ X ][Y+1] >= 2 )
resultat=1;
break;
}
case 1 :
{
if (
tableau[X-1][Y+1] >= 2 ||
tableau[X-1][ Y ] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][ Y ] >= 2 )
resultat=1;
break;
}
case 2 :
{
if (
tableau[X-1][Y-1] >= 2 ||
tableau[ X ][Y-1] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[ X ][Y+1] >= 2 )
resultat=1;
break;
}
case 3 :
{
if (
tableau[X+1][Y-1] >= 2 ||
tableau[X-1][ Y ] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][ Y ] >= 2 )
resultat=1;
break;
}
}
break;
}
case 6 : // Brique en barre
{
switch (position_brique%2)
{
case 0 :
{
if (
tableau[ X ][Y+1] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[ X ][Y-1] >= 2 ||
tableau[ X ][Y-2] >= 2 )
resultat=1;
break;
}
case 1 :
{
if (
tableau[X-1][ Y ] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][ Y ] >= 2 ||
tableau[X+2][ Y ] >= 2 )
resultat=1;
break;
}
}
break;
}
case 7 : // Brique en escalier droit
{
switch (position_brique%2)
{
case 0 :
{
if (
tableau[X-1][Y-1] >= 2 ||
tableau[ X ][Y-1] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][ Y ] >= 2 )
break;
}
case 1 :
{
if (
tableau[ X ][ Y ] >= 2 ||
tableau[ X ][Y+1] >= 2 ||
tableau[X+1][Y-1] >= 2 ||
tableau[X+1][ Y ] >= 2 )
break;
}
}
break;
}
case 8 : // Brique en escalier gauche
{
switch (position_brique%2)
{
case 0 :
{
if (
tableau[X-1][ Y ] >= 2 ||
tableau[ X ][Y-1] >= 2 ||
tableau[ X ][ Y ] >= 2 ||
tableau[X+1][Y-1] >= 2 )
break;
}
case 1 :
{
if (
tableau[ X ][Y-1] >=2 ||
tableau[ X ][ Y ] >=2 ||
tableau[X+1][ Y ] >=2 ||
tableau[X+1][Y+1] >=2 )
break;
}
}
break;
}
}
Y++;
if (resultat==1 )
{
gotoxy(1,10);
cout << "GAME OVER";
// q=7793 ; Q=7761
// n=12654 ; N=12622
do
{
// bioskey(0) renvoie la touche tape
touche = bioskey(0);
}
while (touche!=7793 && touche!=7761 && touche !=12654 && touche!=12622);
if (touche == 12654 || touche == 12622)
// New
{
closegraph();
initialise_graphique();
niveau=15;
jouer();
}
else
// Quit
{
exit(1);
}
}
}
//////////////////////////////
// Augmenter de niveau
//////////////////////////////
void augmente_niveau(void)
{
if (niveau <= 8) niveau++;
gotoxy(1,6);
cout << "Niveau = " << niveau;
}
///////////////////////
// Augmenter le score
///////////////////////
void augmente_score(void)
{
score+=10*(niveau+1);
gotoxy(1,8);
cout << "Score = " << score;
}
//////////////////////////////
// Valide une rotation simple
//////////////////////////////
int valide_rotation(void)
{
switch(type_brique)
{
case 2 : // Brique en double escalier
{
switch (position_brique)
{
case 0 : return ( tableau[ X ][Y-1] < 2 && Y-1 >= 0 );
case 1 : return ( tableau[X-1][ Y ] < 2 && X-1 >= 0 );
case 2 : return ( tableau[ X ][Y+1] < 2 && Y+1 <= y_max );
case 3 : return ( tableau[X+1][ Y ] < 2 && X+1 <= x_max );
}
}
case 3 : return(1); // Brique carre
case 4 : // Brique en L normal
{
switch (position_brique)
{
case 0 : return ( tableau[X-1][Y-1] < 2 && tableau[X-1][ Y ] < 2 && tableau[X+1][ Y ] < 2 && X+1 <= x_max );
case 1 : return ( tableau[ X ][Y-1] < 2 && tableau[X+1][Y-1] < 2 && tableau[ X ][Y+1] < 2 && Y+1 <= y_max );
case 2 : return ( tableau[X-1][Y-1] < 2 && tableau[X+1][ Y ] < 2 && tableau[X+1][Y+1] < 2 && X-1 >= 0 );
case 3 : return ( tableau[ X ][Y-1] < 2 && tableau[X-1][Y+1] < 2 && tableau[ X ][Y+1] < 2 && Y-1 >= 0 );
}
}
case 5 : // Brique en L inverse
{
switch (position_brique)
{
case 0 : return ( tableau[X-1][Y+1] < 2 && tableau[X-1][ Y ] < 2 && tableau[X+1][ Y ] < 2 && X-1 >= 0 );
case 1 : return ( tableau[ X ][Y-1] < 2 && tableau[X-1][Y-1] < 2 && tableau[ X ][Y+1] < 2 && Y-1 >= 0 );
case 2 : return ( tableau[X-1][Y-1] < 2 && tableau[X+1][ Y ] < 2 && tableau[X+1][Y-1] < 2 && X+1 <= x_max );
case 3 : return ( tableau[ X ][Y-1] < 2 && tableau[X+1][Y+1] < 2 && tableau[ X ][Y+1] < 2 && Y+1 <= y_max );
}
}
case 6 : // Brique en barre
{
switch (position_brique%2)
{
case 0 : return ( tableau[X-1][ Y ] < 2 && tableau[X+1][ Y ] < 2 && tableau[X+2][ Y ] < 2 && X-1 >=0 && X+2 <= x_max );
case 1 : return ( tableau[ X ][Y-2] < 2 && tableau[ X ][Y-1] < 2 && tableau[ X ][Y+1] < 2 && Y-2 >=0 && Y+1 <= y_max );
}
}
case 7 : // Brique en escalier droit
{
switch (position_brique%2)
{
case 0 : return ( tableau[ X ][Y+1] < 2 && tableau[X+1][Y-1] < 2 && Y+1 <= y_max );
case 1 : return ( tableau[ X ][Y-1] < 2 && X-1 >= 0 );
}
}
case 8 : // Brique en escalier gauche
{
switch (position_brique%2)
{
case 0 : return ( tableau[X+1][Y+1] < 2 && Y+1 <= y_max );
case 1 : return ( tableau[X-1][ Y ] < 2 && tableau[X+1][Y-1] < 2 && X+1 <= x_max );
}
}
}
}
////////////////////////////////////////
// Valide un mouvement a gauche simple
////////////////////////////////////////
int valide_gauche()
{
switch(type_brique)
{
case 2 : // Brique double escalier
{
switch (position_brique)
{
case 0 : return ( verifie_gauche( X ,Y+1) * verifie_gauche(X-1, Y ) );
case 1 : return ( verifie_gauche( X ,Y+1) * verifie_gauche( X , Y ) * verifie_gauche( X ,Y-1) );
case 2 : return ( verifie_gauche( X ,Y-1) * verifie_gauche(X-1, Y ) );
case 3 : return ( verifie_gauche( X ,Y+1) * verifie_gauche(X-1, Y ) * verifie_gauche( X ,Y-1) );
}
}
case 3 : // Brique carre
{
return ( verifie_gauche(X,Y) * verifie_gauche(X,Y-1) );
}
case 4 : // Brique L normal
{
switch (position_brique)
{
case 0 : return ( verifie_gauche( X ,Y-1) * verifie_gauche( X , Y ) * verifie_gauche(X-1,Y+1) );
case 1 : return ( verifie_gauche(X-1,Y-1) * verifie_gauche(X-1, Y ) );
case 2 : return ( verifie_gauche( X ,Y-1) * verifie_gauche( X , Y ) * verifie_gauche( X ,Y+1) );
case 3 : return ( verifie_gauche(X-1, Y ) * verifie_gauche(X+1,Y+1) );
}
}
case 5 : // Brique L inverse
{
switch (position_brique)
{
case 0 : return ( verifie_gauche( X ,Y-1) * verifie_gauche( X , Y ) * verifie_gauche( X ,Y+1) );
case 1 : return ( verifie_gauche(X-1, Y ) * verifie_gauche(X-1,Y+1) );
case 2 : return ( verifie_gauche(X-1,Y-1) * verifie_gauche( X , Y ) * verifie_gauche( X ,Y+1) );
case 3 : return ( verifie_gauche(X+1,Y-1) * verifie_gauche(X-1, Y ) );
}
}
case 6 : // Brique en barre
{
switch (position_brique%2)
{
case 0 : return ( verifie_gauche( X ,Y-2) * verifie_gauche( X ,Y-1) * verifie_gauche( X , Y) * verifie_gauche( X ,Y+1) );
case 1 : return ( verifie_gauche(X-1, Y ) );
}
}
case 7 : // Brique en escalier droit
{
switch (position_brique%2)
{
case 0 : return ( verifie_gauche(X-1,Y-1) * verifie_gauche( X , Y ) );
case 1 : return ( verifie_gauche( X , Y ) * verifie_gauche( X ,Y+1) * verifie_gauche(X+1,Y-1) );
}
}
case 8 : // Brique en escalier gauche
{
switch (position_brique%2)
{
case 0 : return ( verifie_gauche(X-1, Y ) * verifie_gauche( X ,Y-1) );
case 1 : return ( verifie_gauche( X ,Y-1) * verifie_gauche( X , Y ) * verifie_gauche(X+1,Y+1) );
}
}
}
}
////////////////////////////////////////
// Valide un mouvement a droite simple
////////////////////////////////////////
int valide_droite()
{
switch(type_brique)
{
case 2 : // Brique en double escalier
{
switch (position_brique)
{
case 0 : return ( verifie_droite( X ,Y+1) * verifie_droite(X+1, Y ) );
case 1 : return ( verifie_droite( X ,Y+1) * verifie_droite(X+1, Y ) * verifie_droite( X ,Y-1) );
case 2 : return ( verifie_droite( X ,Y-1) * verifie_droite(X+1, Y ) );
case 3 : return ( verifie_droite( X ,Y+1) * verifie_droite( X , Y ) * verifie_droite( X ,Y-1) );
}
}
case 3 : // Brique en carre
{
return ( verifie_droite(X+1,Y) * verifie_droite(X+1,Y-1) );
}
case 4 : // Brique en L normal
{
switch (position_brique)
{
case 0 : return ( verifie_droite( X ,Y-1) * verifie_droite( X , Y ) * verifie_droite( X ,Y+1) );
case 1 : return ( verifie_droite(X-1,Y-1) * verifie_droite(X+1,Y) );
case 2 : return ( verifie_droite(X+1,Y-1) * verifie_droite( X , Y ) * verifie_droite( X ,Y+1) );
case 3 : return ( verifie_droite(X+1, Y ) * verifie_droite(X+1,Y+1) );
}
}
case 5 : // Brique en L inverse
{
switch (position_brique)
{
case 0 : return ( verifie_droite( X ,Y-1) * verifie_droite( X , Y ) * verifie_droite(X+1,Y+1) );
case 1 : return ( verifie_droite(X+1, Y ) * verifie_droite(X-1,Y+1) );
case 2 : return ( verifie_droite( X ,Y-1) * verifie_droite( X , Y ) * verifie_droite( X ,Y+1) );
case 3 : return ( verifie_droite(X+1,Y-1) * verifie_droite(X+1, Y ) );
}
}
case 6 : // Brique en barre
{
switch (position_brique%2)
{
case 0 : return ( verifie_droite( X ,Y-2) * verifie_droite( X ,Y-1) * verifie_droite( X , Y) * verifie_droite( X ,Y+1) );
case 1 : return ( verifie_droite(X+2, Y ) );
}
}
case 7 : // Brique en escalier droit
{
switch (position_brique%2)
{
case 0 : return ( verifie_droite( X ,Y-1) * verifie_droite(X+1, Y ) );
case 1 : return ( verifie_droite(X+1, Y ) * verifie_droite( X ,Y+1) * verifie_droite(X+1,Y-1) );
}
}
case 8 : // Brique en escalier droite
{
switch (position_brique%2)
{
case 0 : return ( verifie_droite( X , Y ) * verifie_droite(X+1,Y-1) );
case 1 : return ( verifie_droite( X ,Y-1) * verifie_droite(X+1, Y ) * verifie_droite(X+1,Y+1) );
}
}
}
}
/////////////////////////////////////////////////////////
// Valide un figement (lors d'une tentative de descente)
/////////////////////////////////////////////////////////
int valide_fixation(void)
{
switch(type_brique)
{
case 2 : // Brique double escalier
{
switch (position_brique)
{
case 0 : return ( verifie_fixation(X-1, Y ) + verifie_fixation( X , Y ) + verifie_fixation(X+1, Y ) );
case 1 : return ( verifie_fixation( X ,Y-1) + verifie_fixation(X+1, Y ) );
case 2 : return ( verifie_fixation( X ,Y-1) + verifie_fixation(X-1, Y ) + verifie_fixation(X+1, Y ) );
case 3 : return ( verifie_fixation( X ,Y-1) + verifie_fixation(X-1, Y ) );
}
}
case 3 : // Brique carre
{
return ( verifie_fixation( X ,Y-1) + verifie_fixation(X+1,Y-1) );
}
case 4 : // Brique L normal
{
switch (position_brique)
{
case 0 : return ( verifie_fixation(X-1,Y+1) + verifie_fixation( X ,Y-1) );
case 1 : return ( verifie_fixation(X-1,Y-1) + verifie_fixation( X , Y ) + verifie_fixation(X+1, Y ) );
case 2 : return ( verifie_fixation( X ,Y-1) + verifie_fixation(X+1,Y-1) );
case 3 : return ( verifie_fixation(X-1, Y ) + verifie_fixation( X , Y ) + verifie_fixation(X+1, Y ) );
}
}
case 5 : // Brique L inverse
{
switch (position_brique)
{
case 0 : return ( verifie_fixation( X ,Y-1) + verifie_fixation(X+1,Y+1) );
case 1 : return ( verifie_fixation(X-1, Y ) + verifie_fixation( X , Y ) + verifie_fixation(X+1, Y ) );
case 2 : return ( verifie_fixation(X-1,Y-1) + verifie_fixation( X ,Y-1) );
case 3 : return ( verifie_fixation(X-1, Y ) + verifie_fixation( X , Y ) + verifie_fixation(X+1,Y-1) );
}
}
case 6 : // Brique en barre
{
switch (position_brique%2)
{
case 0 : return ( verifie_fixation( X ,Y-2) );
case 1 : return ( verifie_fixation(X-1, Y ) + verifie_fixation( X , Y ) + verifie_fixation(X+1, Y ) + verifie_fixation(X+2, Y ) );
}
}
case 7 : // Brique en escalier droit
{
switch (position_brique%2)
{
case 0 : return ( verifie_fixation(X-1,Y-1) + verifie_fixation( X ,Y-1) + verifie_fixation(X+1, Y ) );
case 1 : return ( verifie_fixation( X , Y ) + verifie_fixation(X+1,Y-1) );
}
}
case 8 : // Brique en escalier gauche
{
switch (position_brique%2)
{
case 0 : return ( verifie_fixation(X-1, Y ) + verifie_fixation( X ,Y-1) + verifie_fixation(X+1,Y-1));
case 1 : return ( verifie_fixation( X ,Y-1) + verifie_fixation(X+1, Y ) );
}
}
}
}
/////////////////////////////
// Verification de la gauche
/////////////////////////////
int verifie_gauche(int x, int y)
{
//1 case a gauche de libre ET brique non fige
return ( x >= 1 && tableau[x-1][y] < 2 );
}
/////////////////////////////
// Verification de la droite
/////////////////////////////
int verifie_droite(int x, int y)
{
//1 case a droite de libre ET brique non fige
return ( x <= x_max-1 && tableau[x+1][y] < 2 );
}
////////////////////////////////
// Verification de la fixation
////////////////////////////////
int verifie_fixation(int x, int y)
{
//0 case en bas de libre OU case au dessous fig‚
return ( y == 0 || tableau[x][y-1] >= 2 );
}
---------------
@rthur
