added bones block to master mode and added invisible mode

Reviewed-on: #3
Co-authored-by: Persson-dev <sim16.prib@gmail.com>
Co-committed-by: Persson-dev <sim16.prib@gmail.com>

.github/workflows/ubuntu.yml

@@ -0,0 +1,36 @@
+name: Linux arm64
+run-name: Build And Test
+
+on: [push]
+
+
+env:
+  XMAKE_ROOT: y
+
+jobs:
+  Build:
+    runs-on: ubuntu-latest
+    steps: 
+      - name: Check out repository code
+        uses: actions/checkout@v3
+
+      - name: Prepare XMake
+        uses: xmake-io/github-action-setup-xmake@v1
+        with:
+          xmake-version: latest
+          actions-cache-folder: '.xmake-cache'
+          actions-cache-key: 'ubuntu'
+
+      - name: Install SFML
+        run: |
+          apt update
+          apt install -y libsfml-dev
+      
+      - name: XMake config
+        run: xmake f -p linux -y
+
+      - name: Build
+        run: xmake
+
+      - name: Test
+        run: xmake test

.gitignore

@@ -10,7 +10,7 @@ build/
 
 # personnal documentation
 doc/*.txt
-doc/*.violet.html
+doc/diagrams/*.violet.html
 doc/mockups/*
 
 # data files

README.md

@@ -1,28 +1,35 @@
 # jminos
 
-Modern stacker game with every polyominos from size 1 to 15, made in C++ with [SFML 3](https://www.sfml-dev.org/)!
+Modern stacker game with every polyominoes from size 1 to 15, made in C++ with [SFML 3](https://www.sfml-dev.org/)!
 
 ## Download
 
 // TODO when the game is finished //
 
-This game has been tested on and built on Windows 11 and WSL2 Ubuntu only.  
+This game has been tested on and built for Windows 11 and WSL2 Ubuntu.  
 If your OS isn't compactible with either of theses two, you can try [manually building the project](#manual-build).  
 
 ## How to play
 
+Choose which pieces you want to play with and stack them up until you either win or top out!  
+Make full lines to make them dissapear.  
+Use the different spins to kick the pieces in spot you couldn't imagine were attaignable!  
+Each gamemode has its own objective, but you can play as you wish.  
+
 You can see and change in-game keybinds in the **SETTINGS** section of the main menu!  
 All of in-menu navigation is done with the **arrow keys**, the **Enter key** and the **Escape key**. Theses are unchangeable keybinds.  
 You will find more infos about the Rotation System, the scoring system, or the different pieces type in the **INFO** section of the main menu.  
-If you want to know more details about the generation of polyominoes, [check the documentation](/doc/)!  
 
 ## Features
 
-- Every polyominoes from size 1 to 15, selectable as you wish, with customizable propotionnality for each size!
+- Every polyominoes up to pentedecaminoes!
-- Customizable keybinds!
+- 7bag with proportionnality for each polyomino size!
-- 0° rotations!
 - AutoRS as the Rotation System!
+- 0° rotations!
+- All spin!
 - IRS, IHS, infinite hold, and other leniency mechanics!
+- Customizable board size!
+- Customizable keybinds!
 - Very bland interface!! (i'm not a designer)
 
 ### Available gamemodes
@@ -31,11 +38,22 @@ If you want to know more details about the generation of polyominoes, [check the
 - MARATHON : clear 200 lines with increasing gravity!
 - ULTRA : scores as much as possible in only 2 minutes!
 - MASTER : clear 200 lines at levels higher than maximum gravity!
+- INVISIBLE : get 1000 grade while not being able to see the board!
 - ZEN : practice indefinitely in this mode with no gravity!
 
 ### Screenshots
 
-// TODO when the game is finished //
+Pentedecamino jumpscare
+![](./doc/readme/big_piece.png)
+
+Pieces select screen
+![](./doc/readme/pieces_selection.png)
+
+AutoRS demonstration
+![](./doc/readme/rotations.gif)
+
+0° spins demonstration
+![](./doc/readme/rotation_0.gif)
 
 ## Manual build
 
@@ -62,12 +80,42 @@ To switch between debug and release mode:
 ``xmake f -m release``
 
 If for some reasons you wanna run the command line version (not updated):  
+``xmake build text``  
 ``xmake run text``
 
 ### Package the project
 
 // TODO when the game is finished //
 
+## Benchmarks
+
+### One-sided n-polyominoes
+
+| n | Number | Generation | File storing | File retrieving | File size |
+| - | - | - | - | - | - |
+| 1 | 1 | 0s 0.005622ms  | 0s 0.750955ms  | 0s 0.014016ms  | 2 bytes |
+| 2 | 1 | 0s 0.005758ms  | 0s 0.181323ms  | 0s 0.012256ms  | 3 bytes |
+| 3 | 2 | 0s 0.017525ms  | 0s 0.054497ms  | 0s 0.006431ms  | 8 bytes |
+| 4 | 7 | 0s 0.050554ms  | 0s 0.067617ms  | 0s 0.010984ms  | 35 bytes |
+| 5 | 18 | 0s 0.191971ms  | 0s 0.109905ms  | 0s 0.021234ms  | 108 bytes |
+| 6 | 60 | 0s 0.651757ms  | 0s 0.327465ms  | 0s 0.04558ms  | 420 bytes |
+| 7 | 196 | 0s 3.38847ms  | 0s 1.94434ms  | 0s 0.258777ms  | 1568 bytes |
+| 8 | 704 | 0s 22.7411ms  | 0s 10.0103ms  | 0s 1.34813ms  | 6336 bytes |
+| 9 | 2500 | 0s 66.2949ms  | 0s 20.6137ms  | 0s 2.56374ms  | 25000 bytes |
+| 10 | 9189 | 0s 194.764ms  | 0s 84.5884ms  | 0s 9.64467ms  | 101079 bytes |
+| 11 | 33896 | 0s 759.182ms  | 0s 378.494ms  | 0s 44.1424ms  | 406752 bytes |
+| 12 | 126759 | 2s 709.277ms  | 1s 530.34ms  | 0s 155ms  | 1647867 bytes |
+| 13 | 476270 | 10s 668.308ms  | 7s 395.512ms  | 0s 765.601ms  | 6667780 bytes |
+| 14 | 1802312 | 45s 606.597ms  | 32s 28.7977ms  | 2s 919.653ms  | 27034680 bytes |
+| 15 | ~6M | ~5mn  | ~5mn  | ~10s  | ~100 MB |
+
+_File storing includes normalizing and sorting all polyominoes before writing them to the file._  
+If you want to know more details about the generation and storage of polyominoes, [check the documentation](/doc/)!  
+
+Run it yourself by typing:  
+``xmake build benchmark``  
+``xmake run benchmark``
+
 ## Credits
 
 Library used: [SFML 3](https://www.sfml-dev.org/).  

src/Core/Game.cpp

@@ -366,6 +366,10 @@ bool Game::areBlocksBones() const {
     return this->parameters.getBoneBlocks();
 }
 
+bool Game::isBoardInvisible() const {
+    return this->parameters.getInvisibleBoard();
+}
+
 const Board& Game::getBoard() const {
     return this->board.getBoard();
 }

src/Core/Game.h

@@ -136,6 +136,11 @@ class Game {
          */
         bool areBlocksBones() const;
 
+        /**
+         * @return If the board is currently invisible
+         */
+        bool isBoardInvisible() const;
+
         /**
          * @return The board
          */

src/Core/GameParameters.cpp

@@ -24,6 +24,8 @@ void GameParameters::reset() {
         case MARATHON : {this->level = 1; break;}
         // goes from level 20 to 39
         case MASTER : {this->level = 20; break;}
+        // goes from level 1 to 19
+        case INVISIBLE : {this->level = 1; break;}
         // no gravity
         case ZEN : {this->level = 0; break;}
         default : this->level = 1;
@@ -34,7 +36,7 @@ void GameParameters::reset() {
 
 void GameParameters::lockedPiece(const LineClear& lineClear) {
     switch (this->gamemode) {
-        // modes where level increases
+        // modes where level increases with lines
         case MARATHON :
         case MASTER : {
                 int previousLines = this->clearedLines;
@@ -51,9 +53,23 @@ void GameParameters::lockedPiece(const LineClear& lineClear) {
         default : this->clearedLines += lineClear.lines;
     }
 
+    int previousGrade = this->grade;
     if (!((lineClear.lines == 0) && ((this->grade % 100) == 99))) {
         this->grade += (1 + lineClear.lines);
     }
+
+    switch (this->gamemode) {
+        // modes where level increases with grade
+        case INVISIBLE : {
+            if (previousGrade / 100 < this->grade / 100) {
+                this->level += 2;
+                this->updateStats();
+            }
+            break;
+        }
+        // other modes
+        default : break;
+    }
 }
 
 bool GameParameters::hasWon(int framesPassed) const {
@@ -66,6 +82,8 @@ bool GameParameters::hasWon(int framesPassed) const {
         case MARATHON : return this->clearedLines >= 200;
         // win once 200 lines have been cleared
         case MASTER : return this->clearedLines >= 200;
+        // win once 1000 grade has been passed
+        case INVISIBLE : return this->grade >= 1000;
         // infinite mode
         case ZEN :
         default : return false;
@@ -84,7 +102,8 @@ void GameParameters::updateStats() {
             }
         // 3 for slow-controls gamemodes
         case MARATHON :
-        case MASTER : {
+        case MASTER :
+        case INVISIBLE : {
                 this->nextQueueLength = 3;
                 break;
             }
@@ -94,10 +113,13 @@ void GameParameters::updateStats() {
     /* BONE BLOCKS */
     switch (this->gamemode) {
         // blocks turns into bone blocks at level 30
-        case MASTER : this->boneBlocks = (this->level >= 30);
+        case MASTER : {this->boneBlocks = (this->level >= 30); break;}
         default : this->boneBlocks = false;
     }
 
+    /* INVISIBLE */
+    this->invisibleBoard = (this->gamemode == INVISIBLE);
+
     /* GRAVITY */
     // get gravity for an assumed 20-rows board
     static const int gravityPerLevel[] = {
@@ -152,6 +174,8 @@ void GameParameters::updateStats() {
         case MARATHON : {this->ARE = 24 - (this->level - 1); break;}
         // starts at 400ms (24f) at lvl 20 and ends at 083ms (5f) at lvl 39
         case MASTER : {this->ARE = 24 - (this->level - 20); break;}
+        // fixed at 250ms (15f)
+        case INVISIBLE : {this->ARE = 15; break;}
         // no ARE by default
         default : this->ARE = 0;
     }
@@ -228,6 +252,10 @@ bool GameParameters::getBoneBlocks() const {
     return this->boneBlocks;
 }
 
+bool GameParameters::getInvisibleBoard() const {
+    return this->invisibleBoard;
+}
+
 int GameParameters::getGravity() const {
     return this->gravity;
 }

src/Core/GameParameters.h

@@ -18,6 +18,7 @@ class GameParameters {
         int grade;           // the current amount of points
         int nextQueueLength; // the number of pieces visibles in the next queue
         bool boneBlocks;     // wheter all blocks are bone blocks
+        bool invisibleBoard; // wheter the board is invisible
         int gravity;         // the gravity at which pieces drop
         int lockDelay;       // the time before the piece lock in place
         int forcedLockDelay; // the forced time before the piece lock in place
@@ -77,10 +78,15 @@ class GameParameters {
         int getNextQueueLength() const;
 
         /**
-         * Returns wheter the blocks are currently bone blocks
+         * @return Wheter the blocks are currently bone blocks
          */
         bool getBoneBlocks() const;
 
+        /**
+         * @return Wheter the board is currently invisible
+         */
+        bool getInvisibleBoard() const;
+        
         /**
          * @return The current gravity for a 20-line high board
          */

src/Core/Gamemode.h

@@ -11,6 +11,7 @@ enum Gamemode {
     MARATHON,
     ULTRA,
     MASTER,
+    INVISIBLE,
     ZEN
 };
 
@@ -24,6 +25,7 @@ inline std::string getGamemodeName(Gamemode gamemode) {
         "MARATHON",
         "ULTRA",
         "MASTER",
+        "INVISIBLE",
         "ZEN"
     };
 
@@ -39,6 +41,7 @@ inline std::string getGamemodeGoal(Gamemode gamemode) {
         "200 lines",
         "2 minutes",
         "200 lines",
+        "1000 grade",
         "Infinite"
     };
 

src/GraphicalUI/AppMenus/GamePlayingAppMenu.cpp

@@ -105,16 +105,25 @@ void GamePlayingAppMenu::computeFrame() {
 void GamePlayingAppMenu::drawFrame() const {
     this->renderWindow->clear(sf::Color(200, 200, 200));
 
+    sf::Color bonesBlockColor(0, 0, 0);
+    sf::Color bonesBlockGhostColor(100, 100, 100);
+    bool areBlockBones = this->game.areBlocksBones();
+    bool isBoardInvisible = this->game.isBoardInvisible() && !(this->game.hasWon() || this->game.hasLost());
+
     sf::Vector2f cellSize(this->cellSizeZoom, this->cellSizeZoom);
+    float cellOutlineThickness = this->cellSizeZoom / 4;
     bool drawActivePiece = (this->game.getActivePiece() != nullptr) && (!this->game.hasLost());
 
     // board
     for (int y = this->game.getBoard().getBaseHeight() + 9; y >= 0; y--) {
         for (int x = 0; x < this->game.getBoard().getWidth(); x++) {
             Block block = this->game.getBoard().getBlock(Position{x, y});
+            if (isBoardInvisible) block = NOTHING;
 
             sf::RectangleShape cell(cellSize);
-            cell.setFillColor(this->getColorOfBlock(block, (block == NOTHING) ? 0 : -30));
+            cell.setFillColor((areBlockBones && block != NOTHING)
+                ? bonesBlockColor
+                : this->getColorOfBlock(block, (block == NOTHING) ? 0 : -30));
             cell.setPosition(this->getBoardBlockPosition(x, y));
             this->renderWindow->draw(cell);
         }
@@ -122,7 +131,10 @@ void GamePlayingAppMenu::drawFrame() const {
 
     if (drawActivePiece) {
         // ghost piece
-        sf::Color ghostColor = this->getColorOfBlock(this->game.getActivePiece()->getBlockType(), 100);
+        sf::Color ghostColor = areBlockBones
+            ? bonesBlockGhostColor
+            : this->getColorOfBlock(this->game.getActivePiece()->getBlockType(), 100);
+
         for (const Position& position : this->game.getActivePiece()->getPositions()) {
             Position cellPosition = (this->game.getGhostPiecePosition() + position);
 
@@ -133,13 +145,13 @@ void GamePlayingAppMenu::drawFrame() const {
         }
 
         // active piece outline
-        float     pieceOutlineSize = std::roundf(this->cellSizeZoom / 4);
         sf::Color pieceOultlineColor = sf::Color(255, 255 - (255 * this->game.getForcedLockDelayProgression()), 255 - (255 * this->game.getForcedLockDelayProgression()));
+
         for (const Position& position : this->game.getActivePiece()->getPositions()) {
             Position cellPosition = (this->game.getActivePiecePosition() + position);
 
             sf::RectangleShape cell(cellSize);
-            cell.setOutlineThickness(pieceOutlineSize);
+            cell.setOutlineThickness(cellOutlineThickness);
             cell.setOutlineColor(pieceOultlineColor);
             cell.setPosition(this->getBoardBlockPosition(cellPosition.x, cellPosition.y));
             this->renderWindow->draw(cell);
@@ -154,7 +166,9 @@ void GamePlayingAppMenu::drawFrame() const {
 
     if (drawActivePiece) {
         // active piece
-        sf::Color pieceColor = this->getColorOfBlock(this->game.getActivePiece()->getBlockType(), -200 * (this->game.getLockDelayProgression()));
+        sf::Color pieceColor = areBlockBones
+            ? bonesBlockColor
+            : this->getColorOfBlock(this->game.getActivePiece()->getBlockType(), -200 * (this->game.getLockDelayProgression()));
 
         for (const Position& position : this->game.getActivePiece()->getPositions()) {
             Position cellPosition = (this->game.getActivePiecePosition() + position);
@@ -173,7 +187,9 @@ void GamePlayingAppMenu::drawFrame() const {
         nextBox.position.y -= upShift;
 
         sf::Vector2f nextCellSize(this->nextCellSizeZoom, this->nextCellSizeZoom);
-        sf::Color color = this->getColorOfBlock(this->game.getNextPieces().at(i).getBlockType(), 0);
+        sf::Color pieceColor = areBlockBones
+            ? bonesBlockColor
+            : this->getColorOfBlock(this->game.getNextPieces().at(i).getBlockType(), 0);
         sf::Color boxColor = sf::Color(180, 180, 180);
 
         int lowestRank = 0;
@@ -181,7 +197,7 @@ void GamePlayingAppMenu::drawFrame() const {
             for (int x = 0; x < this->game.getNextPieces().at(i).getLength(); x++) {
                 sf::RectangleShape cell(nextCellSize);
                 if (this->game.getNextPieces().at(i).getPositions().contains(Position{x, y})) {
-                    cell.setFillColor(color);
+                    cell.setFillColor(pieceColor);
                     lowestRank = y;
                 }
                 else {
@@ -199,7 +215,9 @@ void GamePlayingAppMenu::drawFrame() const {
     // hold box
     if (this->game.getHeldPiece() != nullptr) {
         sf::Vector2f holdCellSize(this->holdCellSizeZoom, this->holdCellSizeZoom);
-        sf::Color color = this->getColorOfBlock(this->game.getHeldPiece()->getBlockType(), 0);
+        sf::Color color = areBlockBones
+            ? bonesBlockColor
+            : this->getColorOfBlock(this->game.getHeldPiece()->getBlockType(), 0);
         sf::Color boxColor = sf::Color(180, 180, 180);
         
         for (int y = 0; y < this->game.getHeldPiece()->getLength(); y++) {
@@ -212,7 +230,7 @@ void GamePlayingAppMenu::drawFrame() const {
                     cell.setFillColor(boxColor);
                 }
                 cell.setPosition(sf::Vector2f(this->holdBoxPosition.position.x + (x * this->nextCellSizeZoom),
-                                                this->holdBoxPosition.position.y + ((this->game.getHeldPiece()->getLength() - y - 1) * this->holdCellSizeZoom)));
+                                              this->holdBoxPosition.position.y + ((this->game.getHeldPiece()->getLength() - y - 1) * this->holdCellSizeZoom)));
                 this->renderWindow->draw(cell);
             }
         }

src/GraphicalUI/AppMenus/GameSettingsAppMenu.cpp

@@ -13,7 +13,7 @@
 
 GameSettingsAppMenu::GameSettingsAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow) :
     AppMenu(menuStack, settings, renderWindow),
-    playerCursor({2, 3, 2}) {
+    playerCursor({2, 3, 3}) {
 
 }
 
@@ -33,7 +33,8 @@ void GameSettingsAppMenu::computeFrame() {
         case 2 : {
             switch (this->playerCursor.getPosition().x) {
                 case 0 : {this->settings->setGamemode(MASTER); break;}
-                case 1 : {this->settings->setGamemode(ZEN); break;}
+                case 1 : {this->settings->setGamemode(INVISIBLE); break;}
+                case 2 : {this->settings->setGamemode(ZEN); break;}
             }
             break;
         }
@@ -76,7 +77,8 @@ void GameSettingsAppMenu::drawFrame() const {
     this->placeText(text, this->playerCursor, "MARATHON", 25.f, 35.f, sf::Vector2u{1, 1});
     this->placeText(text, this->playerCursor, "ULTRA", 50.f, 35.f, sf::Vector2u{2, 1});
     this->placeText(text, this->playerCursor, "MASTER", 5.f, 45.f, sf::Vector2u{0, 2});
-    this->placeText(text, this->playerCursor, "ZEN", 25.f, 45.f, sf::Vector2u{1, 2});
+    this->placeText(text, this->playerCursor, "INVISIBLE", 25.f, 45.f, sf::Vector2u{1, 2});
+    this->placeText(text, this->playerCursor, "ZEN", 50.f, 45.f, sf::Vector2u{2, 2});
     
     this->renderWindow->display();
 }

src/GraphicalUI/AppMenus/InfoAppMenu.cpp

@@ -10,12 +10,13 @@
 
 InfoAppMenu::InfoAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow) :
     AppMenu(menuStack, settings, renderWindow),
-    playerCursor({4}),
+    playerCursor({INFO_SECTIONS_COUNT}),
     sectionsName(
         "< ABOUT >",
+        "< PIECES TYPES >",
+        "< 0 DEGREES ROTATIONS >",
         "< ROTATION SYSTEM >",
-        "< SCORING >",
+        "< SCORING >"
-        "< 0 DEGREES ROTATIONS >"
     ),
     sectionsContent(
         "This game is written in C++,\n"
@@ -27,6 +28,25 @@ InfoAppMenu::InfoAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<S
         "to them in any ways.\n"
         "Current version: beta.",
 
+        "There is multiple pieces type in\n"
+        "the selection screen. Use theses\n"
+        "categories for size of at least 7.\n"
+        "Convex, Holeless and Others are\n"
+        "all mutually exclusive.\n"
+        "Others have holes inside them, and\n"
+        "Convex are presumably easier to\n"
+        "play with than Holeless.",
+
+        "This games introduces 0 degrees\n"
+        "rotations, which work by simpling\n"
+        "moving the piece down and kicking\n"
+        "it as is, allowing for new kinds\n"
+        "of kicks.\n"
+        "As a leniency mechanic, when a\n"
+        "piece spawns it will automatically\n"
+        "try a 0 degrees rotations if it\n"
+        "spawned inside a wall.",
+
         "This game uses its own\n"
         "Rotation Sytem, called AutoRS.\n"
         "The rotation center is always the\n"
@@ -46,17 +66,7 @@ InfoAppMenu::InfoAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<S
         "and doubles the score gained.\n"
         "A spin is detected when the piece is\n"
         "locked in place, a mini-spin simply\n"
-        "when the last move was a kick.",
+        "when the last move was a kick."
-
-        "This games introduces 0 degrees\n"
-        "rotations, which work by simpling\n"
-        "moving the piece down and kicking\n"
-        "it as is, allowing for new kinds\n"
-        "of kicks.\n"
-        "As a leniency mechanic, when a\n"
-        "piece spawns it will automatically\n"
-        "try a 0 degrees rotations if it\n"
-        "spawned inside a wall."
     ) {
 
 }

src/GraphicalUI/AppMenus/InfoAppMenu.h

@@ -7,12 +7,14 @@
 #include <memory>
 #include <SFML/Graphics.hpp>
 
+static const int INFO_SECTIONS_COUNT = 5;
+
 
 class InfoAppMenu : public AppMenu {
     private:
         PlayerCursor playerCursor;
-        sf::String sectionsName[4];
+        sf::String sectionsName[INFO_SECTIONS_COUNT];
-        sf::String sectionsContent[4];
+        sf::String sectionsContent[INFO_SECTIONS_COUNT];
 
     public:
         InfoAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow);

src/Pieces/PiecesFiles.cpp

@@ -25,22 +25,35 @@ bool PiecesFiles::savePieces(int polyominoSize) const {
     }
 
     Generator generator;
-    std::vector<Polyomino> nMinos = generator.generatePolyominoes(polyominoSize);
+    std::vector<Polyomino> polyominoes = generator.generatePolyominoes(polyominoSize);
+
+    return this->savePieces(polyominoSize, polyominoes);
+}
+
+bool PiecesFiles::savePieces(int polyominoSize, std::vector<Polyomino>& polyominoes) const {
+    std::string filePath;
+    if (!this->getFilePath(polyominoSize, filePath)) {
+        return false;
+    }
+    std::ofstream piecesFile(filePath, std::ios::trunc | std::ios::binary);
+    if (!piecesFile.good()) {
+        return false;
+    }
 
     // sorting the polyominoes is done after setting spawn position to ensure the order is always the same
-    for (Polyomino& nMino : nMinos) {
+    for (Polyomino& nMino : polyominoes) {
         nMino.goToSpawnPosition();
     }
-    std::sort(nMinos.begin(), nMinos.end());
+    std::sort(polyominoes.begin(), polyominoes.end());
 
-    for (const Polyomino& nMino : nMinos) {
+    for (const Polyomino& polyomino : polyominoes) {
         // write the characteristics of the piece
-        char infoByte = (nMino.isConvex() << 7) + (nMino.hasHole() << 6) + nMino.getLength();
+        char infoByte = (polyomino.isConvex() << 7) + (polyomino.hasHole() << 6) + polyomino.getLength();
         piecesFile.write(&infoByte, 1);
 
         // write the positions of the piece
         char positionByte;
-        for (Position position : nMino.getPositions()) {
+        for (const Position position : polyomino.getPositions()) {
             positionByte = (position.x << 4) + position.y;
             piecesFile.write(&positionByte, 1);
         }

src/Pieces/PiecesFiles.h

@@ -22,13 +22,18 @@ class PiecesFiles {
          */
         bool savePieces(int polyominoSize) const;
 
+        /**
+         * Generate a file containing all the pieces of the specified size, assuming they have been correctly generated
+         * @return If the file could be created
+         */
+        bool savePieces(int polyominoSize, std::vector<Polyomino>& polyominoes) const;
+
         /**
          * Replace the content of the vectors by the pieces of the specified size, if the file wasn't found the vectors stays untouched
          * @return If the file was found
          */
         bool loadPieces(int polyominoSize, std::vector<Piece>& pieces, std::vector<int>& convexPieces, std::vector<int>& holelessPieces, std::vector<int>& otherPieces) const;
     
-    private:
         /**
          * Puts the path to the piece file of the specified size in order, if the data folder wasn't found the string stays untouched
          * @return If the data folder was found

src/TextUI/main.cpp

@@ -3,45 +3,60 @@
 #include "TextApp.h"
 
 #include <chrono>
+#include <filesystem>
+#include <cmath>
+
+static const int MAXIMUM_PIECES_SIZE = 10;
+static const int BENCHMARK_PIECES_SIZE = 15;
 
 
-void testGeneratorForAllSizes(int amount);
+void testGeneratorForAllSizes(int max_size);
 void testGeneratorForOneSize(int size);
-void testGeneratorByprintingAllNminos(int n);
+void printPiecesByTypesForOneSize(int size);
-void testStoringAndRetrievingPieces(int size);
+void readStatsFromFilesForAllSizes(int max_size);
-void generateFilesForAllSizes(int amount);
+
-void generateFilesForOneSize(int size);
+void benchmarking(int min_size, int max_size);
-void loadFromFilesForOneSize(int size);
-void readStatsFromFilesForAllSizes(int amount);
 
 
 int main(int argc, char** argv) {
     std::srand(std::time(NULL));
 
-    // dev: generate files if it hasn't been done before, UI will NOT generate the files
+    #ifdef BENCHMARK
-    //generateFilesForAllSizes(10);
+        benchmarking(1, BENCHMARK_PIECES_SIZE);
+    #else
+        // dev: generate files if it hasn't been done before, UI will NOT generate the files
+        //generateFilesForAllSizes(10);
 
-    TextApp UI;
+        PiecesFiles pf;
-    UI.run();
+        for (int i = 1; i <= MAXIMUM_PIECES_SIZE; i++) {
+            if (!std::filesystem::exists("data/pieces/" + std::to_string(i) + "minos.bin")) {
+                std::cout << "INFO: Pieces files for size " << i << " not found, generating..." << std::endl;
+                pf.savePieces(i);
+            }
+        }
+
+        TextApp UI;
+        UI.run();
+    #endif
 
     return 0;
 }
 
 
-void testGeneratorForAllSizes(int amount) {
+void testGeneratorForAllSizes(int max_size) {
     using std::chrono::high_resolution_clock;
     using std::chrono::duration_cast;
     using std::chrono::duration;
     using std::chrono::milliseconds;
     Generator generator;
 
-    for (int i = 1; i <= amount; i++) {
+    for (int i = 1; i <= max_size; i++) {
         auto t1 = high_resolution_clock::now();
         std::vector<Polyomino> n_minos = generator.generatePolyominoes(i);
         auto t2 = high_resolution_clock::now();
     
         duration<double, std::milli> ms_double = t2 - t1;
-        std::cout << "generated " << n_minos.size() << " polyominoes of size " << i << " in " << ms_double.count() << "ms" << std::endl;
+        std::cout << "Generated " << n_minos.size() << " polyominoes of size " << i << " in " << ms_double.count() << "ms" << std::endl;
     }
 }
 
@@ -63,24 +78,8 @@ void testGeneratorForOneSize(int size) {
     }
 }
 
-void testGeneratorByprintingAllNminos(int n) {
+void printPiecesByTypesForOneSize(int size) {
-    Generator generator;
-    std::vector<Polyomino> n_minos = generator.generatePolyominoes(n);
-
-    for (Polyomino& n_mino : n_minos) {
-        n_mino.goToSpawnPosition();
-    }
-    std::sort(n_minos.begin(), n_minos.end());
-
-    for (Polyomino& n_mino : n_minos) {
-        
-        std::cout << n_mino << std::endl;
-    }
-}
-
-void testStoringAndRetrievingPieces(int size) {
     PiecesFiles piecesFiles;
-    piecesFiles.savePieces(size);
 
     std::vector<Piece> pieces;
     std::vector<int> convexPieces;
@@ -104,79 +103,9 @@ void testStoringAndRetrievingPieces(int size) {
     }
 }
 
-void generateFilesForAllSizes(int amount) {
+void readStatsFromFilesForAllSizes(int max_size) {
-    using std::chrono::high_resolution_clock;
-    using std::chrono::duration_cast;
-    using std::chrono::duration;
-    using std::chrono::milliseconds;
     PiecesFiles piecesFiles;
-
+    for (int i = 1; i <= max_size; i++) {
-    for (int i = 1; i <= amount; i++) {
-        auto t1 = high_resolution_clock::now();
-        piecesFiles.savePieces(i);
-        auto t2 = high_resolution_clock::now();
-
-        duration<double, std::milli> ms_double = t2 - t1;
-        std::cout << "Generated pieces files for size " << i << " in " << ms_double.count() << "ms" << std::endl;
-    }
-
-    std::vector<Piece> pieces;
-    std::vector<int> convexPieces;
-    std::vector<int> holelessPieces;
-    std::vector<int> otherPieces;
-    for (int i = 1; i <= amount; i++) {
-        auto t1 = high_resolution_clock::now();
-        piecesFiles.loadPieces(i, pieces, convexPieces, holelessPieces, otherPieces);
-        auto t2 = high_resolution_clock::now();
-
-        duration<double, std::milli> ms_double = t2 - t1;
-        std::cout << "Read pieces from files for size " << i << " in " << ms_double.count() << "ms" << std::endl;
-    }
-}
-
-void generateFilesForOneSize(int size) {
-    using std::chrono::high_resolution_clock;
-    using std::chrono::duration_cast;
-    using std::chrono::duration;
-    using std::chrono::milliseconds;
-    PiecesFiles piecesFiles;
-
-    std::cout << "Generating " << size << "-minos files" << std::endl;
-    for (int i = 0; i < 10; i++) {
-        auto t1 = high_resolution_clock::now();
-        piecesFiles.savePieces(size);
-        auto t2 = high_resolution_clock::now();
-
-        duration<double, std::milli> ms_double = t2 - t1;
-        std::cout << ms_double.count() << "ms" << std::endl;
-    }
-}
-
-void loadFromFilesForOneSize(int size) {
-    using std::chrono::high_resolution_clock;
-    using std::chrono::duration_cast;
-    using std::chrono::duration;
-    using std::chrono::milliseconds;
-    PiecesFiles piecesFiles;
-
-    std::vector<Piece> pieces;
-    std::vector<int> convexPieces;
-    std::vector<int> holelessPieces;
-    std::vector<int> otherPieces;
-    std::cout << "Loading " << size << "-minos from files" << std::endl;
-    for (int i = 0; i < 10; i++) {
-        auto t1 = high_resolution_clock::now();
-        piecesFiles.loadPieces(size, pieces, convexPieces, holelessPieces, otherPieces);
-        auto t2 = high_resolution_clock::now();
-
-        duration<double, std::milli> ms_double = t2 - t1;
-        std::cout << ms_double.count() << "ms" << std::endl;
-    }
-}
-
-void readStatsFromFilesForAllSizes(int amount) {
-    PiecesFiles piecesFiles;
-    for (int i = 1; i <= amount; i++) {
         std::vector<Piece> pieces;
         std::vector<int> convexPieces;
         std::vector<int> holelessPieces;
@@ -189,3 +118,66 @@ void readStatsFromFilesForAllSizes(int amount) {
         std::cout << "Others " << i << "-minos : " << otherPieces.size() << std::endl;
     }
 }
+
+void benchmarking(int min_size, int max_size) {
+    using std::chrono::high_resolution_clock;
+    using std::chrono::duration_cast;
+    using std::chrono::duration;
+    using std::chrono::milliseconds;
+
+    std::cout << "| n | Number | Generation | File storing | File retrieving | File size |" << std::endl;
+    std::cout << "| - | - | - | - | - | - |" << std::endl;
+
+    Generator gen;
+    PiecesFiles pf;
+
+    for (int i = min_size; i <= max_size; i++) {
+        std::cout << "| " << i;
+
+        auto t1 = high_resolution_clock::now();
+        std::vector<Polyomino> polyominoes = gen.generatePolyominoes(i);
+        auto t2 = high_resolution_clock::now();
+        duration<double, std::milli> ms_double = t2 - t1;
+        std::cout << " | " << polyominoes.size();
+        std::flush(std::cout);
+        std::cout << " | " << (int) ms_double.count() / 1000 << "s " << std::fmod(ms_double.count(), 1000) << "ms ";
+        std::flush(std::cout);
+
+        t1 = high_resolution_clock::now();
+        pf.savePieces(i, polyominoes);
+        t2 = high_resolution_clock::now();
+        ms_double = t2 - t1;
+        std::cout << " | " << (int) ms_double.count() / 1000 << "s " << std::fmod(ms_double.count(), 1000) << "ms ";
+        std::flush(std::cout);
+
+        polyominoes.clear();
+        polyominoes.shrink_to_fit();
+
+        std::vector<Piece> pieces;
+        std::vector<int> convexPieces;
+        std::vector<int> holelessPieces;
+        std::vector<int> otherPieces;
+
+        t1 = high_resolution_clock::now();
+        pf.loadPieces(i, pieces, convexPieces, holelessPieces, otherPieces);
+        t2 = high_resolution_clock::now();
+        ms_double = t2 - t1;
+        std::cout << " | " << (int) ms_double.count() / 1000 << "s " << std::fmod(ms_double.count(), 1000) << "ms ";
+        std::flush(std::cout);
+
+        pieces.clear();
+        pieces.shrink_to_fit();
+        convexPieces.clear();
+        convexPieces.shrink_to_fit();
+        holelessPieces.clear();
+        holelessPieces.shrink_to_fit();
+        otherPieces.clear();
+        otherPieces.shrink_to_fit();
+
+        std::string filePath;
+        pf.getFilePath(i, filePath);
+        int fileSize = std::filesystem::file_size(filePath);
+        std::cout << " | " << fileSize << " bytes |" << std::endl;
+        std::flush(std::cout);
+    }
+}

xmake.lua

@@ -11,18 +11,27 @@ target("core")
     add_files("src/Pieces/*.cpp")
     add_files("src/Core/*.cpp")
 
-target("text")
-    set_kind("binary")
-    set_default(false)
-    add_files("./src/TextUI/*.cpp")
-    add_deps("core")
-    
 target("graph")
+    set_default(true)
     set_kind("binary")
     add_files("./src/GraphicalUI/**.cpp")
     add_deps("core")
     add_packages("sfml")
 
+target("text")
+    set_default(false)
+    set_kind("binary")
+    add_files("./src/TextUI/*.cpp")
+    add_deps("core")
+
+target("benchmark")
+    set_default(false)
+    set_kind("binary")
+    add_files("./src/TextUI/*.cpp")
+    add_deps("core")
+    add_defines("BENCHMARK")
+
+
 --
 -- If you want to known more usage about xmake, please see https://xmake.io
 --