Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
2183 connectés 

  FORUM HardWare.fr
  Programmation

  graphics.h

 
 


Dernière réponse
Sujet : graphics.h
arthur D'ailleur si qqn  d'autre arrive a compiler Ca.Ca serait sympa qu'il m'envoie son Graphics.h une  sa solution personnelle.......
merci

Votre réponse
Nom d'utilisateur    Pour poster, vous devez être inscrit sur ce forum .... si ce n'est pas le cas, cliquez ici !
Le ton de votre message                        
                       
Votre réponse
[b][i][u][strike][spoiler][fixed][cpp][url][email][img][*]   
 
   [quote]
 
Options

 
Vous avez perdu votre mot de passe ?


Vue Rapide de la discussion
arthur D'ailleur si qqn  d'autre arrive a compiler Ca.Ca serait sympa qu'il m'envoie son Graphics.h une  sa solution personnelle.......
merci
arthur 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 );
}
arthur C'est quelle version?
 et c'est dans graphic.h?
486dx c une librairie du borland c
arthur ca marche pas ya un probleme avec 'far'...
j'arrive pas à le compiler sous borland.
IL vient d'ou ce fichier
486dx comme ca marche pas, je vire

 

[edit]--Message édité par 486dx--[/edit]
arthur je suis débutant en C++ et je voudrais faire un programme en utilisant graphics.h .
J'ai lu que c'était une librairie borland qui était par défaut avec Borland C++ builder; moi j'ai la version 4 et je l'ai pas.
 
J'ai bien essaillé de la télécharger mais c'est jamais la bonne !!!
Alors si qqn pouvais me dire ou je pourrais la trouver ou bien par quoi je pouvais la remplacer ça m'aiderais...
 
merci d'avance

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo

Copyright © 1997-2025 Groupe LDLC (Signaler un contenu illicite / Données personnelles)