Tetris

Tetris - C++ - Programmation

Marsh Posté le 09-02-2009 à 11:16:19    

Salut,
 
Je débute en C++, je suis tjs en train d'apprendre  les bases du langage. Mais j'ai besoin d'un challenge pour mieux progresser...  
 
J'ai donc décider de tenter de faire un Tetris. Je commence de Zero! et j'ai juste commencé a réfléchir sur comment le programme devrait se structurer.
 
Auriez vous des informations sur un Tetris en C++ ?
 
Je suppose que d'autre s'y on déjà frotté?  
 
Ciao  
Andy

Reply

Marsh Posté le 09-02-2009 à 11:16:19   

Reply

Marsh Posté le 09-02-2009 à 12:54:45    

Bah en vrac : va certainement déjà commencé par une modélisation objet de ton truc.
 
Dans ton jeu, tu as 2 niveaux : la visualisation et le modèle interne de l'état de la partie. En gros, quelles sont les entités qui rentrent en jeu pr l'affichage et pr le jeu en lui même. Certaine existeront dans les deux (les pièces par exemple) mais auront des comportements potentiellement différent. Il est bon de voir à découpler évolution du jeu et affichage en outre.
 
Après, comme toute appli interactive, va falloir prendre en compte le temps qui passe et le caractère asynchrone des interactions avec le joueur.  
 
Quand cette réflexion sera mené, on avisera pour le code :o

Reply

Marsh Posté le 09-02-2009 à 13:39:08    

Mmmm, intéressant...
 
Ton approche a un nom? C'est issu d'une théorie quelconque?  
 
Je dois dire que j'ai déjà programmé en Basic/Fortran/VBA/VB et meme assembleur. Mais les programmes étaient simples...  
 
le code ne me fait pas vraiment peur.
 
C'est plus dans la structuration... que se soit pour Tetris ou pour autre chose...
 
++  
 


---------------
Un Mars par jour en forme toujours
Reply

Marsh Posté le 09-02-2009 à 14:00:54    

bah UML quoi :E

Reply

Marsh Posté le 09-02-2009 à 21:43:16    

Tu débutes en C++ ou en programmation en général ? Si tu débutes en programmation en général, je te conseillerais plutôt de commencer par essayer de trouver comment résoudre les problèmes bas niveau (comme dit Joel F, affichage des pièces, récupérer les actions du joueur, gérer l'écoulement du temps, etc.) avant de penser à la structure haut niveau du jeu.
 
Peut-être essayer déjà d'afficher une pièce du jeu, puis quand ça marche, la faire se déplacer à droite ou à gauche avec le clavier, et quand ça marche, tu pourra penser à la logique du jeu en lui même (collision des pièces, détection des lignes pleines, faire descendre le tout quand tu fais une ligne, etc.).
 
Il faudra que tu choisisses les technologies à utiliser pour faire tout ça (SDL, DirectX, ou que sais-je).
 
L'idée serait de savoir déjà a peu près comment tu va pouvoir faire chaque élément du jeu avant de penser à les mettre ensemble (je ne dis pas du tout que ce n'est pas important, au contraire, mais simplement que tu ne pourra pas concevoir l'architecture générale du programme si tu n'as aucune idée du fonctionnement de chaque élément de l'ensemble).

Reply

Marsh Posté le 09-02-2009 à 23:32:54    

j'ose meme pas balancer le code du tetris que j'ai codé l'an dernier avant d'apprendre la POO,  
 
avec glut,  
 
c'est assez immonde, mais juste pour le plaisir :
 

Code :
  1. // Tetris en OpenGL
  2. // dev par tomas, 12/2007
  4. #include <GL/glut.h>
  5. #include <iostream>
  6. #include <sstream>
  7. #include <math.h>
  8. using namespace std;
  10. #define COLS 10
  11. #define ROWS 19
  12. #define BLOCKSIZE 0.1
  13. #define OFFSET 0.01
  14. #define FALLSPEED 1
  16. int ** gameArray;
  17. int ** movingParts;
  18. int nxtPiece;
  19. int score(0);
  20. bool gameState(true);
  21. int speed(1000);
  22. int nxtLevel(0);
  23. bool mirror(false);
  25. void initGameArray();
  26. void initMovingParts();
  28. void affichage();
  29. void clavier(unsigned char touche,int x,int y);
  30. GLvoid fall(int val);
  32. void moveDownMovingParts();
  33. bool isMoveableDown(int x, int y);
  34. void moveLRMovingParts(char touche);
  35. bool isMoveableLR(char touche, int x, int y);
  36. void rotateMovingParts();
  37. int determinePivot();
  38. bool isBlockFree(int x, int y);
  39. int chooseNewPiece();
  40. bool initNewPiece();
  41. bool isGameOver();
  42. void drawContainer();
  43. void drawNxtPiece();
  44. void scanRows();
  45. void removeRow(int inxdRow);
  46. void afficheStr(const string &chaine, void* font, float x, float y);
  47. string makeStrScore();
  48. void pauseGame();
  50. typedef struct {
  51. float x; float y; float r; float g; float b;
  52. } block;
  54. typedef struct {
  55. float r; float g; float b;
  56. } color;
  58. color colorsBlock[8] = {
  59. {0.0, 0.0, 0.0},{0.0, 0.0, 1.0},{0.0, 1.0, 0.0},{0.0, 1.0, 1.0},
  60. {1.0, 0.0, 0.0},{1.0, 0.0, 1.0},{1.0, 1.0, 0.0},{1.0, 1.0, 1.0}
  61. };
  63. int main(int argc,char **argv){
  64. initGameArray();
  65. initMovingParts();
  66. glutInit(&argc,argv);
  67. glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
  68. glutInitWindowPosition(0,0);
  69. glutInitWindowSize(400,400);
  70. glutCreateWindow("TetrisCore v0.01" );
  71. glClearColor(0.0,0.0,0.0,0.0);
  72. glColor3f(1.0,1.0,1.0);
  73. glPointSize(2.0);
  74. glutDisplayFunc(affichage);
  75. glutKeyboardFunc(clavier);
  76. glutTimerFunc(speed, fall, 10);
  77. glutMainLoop();
  78. return 0;
  79. }
  80. void initGameArray(){
  81. gameArray = new int * [ROWS];
  82. for (int i = 0; i < ROWS; i++)
  83.  gameArray[i] = new int[COLS];
  84. for (int i=0; i < ROWS; i++)
  85.  for (int j=0; j < COLS; j++)
  86.   gameArray[i][j] = 0;
  87. }
  88. void initMovingParts(){
  89. movingParts = new int * [4];
  90. for (int i = 0; i < 4; i++){
  91.  movingParts[i] = new int[3]; // x, y, indxClr
  92.  for (int j = 0; j < 3; j++)
  93.   movingParts[i][j] = -1;
  94. }
  95. chooseNewPiece();
  96. initNewPiece();
  97. }
  98. void affichage(){
  99. glClear(GL_COLOR_BUFFER_BIT);
  100. drawContainer();
  101. drawNxtPiece();
  102. string strScore = makeStrScore();
  103. afficheStr(strScore, GLUT_BITMAP_HELVETICA_18, 0.25, -0.9);
  104. float yf, xf;
  105. int i(0), j(0), iplus(1), stopi(ROWS), stopj(COLS), colorXY;
  106. if (mirror){
  107.  i = ROWS;
  108.  stopi = 0;
  109.  iplus = -1;
  110. }
  111. for (yf = -0.85 ; i < stopi; i+=iplus, yf+=0.1) {
  112.  for (j=0, xf = -0.85; j < COLS; j++, xf+=0.1) {
  113.   colorXY = gameArray[i][j];
  114.   for (int k = 0; k < 4; k++)
  115.    if (movingParts[k][0] == j && movingParts[k][1] == i)
  116.     colorXY = movingParts[k][2];
  117.   if (colorXY != 0){
  118.    glBegin(GL_POLYGON);
  119.    glColor3f(colorsBlock[colorXY].r,colorsBlock[colorXY].g,colorsBlock[colorXY].b);
  120.    glVertex2f(xf - BLOCKSIZE / 2 + OFFSET / 2, yf - BLOCKSIZE / 2 + OFFSET / 2);
  121.    glVertex2f(xf + BLOCKSIZE / 2 - OFFSET / 2, yf - BLOCKSIZE / 2 + OFFSET / 2);
  122.    glVertex2f(xf + BLOCKSIZE / 2 - OFFSET / 2, yf + BLOCKSIZE / 2 - OFFSET / 2);
  123.    glVertex2f(xf - BLOCKSIZE / 2 + OFFSET / 2, yf + BLOCKSIZE / 2 - OFFSET / 2);
  124.    glEnd();
  125.   }
  126.  }
  127. }
  128. glutSwapBuffers();
  129. glFlush();
  130. }
  131. void clavier(unsigned char touche,int x,int y){
  132. switch (touche){
  133.  case 'p':
  134.   pauseGame();
  135.  case 's':
  136.   moveDownMovingParts();
  137.   glutPostRedisplay();
  138.   break;
  139.  case 'a' : case 'd' :
  140.   moveLRMovingParts(touche);
  141.   glutPostRedisplay();
  142.   break;
  143.  case 'w' :
  144.   rotateMovingParts();
  145.   glutPostRedisplay();
  146.   break;
  147.  case 'm' :
  148.   mirror = !mirror;
  149.   glutPostRedisplay();
  150. }
  151. }
  152. void drawContainer(){
  153. glBegin(GL_LINE);
  154. glColor3f(1.0, 1.0, 1.0);
  155. glVertex2f(-0.95, -0.95);
  156. glVertex2f(-0.95, 0.75);
  157. glVertex2f(0.15, -0.95);
  158. glVertex2f(0.15, 0.75);
  159. glVertex2f(-0.95, -0.95);
  160. glVertex2f(0.15, -0.95);
  161. glEnd();
  162. }
  163. void drawNxtPiece(){
  164. int ** nxtPieceBlocks;
  165. nxtPieceBlocks = new int * [4];
  166. for (int i = 0; i < 4; i++){
  167.  nxtPieceBlocks[i] = new int[3]; // x, y, indxClr
  168.  for (int j = 0; j < 3; j++)
  169.   nxtPieceBlocks[i][j] = -1;
  170. }
  171. switch (nxtPiece){
  172.  case 0 :
  173.   nxtPieceBlocks[0][0] = 5; nxtPieceBlocks[0][1] = ROWS-1; nxtPieceBlocks[0][2] = 4;
  174.   nxtPieceBlocks[1][0] = 5; nxtPieceBlocks[1][1] = ROWS-2; nxtPieceBlocks[1][2] = 4;
  175.   nxtPieceBlocks[2][0] = 5; nxtPieceBlocks[2][1] = ROWS-3; nxtPieceBlocks[2][2] = 4;
  176.   nxtPieceBlocks[3][0] = 5; nxtPieceBlocks[3][1] = ROWS-4; nxtPieceBlocks[3][2] = 4;
  177.   break;
  178.  case 1 :
  179.   nxtPieceBlocks[0][0] = 5; nxtPieceBlocks[0][1] = ROWS-1; nxtPieceBlocks[0][2] = 2;
  180.   nxtPieceBlocks[1][0] = 5; nxtPieceBlocks[1][1] = ROWS-2; nxtPieceBlocks[1][2] = 2;
  181.   nxtPieceBlocks[2][0] = 6; nxtPieceBlocks[2][1] = ROWS-1; nxtPieceBlocks[2][2] = 2;
  182.   nxtPieceBlocks[3][0] = 6; nxtPieceBlocks[3][1] = ROWS-2; nxtPieceBlocks[3][2] = 2;
  183.   break;
  184.  case 2 :
  185.   nxtPieceBlocks[0][0] = 5; nxtPieceBlocks[0][1] = ROWS-1; nxtPieceBlocks[0][2] = 6;
  186.   nxtPieceBlocks[1][0] = 5; nxtPieceBlocks[1][1] = ROWS-2; nxtPieceBlocks[1][2] = 6;
  187.   nxtPieceBlocks[2][0] = 6; nxtPieceBlocks[2][1] = ROWS-2; nxtPieceBlocks[2][2] = 6;
  188.   nxtPieceBlocks[3][0] = 6; nxtPieceBlocks[3][1] = ROWS-3; nxtPieceBlocks[3][2] = 6;
  189.   break;
  190.  case 3 :
  191.   nxtPieceBlocks[0][0] = 6; nxtPieceBlocks[0][1] = ROWS-1; nxtPieceBlocks[0][2] = 3;
  192.   nxtPieceBlocks[1][0] = 6; nxtPieceBlocks[1][1] = ROWS-2; nxtPieceBlocks[1][2] = 3;
  193.   nxtPieceBlocks[2][0] = 5; nxtPieceBlocks[2][1] = ROWS-2; nxtPieceBlocks[2][2] = 3;
  194.   nxtPieceBlocks[3][0] = 5; nxtPieceBlocks[3][1] = ROWS-3; nxtPieceBlocks[3][2] = 3;
  195.   break;
  196.  case 4 :
  197.   nxtPieceBlocks[0][0] = 5; nxtPieceBlocks[0][1] = ROWS-1; nxtPieceBlocks[0][2] = 7;
  198.   nxtPieceBlocks[1][0] = 5; nxtPieceBlocks[1][1] = ROWS-2; nxtPieceBlocks[1][2] = 7;
  199.   nxtPieceBlocks[2][0] = 5; nxtPieceBlocks[2][1] = ROWS-3; nxtPieceBlocks[2][2] = 7;
  200.   nxtPieceBlocks[3][0] = 6; nxtPieceBlocks[3][1] = ROWS-3; nxtPieceBlocks[3][2] = 7;
  201.   break;
  202.  case 5 :
  203.   nxtPieceBlocks[0][0] = 6; nxtPieceBlocks[0][1] = ROWS-1; nxtPieceBlocks[0][2] = 5;
  204.   nxtPieceBlocks[1][0] = 6; nxtPieceBlocks[1][1] = ROWS-2; nxtPieceBlocks[1][2] = 5;
  205.   nxtPieceBlocks[2][0] = 6; nxtPieceBlocks[2][1] = ROWS-3; nxtPieceBlocks[2][2] = 5;
  206.   nxtPieceBlocks[3][0] = 5; nxtPieceBlocks[3][1] = ROWS-3; nxtPieceBlocks[3][2] = 5;
  207.   break;
  208.  case 6 :
  209.   nxtPieceBlocks[0][0] = 5; nxtPieceBlocks[0][1] = ROWS-1; nxtPieceBlocks[0][2] = 1;
  210.   nxtPieceBlocks[1][0] = 5; nxtPieceBlocks[1][1] = ROWS-2; nxtPieceBlocks[1][2] = 1;
  211.   nxtPieceBlocks[2][0] = 5; nxtPieceBlocks[2][1] = ROWS-3; nxtPieceBlocks[2][2] = 1;
  212.   nxtPieceBlocks[3][0] = 6; nxtPieceBlocks[3][1] = ROWS-2; nxtPieceBlocks[3][2] = 1;
  213.   break;
  214. }
  215. float yf, xf;
  216. int i, j, colorXY;
  217. for (i = ROWS-4, yf = -0.65 ; i < ROWS; i++, yf+=0.1) {
  218.  for (j = 5, xf = 0.55; j < 7; j++, xf+=0.1) {
  219.   colorXY = 0;
  220.   for (int k = 0; k < 4; k++)
  221.    if (nxtPieceBlocks[k][0] == j && nxtPieceBlocks[k][1] == i)
  222.     colorXY = nxtPieceBlocks[k][2];
  223.   if (colorXY != 0){
  224.    glBegin(GL_POLYGON);
  225.    glColor3f(colorsBlock[colorXY].r,colorsBlock[colorXY].g,colorsBlock[colorXY].b);
  226.    glVertex2f(xf - BLOCKSIZE / 2 + OFFSET / 2, yf - BLOCKSIZE / 2 + OFFSET / 2);
  227.    glVertex2f(xf + BLOCKSIZE / 2 - OFFSET / 2, yf - BLOCKSIZE / 2 + OFFSET / 2);
  228.    glVertex2f(xf + BLOCKSIZE / 2 - OFFSET / 2, yf + BLOCKSIZE / 2 - OFFSET / 2);
  229.    glVertex2f(xf - BLOCKSIZE / 2 + OFFSET / 2, yf + BLOCKSIZE / 2 - OFFSET / 2);
  230.    glEnd();
  231.   }
  232.  }
  233. }
  235. }
  236. void moveDownMovingParts(){
  237. bool canMoveDown (true);
  238. for (int i = 0; i < 4; i++){
  239.  canMoveDown = isMoveableDown(movingParts[i][0],movingParts[i][1]);
  240.  if (!canMoveDown){
  241.   scanRows();
  242.   break;
  243.  }
  244. }
  245. if (canMoveDown)
  246.  for (int i = 0; i < 4; i++)
  247.   movingParts[i][1]--;
  248. }
  249. bool isMoveableDown(int x, int y){
  250. if (y-1 < 0 || gameArray[y-1][x] != 0){
  251.  for (int i = 0; i < 4; i++){
  252.   gameArray[movingParts[i][1]][movingParts[i][0]] = movingParts[i][2];
  253.  }
  254.  initNewPiece();
  255.  return false;
  256. }
  257. return true;
  258. }
  259. void moveLRMovingParts(char touche){
  260. bool canMoveLR (true);
  261. for (int i = 0; i < 4; i++){
  262.  canMoveLR = isMoveableLR(touche,movingParts[i][0],movingParts[i][1]);
  263.  if (!canMoveLR)
  264.   break;
  265. }
  266. if (canMoveLR)
  267.  for (int i = 0; i < 4; i++){
  268.   if (touche == 'a')
  269.    movingParts[i][0]--;
  270.   else
  271.    movingParts[i][0]++;
  272.  }
  273. }
  274. bool isMoveableLR(char touche, int x, int y){
  275. if (touche == 'a'){
  276.  if (x-1 < 0  || gameArray[y][x-1] != 0)
  277.   return false;
  278. }
  279. else {
  280.  if (x+1 > COLS-1  || gameArray[y][x+1] != 0)
  281.   return false;
  282. }
  283. return true;
  284. }
  285. void rotateMovingParts(){
  286. int indxPivot = determinePivot();
  287. bool isOk = true;
  288. for (int i = 0; i < 4; i++){
  289.  if (i == indxPivot)
  290.   continue;
  291.  int x = movingParts[indxPivot][0] - ( movingParts[i][1] - movingParts[indxPivot][1] );
  292.  int y = movingParts[indxPivot][1] + ( movingParts[i][0] - movingParts[indxPivot][0] );
  293.  isOk = isBlockFree(x,y);
  294.  if (!isOk)
  295.   break;
  296. }
  297. if (isOk){
  298.  for (int i = 0; i < 4; i++){
  299.   if (i == indxPivot)
  300.    continue;
  301.   int x = movingParts[indxPivot][0] - ( movingParts[i][1] - movingParts[indxPivot][1] );
  302.   int y = movingParts[indxPivot][1] + ( movingParts[i][0] - movingParts[indxPivot][0] );
  303.   movingParts[i][0] = x;
  304.   movingParts[i][1] = y;
  305.  }
  306. }
  307. }
  308. int determinePivot(){
  309. float x(0);
  310. float y(0);
  311. for (int i = 0; i < 4; i++){
  312.  x += movingParts[i][0];
  313.  y += movingParts[i][1];
  314. }
  315. x = static_cast<int> (round(x/4));
  316. y = static_cast<int> (round(y/4));
  317. for (int i = 0; i < 4; i++)
  318.  if (movingParts[i][0] == x && movingParts[i][1] == y)
  319.   return i;
  320. }
  321. bool isBlockFree(int x, int y){
  322. if (y < 0 || x < 0 || x > COLS-1 || gameArray[y][x] != 0)
  323.  return false;
  324. return true;
  325. }
  326. bool isGameOver(){
  327. bool gameOver = false;
  328. for (int i = 0; i < COLS; i++){
  329.  if (gameArray[ROWS-5][i] != 0){
  330.   gameOver = true;
  331.   break;
  332.  }
  333. }
  334. return gameOver;
  335. }
  336. GLvoid fall(int value){
  337. moveDownMovingParts();
  338. glutPostRedisplay();
  339. glutTimerFunc(speed, fall, 10);
  340. }
  341. void scanRows(){
  342. bool isComplete;
  343. int nb_removed(0);
  344. for (int i = 0; i < ROWS; i++){
  345.  isComplete = true;
  346.  for (int j = 0; j < COLS; j++)
  347.   if (gameArray[i][j] == 0){
  348.    isComplete = false;
  349.    break;
  350.   }
  351.  if (isComplete){
  352.   removeRow(i);
  353.   nb_removed++;
  354.   nxtLevel += nb_removed;
  355.   i--;
  356.   if (nxtLevel >= 10){
  357.    speed -= 100;
  358.    nxtLevel -= 10;
  359.   }
  360.  }
  361. }
  362. score += 100 * nb_removed * nb_removed;
  363. }
  364. void removeRow(int indxRow){
  365. for (int i = indxRow; i < ROWS-1; i++)
  366.  for (int j = 0; j < COLS; j++)
  367.   gameArray[i][j] = gameArray[i+1][j];
  368. }
  369. int chooseNewPiece(){
  370. srand(time(NULL));
  371. nxtPiece = rand() % 7;
  372. }
  373. bool initNewPiece(){
  374. if (isGameOver())
  375.  return false;
  376. switch (nxtPiece){
  377.  case 0 :
  378.   movingParts[0][0] = 5; movingParts[0][1] = ROWS-1; movingParts[0][2] = 4;
  379.   movingParts[1][0] = 5; movingParts[1][1] = ROWS-2; movingParts[1][2] = 4;
  380.   movingParts[2][0] = 5; movingParts[2][1] = ROWS-3; movingParts[2][2] = 4;
  381.   movingParts[3][0] = 5; movingParts[3][1] = ROWS-4; movingParts[3][2] = 4;
  382.   break;
  383.  case 1 :
  384.   movingParts[0][0] = 5; movingParts[0][1] = ROWS-1; movingParts[0][2] = 2;
  385.   movingParts[1][0] = 5; movingParts[1][1] = ROWS-2; movingParts[1][2] = 2;
  386.   movingParts[2][0] = 6; movingParts[2][1] = ROWS-1; movingParts[2][2] = 2;
  387.   movingParts[3][0] = 6; movingParts[3][1] = ROWS-2; movingParts[3][2] = 2;
  388.   break;
  389.  case 2 :
  390.   movingParts[0][0] = 5; movingParts[0][1] = ROWS-1; movingParts[0][2] = 6;
  391.   movingParts[1][0] = 5; movingParts[1][1] = ROWS-2; movingParts[1][2] = 6;
  392.   movingParts[2][0] = 6; movingParts[2][1] = ROWS-2; movingParts[2][2] = 6;
  393.   movingParts[3][0] = 6; movingParts[3][1] = ROWS-3; movingParts[3][2] = 6;
  394.   break;
  395.  case 3 :
  396.   movingParts[0][0] = 6; movingParts[0][1] = ROWS-1; movingParts[0][2] = 3;
  397.   movingParts[1][0] = 6; movingParts[1][1] = ROWS-2; movingParts[1][2] = 3;
  398.   movingParts[2][0] = 5; movingParts[2][1] = ROWS-2; movingParts[2][2] = 3;
  399.   movingParts[3][0] = 5; movingParts[3][1] = ROWS-3; movingParts[3][2] = 3;
  400.   break;
  401.  case 4 :
  402.   movingParts[0][0] = 5; movingParts[0][1] = ROWS-1; movingParts[0][2] = 7;
  403.   movingParts[1][0] = 5; movingParts[1][1] = ROWS-2; movingParts[1][2] = 7;
  404.   movingParts[2][0] = 5; movingParts[2][1] = ROWS-3; movingParts[2][2] = 7;
  405.   movingParts[3][0] = 6; movingParts[3][1] = ROWS-3; movingParts[3][2] = 7;
  406.   break;
  407.  case 5 :
  408.   movingParts[0][0] = 6; movingParts[0][1] = ROWS-1; movingParts[0][2] = 5;
  409.   movingParts[1][0] = 6; movingParts[1][1] = ROWS-2; movingParts[1][2] = 5;
  410.   movingParts[2][0] = 6; movingParts[2][1] = ROWS-3; movingParts[2][2] = 5;
  411.   movingParts[3][0] = 5; movingParts[3][1] = ROWS-3; movingParts[3][2] = 5;
  412.   break;
  413.  case 6 :
  414.   movingParts[0][0] = 5; movingParts[0][1] = ROWS-1; movingParts[0][2] = 1;
  415.   movingParts[1][0] = 5; movingParts[1][1] = ROWS-2; movingParts[1][2] = 1;
  416.   movingParts[2][0] = 5; movingParts[2][1] = ROWS-3; movingParts[2][2] = 1;
  417.   movingParts[3][0] = 6; movingParts[3][1] = ROWS-2; movingParts[3][2] = 1;
  418.   break;
  419. }
  420. chooseNewPiece();
  421. return true;
  422. }
  423. void afficheStr(const string &chaine, void* font, float x, float y){
  424. glDisable(GL_TEXTURE_2D);
  425. glDisable(GL_DEPTH_TEST);
  426. glRasterPos2f(x, y);
  427. glColor3f(1.,1.,1.);
  428. for (int i=0; i < chaine.length(); i++)
  429.  glutBitmapCharacter(font, chaine[i]);
  430. }
  431. string makeStrScore(){
  432. ostringstream oss;
  433. oss << "Score : " << score;
  434. return oss.str();
  435. }
  436. void pauseGame(){
  438. }

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed