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

  FORUM HardWare.fr
  Programmation
  C++

  Tetris

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Tetris

n°1848836
smallmadtv
tain t'es la toi !!!
Posté le 09-02-2009 à 11:16:19  profilanswer
 

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

mood
Publicité
Posté le 09-02-2009 à 11:16:19  profilanswer
 

n°1848868
Joel F
Real men use unique_ptr
Posté le 09-02-2009 à 12:54:45  profilanswer
 

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

n°1848904
smallmadtv
tain t'es la toi !!!
Posté le 09-02-2009 à 13:39:08  profilanswer
 

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
n°1848929
Joel F
Real men use unique_ptr
Posté le 09-02-2009 à 14:00:54  profilanswer
 

bah UML quoi :E

n°1849155
youen
Posté le 09-02-2009 à 21:43:16  profilanswer
 

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).

n°1849217
tomsoft
Posté le 09-02-2009 à 23:32:54  profilanswer
 

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. }


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C++

  Tetris

 

Sujets relatifs
tétris en director[Algo] Algorithme d'un Tetris (et programmation)
mon tetris cherche les ennuisTetris en java
[topik unik regles du jeu tetris] today : répétition des mouvements[tetris] centres de rotation des pieces
!!!!!!JE CHERCHE DES SPRITES DE TETRIS OU D'UN CLONE !!!!!!!!!Help --> Besoin d'un Tetris en C++
Plus de sujets relatifs à : Tetris

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.154 secondes

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