Score gestion

tetris-graph.c

@@ -22,8 +22,6 @@ void drawSquare(int x, int y, Color color){
                 SQUARE_SIZE,
                 SQUARE_SIZE,
                 color);
-    
-    
 }
 
 void drawPiece(Piece p){
@@ -47,14 +45,40 @@ void displayScore(int score){
     DrawText(TextFormat("%4i", score), 430, 80, 20, RAYWHITE);
 }
 
-void gameInstructions(Grid grid, Piece* pList){
-    Piece piece = generePiece(pList);
+void displaySquare(Square sq, int pIndex, int pListIndex){
+    char text0[5];
+    char text1[5];
+            
+    itoa(sq->posX, text0, 10);
+    itoa(sq->posY, text1, 10);
+            
+    DrawText(text0, 20 + 80*pIndex, 20 + 80*pListIndex, 20, RAYWHITE);
+    DrawText(text1, 60 + 80*pIndex, 20 + 80*pListIndex, 20, RAYWHITE);
+}
+
+void displayPiece(Piece p, int pListIndex){
+    for(int i = 0; i < p.size; i ++){
+        displaySquare(p.squares[i], i, pListIndex);
+    }
+}
+
+void displayPieceList(Piece* pList, int size){
+    for(int i = 0; i < size; i++){
+        displayPiece(pList[i], i);
+    }
+}
 
-    drawPiece(piece);
+void displayColumn(Square* line, int index, int height){
+    for(int y = 0; y < height; y++){
+        if(line[y] != NULL){
+            DrawText("1", 500 + 30*index, 20 + 30*y, 20, RAYWHITE);
+        }
+    }
+}
 
-    while(canMove(piece, grid)){
-        movePieceVert(piece, 1);
+void displayGrid(Grid g){
+    for(int x = 0; x < g.width; x++){
+        displayColumn(g.grid[x], x, g.height);
     }
+}
 
-    addPieceToGrid(piece, grid);
-}
\ No newline at end of file

tetris-graph.h

@@ -9,13 +9,21 @@
 #define GRID_PWIDTH SQUARE_SIZE*GRID_WIDTH
 #define GRID_PHEIGHT SQUARE_SIZE*GRID_HEIGHT
 
+// Init functions
 void InitDisplay();
 void InitGame();
 
+// Draw functions
 void drawSquare(int x, int y, Color color);
 void drawPiece(Piece p);
 void drawGrid(Grid g);
 
+// Display functions
 void displayScore(int score);
 
-void gameInstructions(Grid grid, Piece* pList);
\ No newline at end of file
+// Display functions (debug only)
+void displaySquare(Square sq, int pIndex, int pListIndex);
+void displayPiece(Piece p, int pListIndex);
+void displayPieceList(Piece* pList, int size);
+void displayColumn(Square* line, int index, int height);
+void displayGrid(Grid g);
\ No newline at end of file

tetris-main.c

@@ -10,6 +10,7 @@ int main(void){
     bool isFixed = true;
 
     int score = 0;
+    int level = 1;
 
     int frameCounter = 0;
     
@@ -34,7 +35,7 @@ int main(void){
         
         // Nouvelles pièces
         if(isFixed){
-            p = generePiece(pieceList);
+            p = spawnPiece(pieceList);
             movePieceHztl(p, 3);
             isFixed = false;
         }
@@ -46,15 +47,15 @@ int main(void){
         if(IsKeyPressed(KEY_RIGHT) && canMoveHztl(grid, p, 1)){
             movePieceHztl(p, 1);
         }
-        if(IsKeyDown(KEY_DOWN) && canMoveDown(grid, p, 1)){
+        if(IsKeyDown(KEY_DOWN) && canMoveVert(grid, p, 1)){
             movePieceVert(p, 1);
         }
 
         if(IsKeyPressed(KEY_Q)){    // A en AZERTY
-            while(rotateBorderLeft(p, false)){
+            while(rotateCollideLeft(p, false)){
                 movePieceHztl(p, 1);
             }
-            while(rotateBorderRight(p, false)){
+            while(rotateCollideRight(p, false)){
                 movePieceHztl(p, -1);
             }
             while(rotateCollideGrid(grid, p, false)){
@@ -63,11 +64,12 @@ int main(void){
             
             rotatePiece(grid, p, false);
         } 
+        
         if(IsKeyPressed(KEY_W)){    // Z en AZERTY
-            while(rotateBorderLeft(p, true)){
+            while(rotateCollideLeft(p, true)){
                 movePieceHztl(p, 1);
             }
-            while(rotateBorderRight(p, true)){
+            while(rotateCollideRight(p, true)){
                 movePieceHztl(p, -1);
             }
             while(rotateCollideGrid(grid, p, true)){
@@ -76,10 +78,11 @@ int main(void){
 
             rotatePiece(grid, p, true);
         }
-
+    
+        int score_prec = score;
         // Déplacer pièce toutes les 1s
-        if(frameCounter%20 == 0){
-            if(canMove(p, grid)){
+        if(frameCounter%(60/level) == 0){
+            if(canMoveVert(grid, p, 1)){
                 movePieceVert(p, 1);
             }
             else{
@@ -91,6 +94,11 @@ int main(void){
             }
         }
 
+        // Gestion des niveaux
+        if(score_prec%10 > score%10 && level < 10){
+            level++;
+        }
+
         drawPiece(p);
         drawGrid(grid);
         displayGrid(grid);
@@ -99,6 +107,20 @@ int main(void){
         
         EndDrawing();
     }
+
+    for(int x = 0; x < grid.width; x++){
+        for(int y = 0; y < grid.height; y++){
+            free(grid.grid[x][y]);
+        }
+        free(grid.grid[x]);
+    }
+    free(grid.grid);
+
+    for(int i = 0; i < p.size; i++){
+        free(p.squares[i]);
+    }
+    free(p.squares);
+
     CloseWindow();
     
     return EXIT_SUCCESS;

tetris-struct.c

@@ -33,117 +33,28 @@ Square squareInit(){
     return sq;
 }
 
-void setSquareColor(Square sq, int colorIndex){
-    Color colorList[7] = {SKYBLUE, YELLOW, PURPLE, ORANGE, BLUE, RED, GREEN};
-
-    sq->color = colorList[colorIndex];
-}
-
-void setColor(Piece p, int colorIndex){
-    for(int i = 0; i < p.size; i++){
-        setSquareColor(p.squares[i], colorIndex);
-    }
-}
-
-bool gameOver(Grid grid){
-    return height(grid) == grid.height;
-}
-
-int height(Grid g){
-    int height = 0;
-    int height_p;
-
-    for(int i = 0; i < g.width; i++){
-        height_p = heightColumn(g.grid[i], g.height);
-
-        if(height_p > height){
-            height = height_p;
-        }
-    }
-    return height;
-}
-
-int heightColumn(Square* column, int size){
-    int height = size;
-
-    while(height > 0 && column[size-height] == NULL){
-        height--;
-    }
-    return height;
-}
-
-bool canMove(Piece piece, Grid grid){
-
-    for(int i = 0; i < piece.size; i++){
-        if(!canMoveSquare(piece.squares[i], grid)){
-            return false;
-        }
-    }
-    return true;
-}
-
-bool canMoveSquare(Square sq, Grid g){
-    int x = sq->posX;
-    int y = sq->posY;
+Square copySquare(Square sq){
+    Square newSq = squareInit();
 
-    char text3[5];
-    itoa(y, text3, 50);
-    DrawText(text3, 400, 20, 20, RED);
+    newSq->color = sq->color;
+    newSq->posX = sq->posX;
+    newSq->posY = sq->posY;
 
-    if(y < g.height-1){
-        if(y < g.height-heightColumn(g.grid[x], g.height)-1){
-            return true;
-        }
-        return false;
-    }
-    return false;
+    return newSq;
 }
 
-void rotateSquare(Square sq, Square ref, bool rotation){
-    int refX = ref->posX;
-    int refY = ref->posY;
-
-    // Keep memory
-    int posX = sq->posX;
-    int posY = sq->posY;
+void setSquareColor(Square sq, int colorIndex){
+    Color colorList[7] = {SKYBLUE, YELLOW, PURPLE, ORANGE, BLUE, RED, GREEN};
 
-    if(rotation){
-        sq->posX = refX - posY + refY;
-        sq->posY = refY + posX - refX;
-    }
-    else{
-        sq->posX = refX + posY - refY;
-        sq->posY = refY - posX + refX; 
-    }
+    sq->color = colorList[colorIndex];
 }
 
-void rotatePiece(Grid g, Piece p, bool rotation){
+void setPieceColor(Piece p, int colorIndex){
     for(int i = 0; i < p.size; i++){
-        if(i != 1){
-            rotateSquare(p.squares[i], p.squares[1], rotation);
-        }
-    }
-}
-
-void addPieceToGrid(Piece piece, Grid grid){
-    for(int i = 0; i < piece.size; i++){
-        addSquareToGrid(piece.squares[i], grid);
+        setSquareColor(p.squares[i], colorIndex);
     }
 }
 
-void addSquareToGrid(Square sq, Grid g){
-    Square newSq = copySquare(sq);
-    
-    g.grid[newSq->posX][newSq->posY] = newSq;
-}
-
-int randInt(int lower, int upper){
-    srand(time(0));
-    int num = (rand() % (upper-lower+1)) + lower;
-
-    return num;
-}
-
 Square getSquare(char* line, int index){
     Square sq = squareInit();
     int k = 0;      // Compteur de '('
@@ -174,15 +85,6 @@ Piece getPieceFromLine(char* line){
     for(int i = 0; i < p.size; i++){
         sq = getSquare(line, i);
         p.squares[i] = sq;
-        
-        char text0[5];
-        char text1[5];
-            
-        itoa(sq->posX, text0, 10);
-        itoa(sq->posY, text1, 10);
-            
-        DrawText(text0, 50, 100+50*i, 20, RAYWHITE);
-        DrawText(text1, 100, 100+50*i, 20, RAYWHITE);
     }
     return p;
 }
@@ -211,29 +113,27 @@ Piece* getPiecesData(char* fileName){
     for(int i = 0; i < numPieces; i++){
         fgets(line, 30, dataFile);
         pieceList[i] = getPieceFromLine(line);
-        setColor(pieceList[i], i);
+        setPieceColor(pieceList[i], i);
     }
     free(line);
 
     return pieceList;
 }
 
-Square copySquare(Square sq){
-    Square newSq = squareInit();
-
-    newSq->color = sq->color;
-    newSq->posX = sq->posX;
-    newSq->posY = sq->posY;
+int randInt(int lower, int upper){
+    srand(time(0));
+    int num = (rand() % (upper-lower+1)) + lower;
 
-    return newSq;
+    return num;
 }
 
-Piece generePiece(Piece* pieceList){
+Piece spawnPiece(Piece* pieceList){
     int numPiece = randInt(0, 6);
 
     Piece pieceFromList = pieceList[numPiece];
     Piece newPiece = pieceInit();
     
+    // Copy the piece from the piece list
     for(int i = 0; i < newPiece.size; i++){
         newPiece.squares[i] = copySquare(pieceFromList.squares[i]);
     }
@@ -241,27 +141,28 @@ Piece generePiece(Piece* pieceList){
     return newPiece;
 }
 
-void displaySquare(Square sq, int pIndex, int pListIndex){
-    char text0[5];
-    char text1[5];
-            
-    itoa(sq->posX, text0, 10);
-    itoa(sq->posY, text1, 10);
-            
-    DrawText(text0, 20 + 80*pIndex, 20 + 80*pListIndex, 20, RAYWHITE);
-    DrawText(text1, 60 + 80*pIndex, 20 + 80*pListIndex, 20, RAYWHITE);
-}
+bool canMoveVert(Grid g, Piece p, int moveNum){
+    for(int i = 0; i < p.size; i++){
+        int x = p.squares[i]->posX;
+        int y = p.squares[i]->posY + moveNum;
 
-void displayPiece(Piece p, int pListIndex){
-    for(int i = 0; i < p.size; i ++){
-        displaySquare(p.squares[i], i, pListIndex);
+        if(y >= g.height || g.grid[x][y] != NULL){
+            return false;
+        }
     }
+    return true;
 }
 
-void displayPieceList(Piece* pList, int size){
-    for(int i = 0; i < size; i++){
-        displayPiece(pList[i], i);
+bool canMoveHztl(Grid g, Piece p, int moveNum){
+    for(int i = 0; i < p.size; i++){
+        int x = p.squares[i]->posX + moveNum;
+        int y = p.squares[i]->posY;
+
+        if(x < 0 || x >= g.width || g.grid[x][y] != NULL){
+            return false;
+        }
     }
+    return true;
 }
 
 void moveSquareVert(Square sq, int shift){
@@ -277,29 +178,6 @@ void movePieceVert(Piece piece, int shift){
         DrawText(text3, 450, 20, 20, RED);
 }
 
-bool canMoveHztl(Grid g, Piece p, int moveNum){
-    for(int i = 0; i < p.size; i++){
-        int x = p.squares[i]->posX + moveNum;
-        int y = p.squares[i]->posY;
-
-        if(x < 0 || x >= g.width || g.grid[x][y] != NULL){
-            return false;
-        }
-    }
-    return true;
-}
-bool canMoveDown(Grid g, Piece p, int moveNum){
-    for(int i = 0; i < p.size; i++){
-        int x = p.squares[i]->posX;
-        int y = p.squares[i]->posY + moveNum;
-
-        if(y < 0 || y >= g.height || g.grid[x][y] != NULL){
-            return false;
-        }
-    }
-    return true;
-}
-
 void moveSquareHztl(Square sq, int shift){
     sq->posX += shift;
 }
@@ -310,104 +188,66 @@ void movePieceHztl(Piece p, int shift){
     }
 }
 
-int removeLinesIfCompleted(Grid grid){
-    int nbLinesRemoved = 0;
-    bool isLineCompleted;
-
-    int y = 0;
-    while(y < grid.height){
-        isLineCompleted = true;
-        for(int x = 0; x < grid.width; x++){
-            if(grid.grid[x][y] == NULL){
-                isLineCompleted = false;
-            }
-        }
+bool rotateCollideLeft(Piece p, bool rotation){
+    int refX = p.squares[1]->posX;
+    int refY = p.squares[1]->posY;
 
-        if(isLineCompleted){
-            nbLinesRemoved++;
-            int lineToRemove = y;
+    for(int i = 0; i < p.size; i++){
+        int posY = p.squares[i]->posY;
+        int newPosX;
 
-            //free
-            for(int x = 0; x < grid.width; x++){
-                free(grid.grid[x][lineToRemove]);
-            }
-            //shift
-            for(int x = 0; x < grid.width; x++){
-                for(int i = lineToRemove; i > 0; i--){
-                    grid.grid[x][i] = grid.grid[x][i-1];
-                }   
-            }
-            //initTop
-            for(int x = 0; x < grid.width; x++){
-                grid.grid[x][0] = malloc(sizeof(square_s));
-                grid.grid[x][0] = NULL;
-            }
+        if(rotation){
+            newPosX = refX - posY + refY;
         }
         else{
-            y++;
+            newPosX = refX + posY - refY;
         }
-    }
-    return nbLinesRemoved;
-}
 
-void displayColumn(Square* line, int index, int height){
-    for(int y = 0; y < height; y++){
-        if(line[y] != NULL){
-            DrawText("1", 500 + 30*index, 20 + 30*y, 20, RAYWHITE);
+        if(newPosX < 0){
+            return true;
         }
     }
+    return false;
 }
 
-void displayGrid(Grid g){
-    for(int x = 0; x < g.width; x++){
-        displayColumn(g.grid[x], x, g.height);
-    }
-}
-
-bool rotateBorderLeft(Piece p, bool rotation){
+bool rotateCollideRight(Piece p, bool rotation){
     int refX = p.squares[1]->posX;
     int refY = p.squares[1]->posY;
 
     for(int i = 0; i < p.size; i++){
         int posX = p.squares[i]->posX;
-        int posY = p.squares[i]->posY;
-        int newPosX, newPosY;
+        int newPosY;
 
         if(rotation){
-            newPosX = refX - posY + refY;
-            newPosY = refY + posX - refX;
+            newPosY = refY - posX + refX;
         }
         else{
-            newPosX = refX + posY - refY;
-            newPosY = refY - posX + refX; 
+            newPosY = refY + posX - refX;
         }
 
-        if(newPosX < 0){
+        if(newPosY < 0){
             return true;
         }
     }
     return false;
 }
 
-bool rotateBorderRight(Piece p, bool rotation){
+bool rotateCollideTop(Piece p, bool rotation){
     int refX = p.squares[1]->posX;
     int refY = p.squares[1]->posY;
 
     for(int i = 0; i < p.size; i++){
-        int posX = p.squares[i]->posX;
         int posY = p.squares[i]->posY;
-        int newPosX, newPosY;
+        int newPosX;
 
         if(rotation){
-            newPosX = refX - posY + refY;
-            newPosY = refY + posX - refX;
+            newPosX = refX + posY - refY;
         }
         else{
-            newPosX = refX + posY - refY;
-            newPosY = refY - posX + refX; 
+            newPosX = refX - posY + refY;
         }
 
-        if(newPosX >= GRID_WIDTH){
+        if(newPosX < 0){
             return true;
         }
     }
@@ -437,4 +277,109 @@ bool rotateCollideGrid(Grid g, Piece p, bool rotation){
         }
     }
     return false;
+}
+
+void rotateSquare(Square sq, Square ref, bool rotation){
+    int refX = ref->posX;
+    int refY = ref->posY;
+
+    // Keep memory
+    int posX = sq->posX;
+    int posY = sq->posY;
+
+    if(rotation){
+        sq->posX = refX - posY + refY;
+        sq->posY = refY + posX - refX;
+    }
+    else{
+        sq->posX = refX + posY - refY;
+        sq->posY = refY - posX + refX; 
+    }
+}
+
+void rotatePiece(Grid g, Piece p, bool rotation){
+    for(int i = 0; i < p.size; i++){
+        if(i != 1){
+            rotateSquare(p.squares[i], p.squares[1], rotation);
+        }
+    }
+}
+
+void addSquareToGrid(Square sq, Grid g){
+    Square newSq = copySquare(sq);
+    
+    g.grid[newSq->posX][newSq->posY] = newSq;
+}
+
+void addPieceToGrid(Piece piece, Grid grid){
+    for(int i = 0; i < piece.size; i++){
+        addSquareToGrid(piece.squares[i], grid);
+    }
+}
+
+int removeLinesIfCompleted(Grid grid){
+    int nbLinesRemoved = 0;
+    bool isLineCompleted;
+
+    int y = 0;
+    while(y < grid.height){
+        isLineCompleted = true;
+        for(int x = 0; x < grid.width; x++){
+            if(grid.grid[x][y] == NULL){
+                isLineCompleted = false;
+            }
+        }
+
+        if(isLineCompleted){
+            nbLinesRemoved++;
+            int lineToRemove = y;
+
+            //free
+            for(int x = 0; x < grid.width; x++){
+                free(grid.grid[x][lineToRemove]);
+            }
+            //shift
+            for(int x = 0; x < grid.width; x++){
+                for(int i = lineToRemove; i > 0; i--){
+                    grid.grid[x][i] = grid.grid[x][i-1];
+                }   
+            }
+            //initTop
+            for(int x = 0; x < grid.width; x++){
+                grid.grid[x][0] = malloc(sizeof(square_s));
+                grid.grid[x][0] = NULL;
+            }
+        }
+        else{
+            y++;
+        }
+    }
+    return nbLinesRemoved;
+}
+
+int heightColumn(Square* column, int size){
+    int height = size;
+
+    while(height > 0 && column[size-height] == NULL){
+        height--;
+    }
+    return height;
+}
+
+int height(Grid g){
+    int height = 0;
+    int height_p;
+
+    for(int i = 0; i < g.width; i++){
+        height_p = heightColumn(g.grid[i], g.height);
+
+        if(height_p > height){
+            height = height_p;
+        }
+    }
+    return height;
+}
+
+bool gameOver(Grid grid){
+    return height(grid) == grid.height;
 }
\ No newline at end of file

tetris-struct.h

@@ -30,48 +30,55 @@ typedef struct Piece{
     int size;
 } Piece;
 
+// Init functions
 Grid gridInit();
-Grid initSquares(Grid g);
 Piece pieceInit();
+Square squareInit();
 
+// Copy functions
 Square copySquare(Square sq);
 
-bool gameOver(Grid grid);
-int height(Grid g);
-int heightColumn(Square* column, int size);
-
-bool canMove(Piece piece, Grid grid);
-bool canMoveSquare(Square sq, Grid g);
-
-void rotateSquare(Square sq, Square ref, bool rotation);
-void rotatePiece(Grid g, Piece p, bool rotation);       // False makes a counterclockwise rotation and true makes a clockwise rotation
+// Set functions
+void setSquareColor(Square sq, int colorIndex);
+void setPieceColor(Piece p, int colorIndex);
 
-void addPieceToGrid(Piece piece, Grid grid);
-void addSquareToGrid(Square sq, Grid g);
-
-int randInt(int lower, int upper);
+// Piece generation and data reading
 Square getSquare(char* line, int index);
 Piece getPieceFromLine(char* line);
 Piece* getPiecesData(char* fileName);
-Piece generePiece(Piece* pieceList);
 
-void displaySquare(Square sq, int pIndex, int pListIndex);
-void displayPiece(Piece p, int pListIndex);
-void displayPieceList(Piece* pList, int size);
+int randInt(int lower, int upper);
+Piece spawnPiece(Piece* pieceList);
+
+// Bool verifications for moving
+bool canMoveVert(Grid g, Piece p, int moveNum);
+bool canMoveHztl(Grid g, Piece p, int moveNum);
 
-bool canMoveDown(Grid g, Piece p, int moveNum);
+// Moving functions
 void moveSquareVert(Square sq, int shift);
 void movePieceVert(Piece piece, int shift);
 
-bool canMoveHztl(Grid g, Piece p, int moveNum);
 void moveSquareHztl(Square sq, int shift);
 void movePieceHztl(Piece p, int shift);
 
-int removeLinesIfCompleted(Grid grid);
+// Bool verifications for rotating
+bool rotateCollideLeft(Piece p, bool rotation);
+bool rotateCollideRight(Piece p, bool rotation);
+bool rotateCollideTop(Piece p, bool rotation);          // To debug
+bool rotateCollideGrid(Grid g, Piece p, bool rotation);
 
-void displayColumn(Square* line, int index, int height);
-void displayGrid(Grid g);
+// Rotating functions
+void rotateSquare(Square sq, Square ref, bool rotation);
+void rotatePiece(Grid g, Piece p, bool rotation);       // False makes a counterclockwise rotation and true makes a clockwise rotation
 
-bool rotateBorderLeft(Piece p, bool rotation);
-bool rotateBorderRight(Piece p, bool rotation);
-bool rotateCollideGrid(Grid g, Piece p, bool rotation);
\ No newline at end of file
+// Grid adding functions
+void addSquareToGrid(Square sq, Grid g);
+void addPieceToGrid(Piece piece, Grid grid);
+
+// Line completed detection
+int removeLinesIfCompleted(Grid grid);      // Returns the number of lines completed
+
+// Game over detection
+int heightColumn(Square* column, int size);
+int height(Grid g);
+bool gameOver(Grid grid);
\ No newline at end of file