revert enum class

.gitignore

@@ -11,7 +11,6 @@ build/
 # personnal documentation
 doc/*.txt
 doc/*.violet.html
-doc/mockups/*
 
 # pieces files
 data/pieces/*.bin

.vscode/c_cpp_properties.json

@@ -1,10 +1,10 @@
 {
   "configurations": [
     {
-      "name": "jminos",
+      "name": "Tetris",
       "cppStandard": "c++20",
       "compileCommands": ".vscode/compile_commands.json"
     }
   ],
   "version": 4
-}
+}

README.md

@@ -1,29 +0,0 @@
-# jminos
-
-Modern stacker game with every polyominos from size 1 to 15, made in C++ with [SFML 3](https://www.sfml-dev.org/)!
-
-## Manual build and run
-
-This project uses xmake for compiling.  
-To be able to build it, you need to [install xmake](https://xmake.io) and have a compiler with c++20 compatibility, xmake will install SFML for you.
-
-### Build the project
-
-``cd jminos``
-
-``xmake``
-
-If you need to change the toolchain (for example using gcc):  
-``xmake f --toolchain=gcc``
-
-### Run the project
-
-``xmake run``  
-Note that the program will genereate the polyomino files for you. This can be quite long so it only does it up to size 10.
-
-If for some reasons you wanna run the command line version:  
-``xmake run text``
-
-## Credits
-
-Font used: [Press Start](https://www.zone38.net/font/#pressstart).

data/fonts/pressstart/license.txt

@@ -1,17 +0,0 @@
-Thanks for downloading one of codeman38's retro video game fonts, as seen on Memepool, BoingBoing, and all around the blogosphere.
-
-So, you're wondering what the license is for these fonts? Pretty simple; it's based upon that used for Bitstream's Vera font set <http://www.gnome.org/fonts/>.
-
-Basically, here are the key points summarized, in as little legalese as possible; I hate reading license agreements as much as you probably do:
-
-With one specific exception, you have full permission to bundle these fonts in your own free or commercial projects-- and by projects, I'm referring to not just software but also electronic documents and print publications.
-
-So what's the exception? Simple: you can't re-sell these fonts in a commercial font collection. I've seen too many font CDs for sale in stores that are just a repackaging of thousands of freeware fonts found on the internet, and in my mind, that's quite a bit like highway robbery. Note that this *only* applies to products that are font collections in and of themselves; you may freely bundle these fonts with an operating system, application program, or the like.
-
-Feel free to modify these fonts and even to release the modified versions, as long as you change the original font names (to ensure consistency among people with the font installed) and as long as you give credit somewhere in the font file to codeman38 or zone38.net. I may even incorporate these changes into a later version of my fonts if you wish to send me the modifed fonts via e-mail.
-
-Also, feel free to mirror these fonts on your own site, as long as you make it reasonably clear that these fonts are not your own work. I'm not asking for much; linking to zone38.net or even just mentioning the nickname codeman38 should be enough.
-
-Well, that pretty much sums it up... so without further ado, install and enjoy these fonts from the golden age of video games.
-
-[ codeman38 | cody@zone38.net | http://www.zone38.net/ ]

doc/files_format.md

@@ -1,47 +0,0 @@
-# Files format
-
-## Pieces
-
-If you don't know what a polyomino is, check [this other file](Pieces_representation.md#what-are-polyominoes).
-
-Generating polyominoes of size n is exponential in regard to n. Because of this, we will store the pieces beforehand and load them upon launching the game.
-
-We want the pieces to be always sorted in the same order, always attributed the same block type, and always set at the same spawn position, no matter how they were generated. We also want them to be separated in 3 categories : convex, not convex but without a hole, and with a hole. Theses problematics are already resolved internally, but will be calculated before storage as to not need extra calculcations upon load (except for the block type which is trivially computed).
-
-Pieces are stored in binary files. Each file simply contains every polyomino of one size, one after the other. Since each file contains all polyominoes of the same size, we know how much stuff to read and don't need delimiters. We know we've read all pieces simply when we reach the end of file character.
-
-Each piece is stored as follows:
-- 1 byte for the characteristics of the piece: ``ABCCCCCC`` where A indicates if the piece is convex, B indicates if it has a hole, and C is the length of the piece
-- 1 byte for each position: ``XXXXYYYY`` where X is the x coordinate of the position and Y is the y coordinate of the position
-
-The current implementation only allows to generate polyominoes up to size 16, but can be upgraded by storing coordinates on 8 bits instead of 4.  
-It has been currently choosen to use pieces only up to size 15 for this game.
-
-## Config
-
-When compiling a release version, default files will be used, theses will then be impacted by the user and used for their next sessions.
-
-### Keybinds
-
-The games has 4 keyboard configs by default that never changes, and a modifiable 5th one, but theses are all stored the same.
-
-Each keybinds files has the the following format:
-
-- The number of the action (converted from an Enum), stored with 1 byte
-- The number of each binded keys (also converted from an Enum), stored with 1 byte
-- A separator characters which is 0xFF
-
-_Repeat for every avaible actions._
-
-### Settings
-
-The settings file has the following format:
-
-- The number of the chosen keybinds (from 0 to 4), stored with 1 byte
-- The window size mode, stored with 1 byte
-- The number of the last selected gamemode (converted from an Enum), stored with 1 byte
-- The last selected width of the board, stored with 1 byte
-- The last selected height of the board, stored with 1 byte
-- The uniformity mode (0 for default distribution, 1 for uniformous distribution, 2 for custom distribution), stored with 1 byte
-    - If custom distribution is set, store the proportion of each size (15x1 byte total)
-- Every selected pieces, using 1 byte for the type of selection (once again converted from an Enum) and 1 byte for the actual value

doc/game_logic.md

@@ -1,7 +1,7 @@
 # Game logic
 
 This section will detail how the player's action are interpreted into the game.  
-We will only talk about pieces and not polyominoes. In this project, pieces are an abstraction of a polyomino. Though if you want to know more the polyominoes in this project, check [this other file](Pieces_representation.md).
+We will only talk about pieces and not polyominos. In this project, pieces are an abstraction of a polyomino. Though if you want to know more the polyominos in this project, check [this other file](Pieces_representation.md).
 
 ## Order of operations
 
@@ -12,7 +12,6 @@ Each frame, the UI will translate the user's input into a series of action to ap
 - Hold
 - Move left
 - Move right
-- Rotate 0°
 - Rotate clockwise (CW)
 - Rotate 180°
 - Rotate counter-clockwise (CCW)
@@ -25,39 +24,12 @@ Then the rest of actions will be tested in the list's order.
 Finally, gravity and lock delay are applied last.  
 Moving and soft dropping can be held but hard dropping, holding and rotating needs to be released and pressed again to happen.
 
-Menu navigation is managed by the UI and uses static keybinds to prevent the user from softlocking themselves.
-
-## ARR and DAS
-
-The sidewise movement of the piece is defined by two parameters: DAS and ARR.  
-**DAS** stands for Delayed Auto Shift and **ARR** for Auto Repeat Rate.
-Theses can be changed by the player.
-The parameters will be refered to as DAS and ARR, while the in-game values will be refered to as the piece's DAS ans ARR.
-
-- Initially, both the piece DAS and piece ARR are at 0. When moving the piece in one direction,
-the piece will move one position and then wait for the player to hold that direction as long as the DAS value.  
-_So for exemple if DAS is set to 20, on the first frame piece DAS will be set to 1 and the piece will move once.
-The next movement will be delayed by 20 frames, so the piece will move again 20 frames later, on the 21th frame, or when the piece DAS = (DAS +1)._
-- Then, if the player still holds the same direction, ARR takes on.
-The piece will move every ARR frames.  
-_So in our exemple if ARR is set to 5, this means the piece will move every 5 frames after the 21th frame.
-So on the 21th frame piece DAS = 21 and piece ARR = 0.
-On the 26th frame, piece ARR = 5 so the piece moves and piece ARR is set back to 0._
-
-Now DAS can be buffered, that is if a direction is held before the piece spawn, it will have an initial DAS value corresponding to the number of frames held.  
-_So in our example where DAS = 20 and ARR = 5, if we held a direction during 30f then hold without releasing this direction, the piece will move instantly on the frame it spawns.
-Then, ARR will start counting on the next frame. So the piece will move on frames 1, 6, 11, etc._
-
-When trying to hold two directions at the same time, only the direction held last will be applied.
-So for example if you were holding left and you suddendly start holding the two directions at the same time, the piece will go right.  
-In the two directions are first pressed at the same frame, left will take priority.
-
 ## Leniency mechanics
 
-In a general sense, we try to be kind to the players. Some of the following mechanics are just standards in a lot of stacker games, while other have been added because of this game using polyominoes of high sizes and thus being way harder to play.
+In a general sense, we try to be kind to the players. Some of the following mechanics are just standards in a lot of stacker games, while other have been added because of this game using polyominos of high sizes and thus being way harder to play.
 
-When a piece touches the ground, there is a short time period before it automatically locks. This period is called _lock delay_. Lock delay is reset everytime the piece move. To not allow for infinite stalling, there is another longer period called _forced lock delay_ that does not reset when moving the piece.  
-The player has a hold box in which they can temporarly store a piece. In this game, we allow the player to swap between the held piece and the active piece as much as they want. Once again to not allow for infinite stalling, forced lock delay does not reset when holding a piece.
+When a piece touches the ground, there is a short time period before she automatically locks. This period is called _lock delay_. Lock delay is reset everytime the piece move. To not allow for infinite stalling, there is another longer period called _forced lock delay_ that does not reset when moving the piece.  
+The player as a hold box in which they can temporarly store a piece. In this game, we allow the player to swap between the held piece and the active piece as much as they want. Once again to not allow for infinite stalling, forced lock delay does not reset when holding a piece.
 
 If either holding or rotating happens during frames where no piece is in the board, they will be memorized and immediately applied upon spawning the next piece. This can sometime prevent the player from loosing when the default spawn would have lost the game. This is called IRS and IHS, for Instant Rotation/Hold System.  
 IRS and IHS will fail if they actually loose the player the game when it would have not happened otherwise. In the same sense, holding always fails if it would loose the game.
@@ -66,33 +38,30 @@ IRS and IHS will fail if they actually loose the player the game when it would h
 
 A common mechanic of stacker games is kicking. This happen when rotating a piece makes it collide with a wall. The game will try to move the piece in a few predetermined spot close to the current position until one of them allow the piece to not be in a wall again. If no positions allow for that, the rotation is simply cancelled.
 
-This concept works very well for games with up to tetrominos or pentominos, but when using polyominoes of any size we can't choose a few predetermined spots for each piece.
+This concept works very well for games with up to tetrominos or pentominos, but when using polyominos of any size we can't choose a few predetermined spots for each piece.
 
 Since this game uses polyomino of high sizes which are very unplayable, we will try to be complaisant to the player and allow as much kicking spots as possible, while trying not to make him feel like the piece is going through walls. To solve this problem, this game introduce a new Rotation System called **AutoRS**, which does not have a predetermined list of spots to fit the piece but instead adapt to its shape. Its algorithm goes as follow:
 
-1. Before rotating, mark every position containing the piece or touching the piece, we will call the set of all theses positions the ``safePositions``
+1. Before rotating, mark every cell containing the piece or touching the piece, we will call the set of all theses cells the ``safeCells``
 2. Rotate the piece, if it fit stop the algorithm
-3. Try fitting the piece, going from the center to the sides, that means we try to move the piece 1 position right, then 1 position left, then 2 position right, etc. until it fit (and then stop the algorithm), if at one point none of the squares of the pieces are in one of the ``safePositions`` we stop trying in this direction
-4. Move the piece one line down, and repeat step 3 again, until we hit a line were the first position (shifted by 0 positions horizontally) touched none of the ``safePositions``
+3. Try fitting the piece, going from the center to the sides, that means we try to move the piece 1 cell right, then 1 cell left, then 2 cell right, etc. until it fit (and then stop the algorithm), if at one point a position doesn't touch one of the ``safeCells`` we stop trying in this direction
+4. Move the piece one line down, and repeat step 3 again, until we hit a line were the first position (shifted by 0 cells horizontally) touched none of the ``safeCells``
 5. Do the same as step 4 but now we move the piece one line up every time
 6. Cancel the rotation
 
-Kicking is primarly designed for rotating, but it is also applied when a piece spawns into a wall.  
-0° rotations will first try to move the piece one position down, and if it can't try kicking the piece, only registering a kick if the piece couldn't move down.
-
 ## Detecting spins
 
-Another common mechanic of stacker games that goes alongside kicking is spinning. A spin is a special move (a move is calculated once a piece has been locked to the board) which usually happen when the last move a piece did was a kick or a rotation and the piece is locked in place or is locked in certain corners, but the rules varies a lot from game to game. 
+Another common mechanic of stacker games that goes alongside kicking is spinning. A spin is a special move (a move is calculated once a piece has been locked to the board) which usually happen when the last move a piece did was a kick or a rotation and the piece is locked in place, but the rules varies a lot from game to game. 
 
-Since we work with a great deal of different size and shapes, the rules for spin dectection have been simplified greatly:
+Since we deal with a great deal of different size and shapes, the rules for spin dectection have been simplified greatly:
 
-- A move is a _spin_ if the piece is locked in place, that is it can't be moved one position up, down, left or right without hitting a wall
+- A move is a _spin_ if the piece is locked in place, that is it can't be moved one cell up, down, left or right without hitting a wall
 - A move is a _mini spin_ if the move isn't a spin and the last action of the piece was a kick (dropping down because of gravity counts as an action)
 
 ## Score calculation
 
-- For every position soft dropped, add 1 to the score
-- For every position hard dropped, add 2 to the score
+- For every cell soft dropped, add 1 to the score
+- For every cell hard dropped, add 2 to the score
 - When clearing one line, add 100 to the score, 200 for 2 lines, 400 for 3 lines, 800 for 4 lines, 1600 for 5 lines, etc.
 - If the line clear is a spin, count the score like a normal clear of 2x more line (200 for 1-line spin, 800 for 2, 3200 for 3, etc.)
 - When performing a spin, a mini spin, or clearing 4 or more lines, B2B is activated, every subsequent line clear that is a spin, a mini spin, or clear 4 or more lines, scores twice as much

doc/pieces_representation.md

@@ -1,110 +1,108 @@
 # Pieces representation
 
-## What are polyominoes ?
+## What are polyominos ?
 
-In this game, pieces are represented as a polyomino and a block type.  
-Polyominoes are mathematical objects consisting of multiple edge-touching squares.
-There must be a path from every square to every other square, going from square to square only through the sides and not the corners.  
-Polyominoes can be classified in 3 ways:
+In this game, pieces are represented as a polyomino with a color.  
+Polyominos are mathematical objects consisting of multiple edge-touching squares.
+There must be a path from every cell to every other cell, going from square to square only through the sides and not the corners.  
+Polyominos can be classified in 3 ways:
 
-- Fixed polyominoes : only translation is allowed
-- One-sided polyominoes : only translation and rotation are allowed
+- Fixed polyominos : only translation is allowed
+- One-sided polyominos : only translation and rotation are allowed
 - Free polyomins : translation, rotation, and reflection are allowed
 
-For more detailed informations about polyominoes, check the [Wikipedia page](https://en.wikipedia.org/wiki/Polyomino).
+For more detailed informations about polyominos, check the [Wikipedia page](https://en.wikipedia.org/wiki/Polyomino).
 
-Most stacker game uses all one-sided polyominoes of size 4 (called tetrominos), which results in 7 distinct polyominoes.  
-In this game too, one-sided polyominoes will be used since we will only allow to move and rotate the pieces.  
+Most stacker game uses one-sided polyominos, which results in 7 polyominos of size 4, also known as tetrominos.
+In this game too, one-sided polyominos will be used since we will only allow to move and rotate the pieces.  
 
-Internally, polyominoes are represented as a set of positions on a 2D grid.  
-This means that 2 polyominoes of same shape but at different places will be interpreted as different polyominoes.
-To solve this, when doing equality checks, we normalize the polyominoes so that their left-most column is at x=0 and their bottom-most row at y=0.
+Internally, Polyominos are represented as a set of Cell.
+This means the cells can be in any order but can't be duplicates.  
+A cell is simply a position on a 2D grid, so a polyomino is determined by the position of its cells.
+This means however that 2 polyominos of same shape but different positions will be interpreted as different polyominos.
+To solve this, we normalize the position of the polyominos so that their left-most column is at x=0 and their bottom-most row at y=0.
 
 Even if there is only 7 one-sided 4-minos, there is already more than 9,000 one-sided 10-minos.
-Since the aim of this game is to be playable with polyominoes of any size, listing all polyominoes manually isn't viable.
-We will need a way to automatically:
+Since the aim of this game is to be playable with polyominos of any size, listing all polyominos manually isn't viable.
+We will need a way to:
 
-1. Generate all one-sided polyominoes of size n
+1. Generate all one-sided polyominos of size n
 2. Set their spawn positions and rotation centers
 
-Aditionally, for this game we will also a want a way to separate the polyominoes into multiple categories, specifically to allow removing those with holes who are harder to play with.
+Aditionally, for this game we will also a want a way to separate the polyominos into multiple categories, specifically to allow removing those with holes who are more unplayable.
 
-##  Ordering the polyominoes
+##  Ordering the polyominos
 
-For practical reasons, we want to be able to sort all polyominoes of the same size.
-But to sort objects we need a way to compare them.
-
-When a polyomino is created, an attribute named its length is computed. This is simply the max between its width and its height. Thus the polyomino can be inscribed in a box of size ``length``.  
-We will now assume that our polyominoes are always inscribed in a box of origin (0,0) and size ``length`` (which should always be the case under normal circumstances).
-
-We can now compare polyominoes using this method:
+For practical reasons, we want to be able to sort all polyominos of the same size.
+This is done very simply:
 
 - If one polyomino has an inferior length than another, it is deemed inferior
-- If two polyomino have the same length, we check all the positions of their box, from left to right, and repeating from up to bottom, for the first position where a polyomino has a square and the another doesn't, the present polyomino which has a square is deemed inferior
+- If two polyomino have the same length, we check all the cells of their square, from left to right, and repeating from up to bottom, for the first position where a polyomino has a cell that another doesn't, the polyomino with the cell is deemed inferior
 
-A nice side-effect is that, once the polyomino are ordered, it is very simple to attribute them a block type, we can simply iterate through the list while looping over the block list.
+Once the polyomino are ordered, it is very simple to attribute them a color, we can simply iterate through the list while looping over the color list.
 
-## 1. Generating polyominoes
+## 1. Generating polyominos
 
-The method used to generate polyominoes is similar to the [inductive method](https://en.wikipedia.org/wiki/Polyomino#Inductive_algorithms) described in the previously mentionned Wikipedia page.
+The method used to generate polyominos is similar to the [inductive method](https://en.wikipedia.org/wiki/Polyomino#Inductive_algorithms) described in the previously mentionned Wikipedia page.
 
 The algorithm is the following:
 
-1. Add a single square at position (0,0), and number it with 0
+1. Add a single cell at position (0,0), and number it with 0
 2. Call the generator function
     1. If we get a polyomino of the size we want:
         1. We rotate it in its 4 possible rotations and sort them
         2. If the polyomino was generated in its lowest rotation, we add it to the list, else we discard it
         3. Stop this instance of the function (the function is recursive, see step 2.3.2)
-    2. Else we number each adjacent square to the polyomino with a number higher than the last numbered square, unless:
-        1. If a square was already numbered then we don't touch it
-        2. If a square is on top of the polyomino then we don't number it
-        3. If a square is below y=0, or at exactly x=0 and y<0, then we don't number it
-    3. For each square with a higher number than the last added one:
-        1. We add this square to the polyomino
+    2. Else we number each adjacent cell to the polyomino with a number higher than the last numbered cell, unless:
+        1. If a cell was already numbered then we don't touch it
+        2. If a cell is on top of the polyomino then we don't number it
+        3. If a cell is below y=0, or at exactly x=0 and y<0, then we don't number it
+    3. For each cell with a higher number than the last added one:
+        1. We add this cell to the polyomino
         2. We call the generator function (recursive function!)
-        3. We remove this square from the polyomino
-3. Return the list of polyominoes
+        3. We remove this cell from the polyomino
+3. Return the list of polyominos
 
-The exact number of one-sided polyominoes up to size 15 (and higher, but we only generated up to size 15) is known, and this method generated exactly theses numbers, without duplicates.
+The exact number of one-sided polyominos up to size 12 (and higher, but we only generated up to size 12) is known, and this method generated exactly theses numbers, without duplicates.
 
-By marking squares and adding only ones that have a higher number than the last one everytime, we generate each fixed polyomino exactly n times. By ignoring the squares below y=0, or at exactly x=0 and y<0, we generate each fixed polyomino exactly 1 time.  
+By marking cells and adding only ones that have a higher number than the last one everytime, we generate each fixed polyomino exactly n times. By ignoring the cells below y=0, or at exactly x=0 and y<0, we generate each fixed polyomino exactly 1 time.  
 An one-sided polyomino has 4 rotations, some of which can be the same if the polyomino has symmetries. 2 rotations that are the same corresponds to 1 fixed polyomino, we will refer to theses 2 rotation as 1 "unique" rotation.  
-Because we generate every fixed polyomino exactly 1 time, that means each "unique" rotation of an one-sided polyomino is generated exactly one-time, which includes its lowest rotation. That's how we can get away with only checking the rotation of the polyomino and not comparing it to the rest of the generated polyominoes.
+Because we generate every fixed polyomino exactly 1 time, that means each "unique" rotation of an one-sided polyomino is generated exactly one-time, which includes its lowest rotation. That's how we can get away with only checking the rotation of the polyomino and not comparing it to the rest of the generated polyominos.
 
-## 2. Setting the spawn position of polyominoes
+## 2. Setting the spawn position of polyominos
 
-Since we assume the polyomino is always inscribed in a box at origin (0,0), we can use formulae close to matrix rotations to rotate the piece:
+When a polyomino is created, an attribute named its length is computed. This is simply the max between its width and its height. Thus the polyomino can be inscribed in a square of size ``length``.  
+So now we can assume the polyomino is always inscribed in a square of origin (0,0) and size ``length`` (which should always be the case under normal circumstances). This make the rotation center very easy to find as it is simply the center of this square, and rotating is as simple as rotating a matrix:
 
 - Clockwise (CW) rotation : ``x, y = y, (length - 1) - x``
 - 180° rotation : ``x, y = (length - 1) - x, (length - 1) - y``
 - Counter-clockwise (CCW) rotation : ``x, y = (length - 1) - y, x``
 
-_Note: we set the origin at the bottom-left corner instead of the up-left corner in a matrix, so the formulae aren't exactly the same._
+_Note we set the origin at the bottom-left corner instead of the up-left corner in a matrix, so the formulae aren't exactly the same._
 
-The second challenge comes in finding a normalized spawn position for pieces. To do this, we first need to find which rotation the piece needs to spawn on, and then center it in the middle of its box.  
-The very arbitrary rules used in this game for finding the spawn rotation is the following: **we want to find the side which is both the widest and the flattest**.  
+The second challenge comes in finding a normalized spawn position for pieces. To do this, we first need to find which rotation the piece needs to spawn on, and then center it in the middle of its square.  
+For the rotation, **we want to find the side which is both the widest and the flattest**.  
 **Widest** means that we prefer if the piece is oriented horizontally rather than vertically.  
-**Flattest** means we prefer the side with the most square at the bottom of the piece.  
+**Flattest** means we prefer the side with the most cell at the bottom of the piece.  
 The current algorithm for doing so is the following:
 
-1. Check if the polyomino has more lines horizontally or vertically, this will determine either 2 or 4 sides which are wider than the others, and the others will be discarded
-2. For each potential side check the number of square on the first line, if one has more than every others, then this side is choosed, else we only keep the sides that tied and repeat for the next line
-3. If we still have at least 2 sides tied, we do the same again but check the flatness of the side to the left instead, this will make the pieces overall have more squares to their left at spawn
-4. If there is still no winner, we sort the remaining sides (by simulating having them selectionned and then sorting the resulting polyominoes) and keep the lowest
+1. Check if the polyomino has more lines horizontally or vertically, this will determine either 2 or 4 sides which are widest than the others, and the others will be discarded
+2. For each potential side check the number of cell on the first line, if one has more than every others, then this side is choosed, else we only keep the sides that tied and repeat for the next line
+3. If we still have at least 2 sides tied, we do the same again but check the flatness of the side to the left instead, this will make the pieces overall have more cells to their left at spawn
+4. If there is still no winner, we sort the remaining sides (by simulating having them selectionned and then sort the resulting polyominos) and keep the lowest
 5. We rotate the piece so that the chosen side ends up at the bottom of the polyomino
-6. We center the polyomino inside its box, since we chose the widest side it will always fill the width of the square, but for the height it can be asymmetric, in that case we place it one line closer to the top than the bottom
+6. We center the polyomino inside its square, since we chose the widest side it will always fill the width of the square, but for the height it can be asymmetric, in that case we place it one line closer to the top than the bottom
 
-_Note we could actually just skip straight to step 4 because it always give the same orientation, but we want the spawn rotations to follow somewhat of a logic. Step 1 to 3 actually already works for 99% of polyominoes and they constrain step 4 too by preselecting certain sides._
+_Note we could actually just skip straight to step 4 because it always give the same orientation, but we want the spawn rotations to follow somewhat of a logic. Step 1 to 3 actually already works for 99% of polyominos and they constrain step 4 too by preselecting certain sides._
 
-## 3. Separating the polyominoes into categories
+## 3. Separating the polyominos into categories
 
-For this game, we want the polyominoes to be broken down into 3 categories:
+For this game, we want the polyominos to be broken down into 3 categories:
 
-- Convex: this is said of a polyomino where every row and column is formed of at most one continous line of squares
-- Holeless: the polyominoes which are neither convex nor have a hole
-- Others: the polyominoes who have a hole (thoses are by definition not convex)
+- Convex: this is said of a polyomino where every row and column is formed of at most one continous line of cells
+- Holeless: the polyominos which are neither convex nor have a hole
+- Others: the polyominos who have a hole (thoses are by definition not convex)
 
-To check for convexity, we simply iterate trough each row and column, and check if all the squares are contiguous.
+To check for convexity, we simply iterate trough each row and column, and check cell by cell if they are all contiguous.
 
-To check for holes, we list every empty squares starting from the exterior of the box of the polyomino, then add every adjacent empty square recursively. If the polyomino has an hole then there is at least one empty square we could not attaign, and since we know the size of the square and of the polyomino, we can compute wheter we have the right number of empty squares.
+To check for holes, we list every empty cells starting from the exterior of the square of the polyomino, then add every adjacent empty cell recursively. If the cell has an hole then there is at least one empty cell we could not attaign, and since we know the size of the square and of the polyomino, we can compute wheter we have the right number of empty cells.

doc/pieces_storage.md

@@ -0,0 +1,20 @@
+# Pieces storage
+
+## What is stored
+
+If you don't know what a polyomino is, check [this other file](Pieces_representation.md#what-are-polyominos).
+
+Generating polyominos of size n is exponential in regard to n. Because of this, we will store the pieces beforehand and load them upon launching the game.
+
+We want the pieces to be always sorted in the same order, always attributed the same color, and always set at the same spawn position, no matter how they were generated. We also want them to be separated in 3 categories : convex, not convex but wihtout a hole, and with a hole. Theses problematics are already resolved internally, but will be calculated before storage as to not need extra calculcations upon load.
+
+## How is it stored
+
+Pieces are stored in binary files. Each file simply contains every polyomino of one size, one after the other. Since each file contains all polyominos of the same size, we know how much stuff to read and don't need delimiters. We know we've read all pieces simply when we reach the end of file character.
+
+Each piece is stored as follows:
+- 1 byte for the length of the piece
+- 1 byte for the other characteristics of the piece: ``ABCCCCCC`` where A indicates if the piece is convex, B indicates if it has a hole, and C is the color number of the piece
+- 1 byte for each cell: ``XXXXYYYY`` where X is the x coordinate of the cell and Y is the y coordinate of the cell
+
+The current implementation only allows to generate polyominos up to size 16, but can be upgraded by storing coordinates on 8 bits instead of 4. It has been choosen to use pieces only up to size 15 for this game.

src/Core/Action.h

@@ -1,10 +1,8 @@
 #pragma once
 
-#include <iostream>
-
 
 /**
- * The list of in-game actions that can be taken by the player
+ * The list of actions that can be taken by the player
  */
 enum Action {
     PAUSE,
@@ -14,45 +12,7 @@ enum Action {
     HARD_DROP,
     MOVE_LEFT,
     MOVE_RIGHT,
-    ROTATE_0,
     ROTATE_CW,
     ROTATE_180,
     ROTATE_CCW
 };
-
-
-static const Action ACTION_LIST_IN_ORDER[] = { // the list of possible actions in a sorted order
-    MOVE_LEFT,
-    MOVE_RIGHT,
-    SOFT_DROP,
-    HARD_DROP,
-    ROTATE_CW,
-    ROTATE_CCW,
-    ROTATE_180,
-    ROTATE_0,
-    HOLD,
-    PAUSE,
-    RETRY
-};
-static const std::string ACTION_NAMES[] = {    // name representation for each actions
-    "Pause",
-    "Retry",
-    "Hold",
-    "Soft drop",
-    "Hard drop",
-    "Move left",
-    "Move right",
-    "Rotate 0°",
-    "Rotate CW",
-    "Rotate 180°",
-    "Rotate CCW"
-};
-
-/**
- * Stream output operator, adds the name of the action
- * @return A reference to the output stream
- */
-inline std::ostream& operator<<(std::ostream& os, const Action action) {
-    os << ACTION_NAMES[action];
-    return os;
-}

src/Core/Bag.cpp

@@ -1,55 +1,50 @@
 #include "Bag.h"
 
 #include "../Pieces/Piece.h"
-#include "PiecesList.h"
 
 #include <vector>
-#include <utility>
 #include <cstdlib>
 
 
-Bag::Bag(const std::shared_ptr<PiecesList>& piecesList) :
-    piecesList(piecesList) {
-        
-    this->currentBag = this->piecesList->getSelectedPieces();
-    this->nextBag.clear();
-
-    this->prepareNext();
-}
-
-void Bag::jumpToNextBag() {
-    if (this->currentBag.size() < this->nextBag.size()) {
-        std::swap(this->currentBag, this->nextBag);
-    }
-
-    for (const std::pair<int, int>& pieceIndex : this->nextBag) {
-        this->currentBag.push_back(pieceIndex);
+Bag::Bag(const std::vector<Piece>& pieces) : pieces(pieces) {
+    // initialize bags
+    this->currentBag.clear();
+    for (int i = 0; i < this->pieces.size(); i++) {
+        this->currentBag.push_back(i);
     }
     this->nextBag.clear();
 
+    // prepare first piece
     this->prepareNext();
 }
 
 Piece Bag::lookNext() {
-    return this->piecesList->getPiece(this->next);
+    // return the next piece
+    return this->pieces.at(this->next);
 }
 
 Piece Bag::getNext() {
-    std::pair<int, int> nextIndex = this->next;
+    // get the piece to return
+    int nextIndex = this->next;
 
+    // prepare the piece even after the next
     this->prepareNext();
 
-    return this->piecesList->getPiece(nextIndex);
+    // return the next piece
+    return this->pieces.at(nextIndex);
 }
 
 void Bag::prepareNext() {
+    // if the bag is empty switch to the next bag
     if (this->currentBag.empty()) {
         std::swap(this->currentBag, this->nextBag);
     }
 
+    // pick a random piece from the current bag
     int indexIndex = std::rand() % this->currentBag.size();
     this->next = this->currentBag.at(indexIndex);
 
+    // move the piece over to the next bag
     this->nextBag.push_back(this->next);
     this->currentBag.erase(this->currentBag.begin() + indexIndex);
 }

src/Core/Bag.h

@@ -1,11 +1,8 @@
 #pragma once
 
 #include "../Pieces/Piece.h"
-#include "PiecesList.h"
 
 #include <vector>
-#include <memory>
-#include <utility>
 
 
 /**
@@ -13,32 +10,24 @@
  */
 class Bag {
     private:
-        std::shared_ptr<PiecesList> piecesList;          // the list of loaded pieces
-        std::vector<std::pair<int, int>> selectedPieces; // the list of pieces that can be given to the player
-        std::pair<int, int> next;                        // the next piece to give
-        std::vector<std::pair<int, int>> currentBag;     // the list of pieces that are still to be taken out before starting a new bag
-        std::vector<std::pair<int, int>> nextBag;        // the list of pieces that have been taken out of the current bag and have been placed in the next
-
+        std::vector<Piece> pieces; // the pieces the bag can dispense
+        int next; // the next piece to give
+        std::vector<int> currentBag; // the list of pieces that are still to be taken out before starting a new bag
+        std::vector<int> nextBag; // the list of pieces that have been taken out of the current bag and have been placed in the next
+    
     public:
         /**
-         * Creates a new bag with the pieces currently selected in the piece list
+         * Creates a new bag of the specified list of pieces
          */
-        Bag(const std::shared_ptr<PiecesList>& piecesList);
+        Bag(const std::vector<Piece>& pieces);
 
         /**
-         * Ignores the remaining pieces in the current bag and startd fresh from a new bag
-         */
-        void jumpToNextBag();
-
-        /**
-         * Looks at what the next picked piece will be, without removing it from the bag
-         * @return The next piece
+         * Looks at what the next picked piece will be
          */
         Piece lookNext();
 
         /**
-         * Picks a new piece from the current bag, removing it from the bag
-         * @return The next piece
+         * Picks a new piece from the current bag
          */
         Piece getNext();
 

src/Core/Board.cpp

@@ -7,63 +7,59 @@
 #include <iostream>
 
 
-Board::Board(int width, int height) :
-    width(width),
-    height(height) {
-
-    this->emptyRow = std::vector<Block>(width);
+Board::Board(int width, int height) : width(width), height(height) {
+    std::vector<ColorEnum> emptyRow;
     for (int i = 0; i < width; i ++) {
-        this->emptyRow.push_back(NOTHING);
+        emptyRow.push_back(NOTHING);
     }
     
-    this->clearBoard();
+    // initialize grid
+    this->grid.clear();
+    for (int j = 0; j < height; j++) {
+        this->grid.push_back(emptyRow);
+    }
 }
 
-void Board::changeBlock(const Position& position, Block block) {
+void Board::addBlock(const Cell& position, ColorEnum block) {
+    // if the block is out of bounds we discard it
     if (position.x < 0 || position.x >= this->width || position.y < 0) return;
 
     // resize the grid if needed
     if (position.y >= this->grid.size()) {
+        std::vector<ColorEnum> emptyRow;
+        for (int i = 0; i < width; i ++) {
+            emptyRow.push_back(NOTHING);
+        }
         for (int j = this->grid.size(); j <= position.y; j++) {
-            this->grid.push_back(this->emptyRow);
+            this->grid.push_back(emptyRow);
         }
     }
     
+    // change the block in the grid
     this->grid.at(position.y).at(position.x) = block;
 }
 
-void Board::insertRow(int height, int holePosition, Block blockType) {
-    std::vector<Block> insertedRow;
-    for (int i = 0; i < this->width; i++) {
-        if (i == holePosition) {
-            insertedRow.push_back(NOTHING);
-        }
-        else {
-            insertedRow.push_back(blockType);
-        }
+int Board::clearRows() {
+    std::vector<ColorEnum> emptyRow;
+    for (int i = 0; i < width; i ++) {
+        emptyRow.push_back(NOTHING);
     }
 
-    this->grid.insert(this->grid.begin() + height, insertedRow);
-}
-
-int Board::clearRows() {
-    // check from top to bottom, so that erasing lines don't screw up the looping
+    // check from top to bottom
     int clearedLines = 0;
     for (int j = this->grid.size() - 1; j >= 0; j--) {
-        bool lineIsFull = true;
-        int i = 0;
-        while (lineIsFull && (i < width)) {
+        // check if a line has a block on every column
+        bool isFull = true;
+        for (int i = 0; i < this->width; i++) {
             if (this->grid.at(j).at(i) == NOTHING) {
-                lineIsFull = false;
+                isFull = false;
             }
-            i++;
         }
 
-        if (lineIsFull) {
+        // if it has, erase it and add a new row at the top
+        if (isFull) {
             this->grid.erase(this->grid.begin() + j);
-            if(this->grid.size() < this->height) {
-                this->grid.push_back(this->emptyRow);
-            }
+            if(this->grid.size() < height) this->grid.push_back(emptyRow);
             clearedLines++;
         }
     }
@@ -71,29 +67,23 @@ int Board::clearRows() {
     return clearedLines;
 }
 
-void Board::clearBoard() {
-    this->grid.clear();
-    for (int j = 0; j < this->height; j++) {
-        this->grid.push_back(this->emptyRow);
-    }
-}
+ColorEnum Board::getBlock(const Cell& position) const {
+    // if the block is out of bounds
+    if (position.x < 0 || position.x >= this->width || position.y < 0) 
+        return OUT_OF_BOUNDS;
 
-Block Board::getBlock(const Position& position) const {
-    if (position.x < 0 || position.x >= this->width || position.y < 0) return OUT_OF_BOUNDS;
-
-    if (position.y >= this->grid.size()) return NOTHING;
+    // if the block is higher than the current grid, since it can grow indefinitely we do as if it was there but empty
+    if (position.y >= this->grid.size()) 
+        return NOTHING;
 
+    // else get the color in the grid
     return this->grid.at(position.y).at(position.x);
 }
 
-const std::vector<std::vector<Block>>& Board::getBlocks() const {
+std::vector<std::vector<ColorEnum>> Board::getBlocks() const {
     return this->grid;
 }
 
-int Board::getWidth() const {
-    return this->width;
-}
-
 int Board::getGridHeight() const {
     return this->grid.size();
 }
@@ -102,11 +92,16 @@ int Board::getBaseHeight() const {
     return this->height;
 }
 
+int Board::getWidth() const {
+    return this->width;
+}
+
 std::ostream& operator<<(std::ostream& os, const Board& board) {
+    // print the board
     for (int y = board.grid.size() - 1; y >= 0; y--) {
         for (int x = 0; x < board.width; x++) {
-            Block block = board.grid.at(y).at(x);
-            os << getConsoleColorCode(block);
+            ColorEnum block = board.grid.at(y).at(x);
+            os << getColorCode(block);
             if (block != NOTHING) {
                 os << "*";
             }
@@ -117,7 +112,8 @@ std::ostream& operator<<(std::ostream& os, const Board& board) {
         os << std::endl;
     }
 
-    os << getResetConsoleColorCode();
+    // reset console color
+    os << getColorCode(NOTHING);
     
     return os;
 }

src/Core/Board.h

@@ -11,10 +11,9 @@
  */
 class Board {
     private:
-        std::vector<std::vector<Block>> grid; // the grid, (0,0) is downleft
-        std::vector<Block> emptyRow;          // an empty row of blocks
-        int width;                            // the width of the grid
-        int height;                           // the base height of the grid, which can extend indefinitely
+        std::vector<std::vector<ColorEnum>> grid; // the grid, (0,0) is downleft
+        int width; // the width of the grid
+        int height; // the base height of the grid, which can extends indefinitely
 
     public:
         /**
@@ -23,54 +22,42 @@ class Board {
         Board(int width, int height);
 
         /**
-         * Changes the block at the specified position, if the block is out of bounds it is simply ignored
+         * Change the color of the specified block, if the block is out of bounds it is simply ignored
          */
-        void changeBlock(const Position& position, Block block);
+        void addBlock(const Cell& position, ColorEnum block);
 
         /**
-         * Inserts a row of the specified block type (unless on the specified column that has a hole), at the specified height
-         */
-        void insertRow(int height, int holePosition, Block blockType);
-
-        /**
-         * Clears any complete row and moves down the rows on top
-         * @return The number of cleared rows
+         * Clears any complete row and moves down the rows on top, returns the number of cleared rows
          */
         int clearRows();
 
         /**
-         * Deletes any block currently on the board
+         * Returns the color of the block at the specified position
          */
-        void clearBoard();
+        ColorEnum getBlock(const Cell& position) const;
 
         /**
-         * @return The block at the specified position
+         * Returns a copy of the grid
          */
-        Block getBlock(const Position& position) const;
+        std::vector<std::vector<ColorEnum>> getBlocks() const;
 
         /**
-         * @return The grid
-         */
-        const std::vector<std::vector<Block>>& getBlocks() const;
-
-        /**
-         * @return The width of the grid
-         */
-        int getWidth() const;
-
-        /**
-         * @return The actual height of the grid
+         * Returns the actual height of the grid
          */
         int getGridHeight() const;
 
         /**
-         * @return The base height of the grid
+         * Returns the base height of the grid
          */
         int getBaseHeight() const;
         
+        /**
+         * Returns the width of the grid
+         */
+        int getWidth() const;
+
         /**
          * Stream output operator, adds a 2D grid representing the board
-         * @return A reference to the output stream
          */
         friend std::ostream& operator<<(std::ostream& os, const Board& board);
 };

src/Core/Game.cpp

@@ -4,54 +4,42 @@
 #include "GameParameters.h"
 #include "Action.h"
 
-#include <set>
-#include <algorithm>
-#include <memory>
+#include <vector>
 
-static const int SUBPX_PER_ROW = 60;          // the number of position the active piece can take "between" two rows
-static const int SOFT_DROP_SCORE = 1;         // the score gained by line soft dropped
-static const int HARD_DROP_SCORE = 2;         // the score gained by line hard dropped
+static const int SUBPX_PER_ROW = 60; // the number of position the active piece can take "between" two rows
+static const int SOFT_DROP_SCORE = 1; // the score gained by line soft dropped
+static const int HARD_DROP_SCORE = 2; // the score gained by line hard dropped
 static const int LINE_CLEAR_BASE_SCORE = 100; // the score value of clearing a single line
-static const int B2B_SCORE_MULTIPLIER = 2;    // by how much havaing B2B on multiplies the score of the line clear
-static const int B2B_MIN_LINE_NUMBER = 4;     // the minimum number of lines needed to be cleared at once to gain B2B (without a spin)
+static const int B2B_SCORE_MULTIPLIER = 2; // by how much havaing B2B on multiplies the score of the line clear
+static const int B2B_MIN_LINE_NUMBER = 4; // the minimum number of lines needed to be cleared at once to gain B2B (without a spin)
 
 
-Game::Game(Gamemode gamemode, const Player& controls, int boardWidth, int boardHeight, const std::shared_ptr<PiecesList>& piecesList) :
-    parameters(gamemode, controls),
-    board(boardWidth, boardHeight, piecesList, parameters.getNextQueueLength()) {
-        
-    this->initialize();
-}
-
-void Game::start() {
-    this->started = true;
-    this->leftARETime = 1;
-}
-
-void Game::reset() {
-    this->initialize();
-
-    this->parameters.reset();
-    this->board.reset();
-}
-
-void Game::initialize() {
+Game::Game(Gamemode gamemode, const Player& controls, int boardWidth, int boardHeight, const std::vector<Piece>& bag) : parameters(gamemode, controls), board(boardWidth, boardHeight, bag, parameters.getNextQueueLength()) {
+    // the game has not yet started
     this->started = false;
     this->lost = false;
 
+    // initialize stats
     this->score = 0;
     this->framesPassed = 0;
     this->B2BChain = 0;
 
+    // nothing happened yet
     this->heldActions.clear();
     this->initialActions.clear();
     this->heldDAS = 0;
     this->heldARR = 0;
     this->subVerticalPosition = 0;
+    this->leftARETime = 0;
     this->totalLockDelay = 0;
     this->totalForcedLockDelay = 0;
 }
 
+void Game::start() {
+    this->started = true;
+    this->lost = this->board.spawnNextPiece();
+}
+
 void Game::nextFrame(const std::set<Action>& playerActions) {
     if (this->lost || this->hasWon()) return;
 
@@ -63,72 +51,57 @@ void Game::nextFrame(const std::set<Action>& playerActions) {
 
         if (this->leftARETime == 0) {
             if (AREJustEnded) {
-                this->lost = this->board.spawnNextPiece();
-                this->resetPiece(true);
+                this->board.spawnNextPiece();
             }
 
             /* IRS and IHS */
             Rotation initialRotation = NONE
-                + ((this->initialActions.contains(ROTATE_CW)) ? CLOCKWISE : NONE)
-                + ((this->initialActions.contains(ROTATE_180)) ? DOUBLE : NONE)
-                + ((this->initialActions.contains(ROTATE_CCW)) ? COUNTERCLOCKWISE : NONE);
+                + (this->initialActions.contains(ROTATE_CW)) ? CLOCKWISE : NONE
+                + (this->initialActions.contains(ROTATE_180)) ? DOUBLE : NONE
+                + (this->initialActions.contains(ROTATE_CCW)) ? COUNTERCLOCKWISE : NONE;
 
             if (this->initialActions.contains(HOLD)) {
-                this->lost = (!this->board.hold(initialRotation));
+                if (this->board.hold(initialRotation)) {
+                    this->subVerticalPosition = 0;
+                    this->totalLockDelay = 0;
+                    this->heldARR = 0;
+                }
             }
             else {
-                if ((initialRotation != NONE) || this->initialActions.contains(ROTATE_0)) {
-                    this->lost = (!this->board.rotate(initialRotation));
+                if (initialRotation != NONE) {
+                    this->board.rotate(initialRotation);  
                 }
             }
 
-            if (this->lost) {
-                if (initialRotation == NONE) {
-                    this->lost = (!this->board.rotate(initialRotation));
-                }
-            }
-            if (this->lost) {
-                this->framesPassed++;
-                return;
-            }
-
             /* HOLD */
             if (playerActions.contains(HOLD) && (!this->heldActions.contains(HOLD))) {
                 if (this->board.hold()) {
-                    this->resetPiece(false);
+                    this->subVerticalPosition = 0;
+                    this->totalLockDelay = 0;
+                    this->heldARR = 0;
                 }
             }
 
             /* MOVE LEFT/RIGHT */
-            Position before = this->board.getActivePiecePosition();
-
-            if (this->heldDAS >= 0) {
-                if (playerActions.contains(MOVE_LEFT) && (!heldActions.contains(MOVE_LEFT))) this->movePiece(-1);
-                else if (playerActions.contains(MOVE_RIGHT)) this->movePiece(1);
-                else this->heldDAS = 0;
+            if (playerActions.contains(MOVE_LEFT)) {
+                this->movePiece(-1, (this->heldDAS >= 0));
             }
-            else if (this->heldDAS < 0) {
-                if (playerActions.contains(MOVE_RIGHT) && (!heldActions.contains(MOVE_RIGHT))) this->movePiece(1);
-                else if (playerActions.contains(MOVE_LEFT)) this->movePiece(-1);
-                else this->heldDAS = 0;
+            if (playerActions.contains(MOVE_RIGHT)) {
+                this->movePiece(1, (this->heldDAS <= 0));
             }
-
-            if (before != this->board.getActivePiecePosition()) {
-                this->totalLockDelay = 0;
+            else {
+                this->heldDAS = 0;
             }
 
             /* ROTATIONS */
-            if (playerActions.contains(ROTATE_0) && (!this->heldActions.contains(ROTATE_0))) {
-                this->rotatePiece(NONE);
-            }
             if (playerActions.contains(ROTATE_CW) && (!this->heldActions.contains(ROTATE_CW))) {
-                this->rotatePiece(CLOCKWISE);
+                this->board.rotate(CLOCKWISE);
             }
             if (playerActions.contains(ROTATE_180) && (!this->heldActions.contains(ROTATE_180))) {
-                this->rotatePiece(DOUBLE);
+                this->board.rotate(DOUBLE);
             }
             if (playerActions.contains(ROTATE_CCW) && (!this->heldActions.contains(ROTATE_CCW))) {
-                this->rotatePiece(COUNTERCLOCKWISE);
+                this->board.rotate(COUNTERCLOCKWISE);
             }
             
             /* SOFT DROP */
@@ -162,20 +135,15 @@ void Game::nextFrame(const std::set<Action>& playerActions) {
             // no need to apply gravity and lock delay if the piece was hard dropped
             else {
                 /* GRAVITY */
-                if (this->parameters.getLevel() >= 20) {
-                    while (this->board.moveDown());
-                }
-                else {
-                    // parameters.getGravity() gives the gravity for an assumed 20-line high board
-                    int appliedGravity = this->parameters.getGravity() * std::max((double) this->board.getBoard().getBaseHeight() / 20.0, 1.0);
+                // parameters.getGravity() gives the gravity for an assumed 20-line high board
+                int appliedGravity = this->parameters.getGravity() * (this->board.getBoard().getBaseHeight() / 20.0);
 
-                    this->subVerticalPosition += appliedGravity;
-                    while (this->subVerticalPosition >= SUBPX_PER_ROW) {
-                        this->subVerticalPosition -= SUBPX_PER_ROW;
-                        this->board.moveDown();
-                    }
+                this->subVerticalPosition += appliedGravity;
+                while (this->subVerticalPosition >= SUBPX_PER_ROW) {
+                    this->subVerticalPosition -= SUBPX_PER_ROW;
+                    this->board.moveDown();
                 }
-                
+
                 /* LOCK DELAY */
                 if (this->board.touchesGround()) {
                     this->totalLockDelay++;
@@ -190,78 +158,56 @@ void Game::nextFrame(const std::set<Action>& playerActions) {
                 }
             }
 
+            // remove initial actions only once they've been applied
             if (AREJustEnded) {
                 this->initialActions.clear();
             }
         }
 
         this->framesPassed++;
-        if (this->lost) {
-            return;
-        }
     }
-        
-    this->heldActions = playerActions;
-
+    
+    // update remembered actions
     if ((!this->started) || this->leftARETime > 0) {
         for (Action action : playerActions) {
             this->initialActions.insert(action);
         }
+    }
 
-        if (this->heldDAS >= 0) {
-            if (playerActions.contains(MOVE_LEFT)) this->heldDAS = -1;
-            else if (playerActions.contains(MOVE_RIGHT)) this->heldDAS++;
-            else this->heldDAS = 0;
-        }
-        else if (this->heldDAS < 0) {
-            if (playerActions.contains(MOVE_RIGHT)) this->heldDAS = +1;
-            else if (playerActions.contains(MOVE_LEFT)) this->heldDAS--;
-            else this->heldDAS = 0;
-        }
+    this->heldActions = playerActions;
+
+    if (playerActions.contains(MOVE_LEFT)) {
+        this->heldDAS = std::min(-1, this->heldDAS - 1);
+    }
+    if (playerActions.contains(MOVE_RIGHT)) {
+        this->heldDAS = std::max(1, this->heldDAS + 1);
+    }
+    else {
+        this->heldDAS = 0;
     }
 }
 
-void Game::resetPiece(bool newPiece) {
-    int appliedDAS = this->parameters.getDAS();
-
-    this->subVerticalPosition = 0;
-    this->totalLockDelay = 0;
-    if (newPiece) {
-        this->totalForcedLockDelay = 0;
-    }
-    if (abs(this->heldDAS) > appliedDAS) {
-        this->heldDAS = (this->heldDAS > 0) ? (+appliedDAS) : (-appliedDAS);
-    }
-    this->heldARR = 0;
-}
-
-void Game::movePiece(int movement) {
-    int appliedDAS = this->parameters.getDAS();
-    int appliedARR = this->parameters.getARR();
-
-    if ((this->heldDAS * movement) <= 0) {
+void Game::movePiece(int movement, bool resetDirection) {
+    if (resetDirection) {
         this->heldDAS = movement;
         this->heldARR = 0;
-        if (movement == -1) this->board.moveLeft();
-        if (movement == 1) this->board.moveRight();
     }
     else {
         this->heldDAS += movement;
     }
 
-    if (abs(this->heldDAS) > appliedDAS) {
+    if (abs(this->heldDAS) > this->parameters.getDAS()) {
+        int appliedARR = this->parameters.getARR();
+
         // ARR=0 -> instant movement
         if (appliedARR == 0) {
             if (movement == -1) while (this->board.moveLeft());
             if (movement == 1) while (this->board.moveRight());
         }
-
         // ARR>1 -> move by specified amount
         else {
-            if (abs(this->heldDAS) > appliedDAS + 1) {
-                this->heldARR++;
-            }
-            if ((this->heldARR == appliedARR) || (abs(this->heldDAS) == (appliedDAS + 1))) {
+            this->heldARR++;
+            if (this->heldARR == appliedARR) {
                 this->heldARR = 0;
                 if (movement == -1) this->board.moveLeft();
                 if (movement == 1) this->board.moveRight();
@@ -270,94 +216,84 @@ void Game::movePiece(int movement) {
     }
 }
 
-void Game::rotatePiece(Rotation rotation) {
-    Position before = this->board.getActivePiecePosition();
-
-    if (this->board.rotate(rotation)) {
-        this->totalLockDelay = 0;
-        if (before != this->board.getActivePiecePosition()) {
-            this->subVerticalPosition = 0;
-        }
-    }
-}
-
 void Game::lockPiece() {
     LineClear clear = this->board.lockPiece();
     this->parameters.clearLines(clear.lines);
 
-    bool B2BConditionsAreMet = ((clear.lines > B2B_MIN_LINE_NUMBER) || clear.isSpin || clear.isMiniSpin);
+    // update B2B and score
+    bool B2BConditions = ((clear.lines > B2B_MIN_LINE_NUMBER) || clear.isSpin || clear.isMiniSpin);
     if (clear.lines > 0) {
         /* clearing one more line is worth 2x more
            clearing with a spin is worth as much as clearing 2x more lines */
         long int clearScore = LINE_CLEAR_BASE_SCORE;
         clearScore = clearScore << (clear.lines << (clear.isSpin));
 
-        if (this->B2BChain && B2BConditionsAreMet) clearScore *= B2B_SCORE_MULTIPLIER;
+        if (this->B2BChain && B2BConditions) clearScore *= B2B_SCORE_MULTIPLIER;
         this->score += clearScore;
     }
-    this->B2BChain = B2BConditionsAreMet;
+    this->B2BChain = B2BConditions;
+    
+    // reset active piece
+    this->subVerticalPosition = 0;
+    this->totalLockDelay = 0;
+    this->totalForcedLockDelay = 0;
+    this->heldARR = 0;
 
-    if (!this->hasWon()) {
-        this->leftARETime = this->parameters.getARE();
-        if (this->leftARETime == 0) {
-            this->lost = this->board.spawnNextPiece();
-            this->resetPiece(true);
-        }
-    }   
+    // check for ARE
+    this->leftARETime = this->parameters.getARE();
+    if (this->leftARETime == 0) {
+        this->board.spawnNextPiece();
+    }
 }
 
-bool Game::hasWon() const {
+bool Game::hasWon() {
     return this->parameters.hasWon(this->framesPassed);
 }
 
-bool Game::hasLost() const {
+bool Game::hasLost() {
     return this->lost;
 }
 
-int Game::getClearedLines() const {
+int Game::getClearedLines() {
     return this->parameters.getClearedLines();
 }
 
-int Game::getLevel() const {
+int Game::getLevel() {
     return this->parameters.getLevel();
 }
 
-int Game::getFramesPassed() const {
+int Game::getFramesPassed() {
    return this->framesPassed;
 }
 
-int Game::getScore() const {
+int Game::getScore() {
     return this->score;
 }
 
-bool Game::isOnB2BChain() const {
+bool Game::isOnB2BChain() {
     return this->B2BChain;
 }
 
-bool Game::areBlocksBones() const {
+bool Game::areBlocksBones() {
     return this->parameters.getBoneBlocks();
 }
 
-Position Game::ghostPiecePosition() const {
-    return this->board.lowestPosition();
-}
-
-const Board& Game::getBoard() const {
+Board Game::getBoard() {
     return this->board.getBoard();
 }
 
-const std::shared_ptr<Piece>& Game::getActivePiece() const {
+Piece Game::getActivePiece() {
     return this->board.getActivePiece();
 }
 
-const Position& Game::getActivePiecePosition() const {
+Cell Game::getActivePiecePosition() {
     return this->board.getActivePiecePosition();
 }
 
-const std::shared_ptr<Piece>& Game::getHeldPiece() const {
+Piece Game::getHeldPiece() {
     return this->board.getHeldPiece();
 }
 
-const std::vector<Piece>& Game::getNextPieces() const {
+std::vector<Piece> Game::getNextPieces() {
     return this->board.getNextPieces();
 }

src/Core/Game.h

@@ -5,7 +5,6 @@
 #include "Action.h"
 
 #include <vector>
-#include <memory>
 
 
 /**
@@ -13,27 +12,27 @@
  */
 class Game {
     private:
-        GameParameters parameters;       // the current parameters of the game
-        GameBoard board;                 // the board in which the game is played
-        bool started;                    // wheter the game has started
-        bool lost;                       // wheter the game is lost
-        long int score;                  // the current score
-        int framesPassed;                // how many frames have passed since the start of the game
-        bool B2BChain;                   // wheter the player is currently on a B2B chain
-        std::set<Action> heldActions;    // the list of actions that were pressed last frame
+        GameParameters parameters; // the current parameters of the game
+        GameBoard board; // the board in which the game is played
+        bool started; // wheter the game has started
+        bool lost; // wheter the game is lost
+        long int score; // the current score
+        int framesPassed; // how many frames have passed since the start of the game
+        bool B2BChain; // wheter the player is currently on a B2B chain
+        std::set<Action> heldActions; // the list of actions that were pressed last frame
         std::set<Action> initialActions; // the list of actions that have been pressed while there was no active piece
-        int heldDAS;                     // the number of frames DAS has been held, positive for right or negative for left
-        int heldARR;                     // the number of frames ARR has been held
-        int subVerticalPosition;         // how far the active piece is to go down one line
-        int leftARETime;                 // how many frames are left before ARE period finishes
-        int totalLockDelay;              // how many frames has the active piece touched the ground without moving
-        int totalForcedLockDelay;        // how many frames the active piece has touched the ground since the last spawned piece
-
+        int heldDAS; // the number of frames DAS has been held, positive for right or negative for left
+        int heldARR; // the number of frames ARR has been held
+        int subVerticalPosition; // how far the active piece is to go down one line
+        int leftARETime; // how many frames are left before ARE period finishes
+        int totalLockDelay; // how many frames has the active piece touched the ground without moving
+        int totalForcedLockDelay; // how many frames the active piece has touched the ground since the last spawned piece
+    
     public:
         /**
          * Initialize the parameters and creates a new board
          */
-        Game(Gamemode gamemode, const Player& controls, int boardWidth, int boardHeight, const std::shared_ptr<PiecesList>& piecesList);
+        Game(Gamemode gamemode, const Player& controls, int boardWidth, int boardHeight, const std::vector<Piece>& bag);
 
         /**
          * Starts the game
@@ -41,113 +40,85 @@ class Game {
         void start();
 
         /**
-         * Resets the game
-         */
-        void reset();
-
-    private:
-        /**
-         * Initializes the game
-         */
-        void initialize();
-    
-    public:
-
-        /**
-         * Advances to the next frame while excecuting the actions taken by the player,
+         * Advance to the next frame while excecuting the actions taken by the player,
          * this is where the main game logic takes place
          */
         void nextFrame(const std::set<Action>& playerActions);
 
     private:
         /**
-         * Resets the piece's parameter
+         * Move the piece in the specified direction
          */
-        void resetPiece(bool newPiece);
+        void movePiece(int movement, bool resetDirection);
 
         /**
-         * Moves the piece in the specified direction (1 for right and -1 for left)
-         */
-        void movePiece(int movement);
-
-        /**
-         * Rotates the piece with the specified rotation
-         */
-        void rotatePiece(Rotation rotation);
-
-        /**
-         * Locks the piece, updates level and score and spawns the next piece if necessary
+         * Locks the piece, updates level and score and spawn the next piece if necessary
          */
         void lockPiece();
 
     public:
         /**
-         * @return If the player has won
+         * Returns wheter the player has won
          */
-        bool hasWon() const;
+        bool hasWon();
 
         /**
-         * @return If the player has lost
+         * Returns wheter the player has lost
          */
-        bool hasLost() const;
+        bool hasLost();
 
         /**
-         * @return The current level
+         * Returns the current level
          */
-        int getLevel() const;
+        int getLevel();
 
         /**
-         * @return The current number of cleared lines
+         * Returns the current number of cleared lines
          */
-        int getClearedLines() const;
+        int getClearedLines();
 
         /**
-         * @return The number of frames passed since the start of the game
+         * Returns the number of frames passed since the start of the game
          */
-        int getFramesPassed() const;
+        int getFramesPassed();
 
         /**
-         * @return The current score
+         * Returns the current score
          */
-        int getScore() const;
+        int getScore();
 
         /**
-         * @return If the player is currently on a B2B chain
+         * Returns wheter the player is currently on a B2B chain
          */
-        bool isOnB2BChain() const;
+        bool isOnB2BChain();
 
         /**
-         * @return If all blocks are currently bone blocks
+         * Returns wheter all blocks are currently bone blocks
          */
-        bool areBlocksBones() const;
+        bool areBlocksBones();
 
         /**
-         * @return The position of the ghost piece
+         * Returns a copy of the board
          */
-        Position ghostPiecePosition() const;
+        Board getBoard();
 
         /**
-         * @return The board
+         * Returns a copy of the active piece
          */
-        const Board& getBoard() const;
+        Piece getActivePiece();
 
         /**
-         * @return A pointer to the active piece, can be null
+         * Returns a copy of the active piece position
          */
-        const std::shared_ptr<Piece>& getActivePiece() const;
+        Cell getActivePiecePosition();
 
         /**
-         * @return The position of the active piece
+         * Returns a copy of the held piece
          */
-        const Position& getActivePiecePosition() const;
+        Piece getHeldPiece();
 
         /**
-         * @return A pointer to the held piece, can be null
+         * Return a copy of the next pieces queue
          */
-        const std::shared_ptr<Piece>& getHeldPiece() const;
-
-        /**
-         * @return The next piece queue, can be empty
-         */
-        const std::vector<Piece>& getNextPieces() const;
+        std::vector<Piece> getNextPieces();
 };

src/Core/GameBoard.cpp

@@ -8,38 +8,19 @@
 #include <vector>
 #include <set>
 #include <memory>
-#include <utility>
-#include <cstdlib>
 
 
-GameBoard::GameBoard(int boardWidth, int boardHeight, const std::shared_ptr<PiecesList>& piecesList, int nextQueueLength) :
-    board(boardWidth, boardHeight),
-    generator(piecesList),
-    nextQueueLength(nextQueueLength) {
-        
-    this->initialize();
-}
-
-void GameBoard::reset() {
-    this->board.clearBoard();
-    this->generator.jumpToNextBag();
-
-    this->initialize();
-}
-
-void GameBoard::initialize() {
+GameBoard::GameBoard(int boardWidth, int boardHeight, const std::vector<Piece>& bag, int nextQueueLength) : board(boardWidth, boardHeight), generator(bag), nextQueueLength(nextQueueLength) {
+    // initialize queue
     this->nextQueue.clear();
     for (int i = 0; i < nextQueueLength; i++) {
         this->nextQueue.push_back(this->generator.getNext());
     }
-
-    this->activePiece = nullptr;
-    this->heldPiece = nullptr;
-    this->isLastMoveKick = false;
 }
 
 bool GameBoard::moveLeft() {
-    if (this->activePieceInWall(Position{-1, 0})) {
+    // check if the piece can be moved one cell left
+    if (this->isActivePieceInWall(Cell{-1, 0})) {
         return false;
     }
     else {
@@ -50,7 +31,8 @@ bool GameBoard::moveLeft() {
 }
 
 bool GameBoard::moveRight() {
-    if (this->activePieceInWall(Position{1, 0})) {
+    // check if the piece can be moved one cell right
+    if (this->isActivePieceInWall(Cell{1, 0})) {
         return false;
     }
     else {
@@ -61,7 +43,8 @@ bool GameBoard::moveRight() {
 }
 
 bool GameBoard::moveDown() {
-    if (this->activePieceInWall(Position{0, -1})) {
+    // check if the piece can be moved one cell down
+    if (this->isActivePieceInWall(Cell{0, -1})) {
         return false;
     }
     else {
@@ -72,48 +55,36 @@ bool GameBoard::moveDown() {
 }
 
 bool GameBoard::rotate(Rotation rotation) {
+    // copy the original piece before rotating it
     Piece stored = *this->activePiece;
-    this->activePiece->rotate(rotation);
+    this->rotate(rotation);
 
-    // before trying to kick, check if the piece can rotate without kicking
-    if (rotation == NONE) {
-        if (this->moveDown()) {
-            this->isLastMoveKick = false;
-            return true;
-        }
-    }
-    else {
-        if (!this->activePieceInWall()) {
-            this->isLastMoveKick = false;
-            return true;
-        }
+    // check if the piece can rotate
+    if (!this->isActivePieceInWall()) {
+        this->isLastMoveKick = false;
+        return true;
     }
 
-    std::set<Position> safePositions;
-    for (Position position : stored.getPositions()) {
-        Position positionInGrid(position + this->activePiecePosition);
-        safePositions.insert(positionInGrid);
-        safePositions.insert(positionInGrid + Position{0, 1});
-        safePositions.insert(positionInGrid + Position{1, 0});
-        safePositions.insert(positionInGrid + Position{0, -1});
-        safePositions.insert(positionInGrid + Position{-1, 0});
+    // get the list of cells that touches the original piece
+    std::set<Cell> safeCells;
+    for (Cell cell : stored.getPositions()) {
+        Cell cellInGrid(cell + this->activePiecePosition);
+        safeCells.insert(cellInGrid);
+        safeCells.insert(cellInGrid + Cell{0, 1});
+        safeCells.insert(cellInGrid + Cell{1, 0});
+        safeCells.insert(cellInGrid + Cell{0, -1});
+        safeCells.insert(cellInGrid + Cell{-1, 0});
     }
 
-    // first try kicking the piece down
-    if (rotation == NONE) {
-        this->activePiecePosition.y -= 1;
-    }
-    bool suceeded = this->tryKicking(true, safePositions);
+    // try kicking the piece down
+    bool suceeded = this->tryKicking(true, safeCells);
     if (suceeded) {
         this->isLastMoveKick = true;
         return true;
     }
 
     // if it doesn't work try kicking the piece up
-    if (rotation == NONE) {
-        this->activePiecePosition.y += 1;
-    }
-    suceeded = this->tryKicking(false, safePositions);
+    suceeded = this->tryKicking(false, safeCells);
     if (suceeded) {
         this->isLastMoveKick = true;
         return true;
@@ -121,43 +92,43 @@ bool GameBoard::rotate(Rotation rotation) {
 
     // if it still doesn't work, abort the rotation
     this->activePiece = std::make_shared<Piece>(stored);
-    if (rotation == NONE) {
-        this->isLastMoveKick = false;
-    }
-    return (rotation == NONE);
+    return false;
 }
 
-bool GameBoard::tryKicking(bool testingBottom, const std::set<Position>& safePositions) {
-    // we try from the original height of the piece, moving vertically as long as the kicked piece touches the original at least once on this row
+bool GameBoard::tryKicking(bool testingBottom, const std::set<Cell>& safeCells) {
+    // we try from the original height of the piece, moving vertically as long as the kicked piece touches the original
     bool overlapsVertically = true;
     int j = 0;
     do {
         // we try from the center to the sides as long as the kicked piece touches the original
         bool overlapsLeft = true;
         bool overlapsRight = true;
-        int i = (j == 0) ? 1 : 0;
+        int i = 0;
         do {
-            // check right before left arbitrarly, we don't decide this with rotations since it would still be arbitrary with 180° rotations
+            // check right before right arbitrarly, we don't decide this with rotations since it would still be arbitrary with 180° rotations
             if (overlapsRight) {
-                Position shift{+i, j};
-                if (!this->activePieceOverlaps(safePositions, shift)) {
+                Cell shift{+i, j};
+                // the kicked position must touch the original piece
+                if (!this->activePieceOverlapsOneCell(safeCells, shift)) {
                     overlapsLeft = false;
                 }
                 else {
-                    if (!this->activePieceInWall(shift)) {
+                    // if the position is valid we place the active piece there
+                    if (!this->isActivePieceInWall(shift)) {
                         this->activePiecePosition += shift;
                         return true;
                     }
                 }
             }
 
+            // do the same on the left side
             if (overlapsLeft) {
-                Position shift{-i, j};
-                if (!this->activePieceOverlaps(safePositions, shift)) {
+                Cell shift{-i, j};
+                if (!this->activePieceOverlapsOneCell(safeCells, shift)) {
                     overlapsLeft = false;
                 }
                 else {
-                    if (!this->activePieceInWall(shift)) {
+                    if (!this->isActivePieceInWall(shift)) {
                         this->activePiecePosition += shift;
                         return true;
                     }
@@ -167,10 +138,12 @@ bool GameBoard::tryKicking(bool testingBottom, const std::set<Position>& safePos
             i++;
         } while (overlapsLeft && overlapsRight);
 
+        // test if no position touched the original piece
         if (i == 1) {
             overlapsVertically = false;
         }
 
+        // move one line up or down
         (testingBottom) ? j-- : j++;
     } while (overlapsVertically);
 
@@ -178,11 +151,15 @@ bool GameBoard::tryKicking(bool testingBottom, const std::set<Position>& safePos
 }
 
 bool GameBoard::hold(Rotation initialRotation) {
+    // swap with held piece
     std::swap(this->activePiece, this->heldPiece);
 
-    bool isFirstTimeHolding = (this->activePiece == nullptr);
-    if (isFirstTimeHolding) {
-        // try with the next piece in queue since there is no piece in the hold box yet
+    // if it's the first time holding try the next piece
+    bool isFirstTimeHolding = false;
+    if (this->activePiece == nullptr) {
+        isFirstTimeHolding = true;
+
+        // if no pieces in next queue look at what the next would be
         if (this->nextQueueLength == 0) {
             this->activePiece = std::make_shared<Piece>(this->generator.lookNext());
         }
@@ -191,145 +168,142 @@ bool GameBoard::hold(Rotation initialRotation) {
         }
     }
 
-    Piece stored = *this->activePiece;
-    Position storedPosition = this->activePiecePosition;
+    // set the spawned piece to the correct position
     this->goToSpawnPosition();
+
+    // apply initial rotation
+    Piece stored = *this->activePiece;
     this->rotate(initialRotation);
 
     // if the piece can't spawn, abort initial rotation
-    if (this->activePieceInWall()) {
+    if (this->isActivePieceInWall()) {
         this->activePiece = std::make_shared<Piece>(stored);
-        this->goToSpawnPosition();
-
+        
         // if the piece still can't spawn, abort holding
-        if (this->activePieceInWall()) {
+        if (this->isActivePieceInWall()) {
             if (isFirstTimeHolding) {
                 this->activePiece = nullptr;
             }
             std::swap(this->activePiece, this->heldPiece);
-            this->activePiecePosition = storedPosition;
             return false;
         }
     }
 
+    // if it's the first time holding, confirm we keep this piece
     if (isFirstTimeHolding) {
-        // confirm we keep the piece we tried with
-        this->nextQueue.push_back(this->generator.getNext());
-        this->nextQueue.erase(this->nextQueue.begin());
+        if (this->nextQueueLength == 0) {
+            this->generator.getNext();
+        }
+        else {
+            this->spawnNextPiece();
+        }
     }
 
-    this->heldPiece->defaultRotation();
-
+    // this piece has done nothing yet
     this->isLastMoveKick = false;
 
     return true;
 }
 
 bool GameBoard::spawnNextPiece() {
+    // add a piece to the queue
     this->nextQueue.push_back(this->generator.getNext());
+
+    // get next piece from queue
     this->activePiece = std::make_shared<Piece>(this->nextQueue.front());
     this->nextQueue.erase(this->nextQueue.begin());
 
+    // set the spawned piece to the correct position
     this->goToSpawnPosition();
+
+    // this piece has done nothing yet
     this->isLastMoveKick = false;
 
-    return this->activePieceInWall();
+    // returns wheter the piece can spawn correctly
+    return !this->isActivePieceInWall();
 }
 
-bool GameBoard::touchesGround() const {
-    return this->activePieceInWall(Position{0, -1});
-}
-
-Position GameBoard::lowestPosition() const {
-    Position shift = Position{0, -1};
-    while (!activePieceInWall(shift)) {
-        shift.y -= 1;
-    }
-    shift.y += 1;
-    return (this->activePiecePosition + shift);
+bool GameBoard::touchesGround() {
+    return this->isActivePieceInWall(Cell{0, -1});
 }
 
 LineClear GameBoard::lockPiece() {
-    bool isLockedInPlace = (this->activePieceInWall(Position{0, 1}) && this->activePieceInWall(Position{1, 0})
-        && this->activePieceInWall(Position{-1, 0}) && this->activePieceInWall(Position{0, -1}));
+    // check if the piece is locked in place
+    bool isLocked = (this->isActivePieceInWall(Cell{0, 1}) && this->isActivePieceInWall(Cell{1, 0}) &&
+        this->isActivePieceInWall(Cell{-1, 0}) && this->isActivePieceInWall(Cell{0, -1}));
 
-    for (Position position : this->activePiece->getPositions()) {
-        this->board.changeBlock(position + this->activePiecePosition, this->activePiece->getBlockType());
+    // put the piece in the board
+    for (Cell cell : this->activePiece->getPositions()) {
+        this->board.addBlock(cell + this->activePiecePosition, this->activePiece->getColor());
     }
 
-    return LineClear{this->board.clearRows(), isLockedInPlace, (!isLockedInPlace) && this->isLastMoveKick};
+    // check for lines to clear
+    return LineClear{this->board.clearRows(), isLocked, (!isLocked) && this->isLastMoveKick};
 }
 
-void GameBoard::addGarbageRows(int number) {
-    int holePosition = std::rand() % this->board.getWidth();
-
-    for (int i = 0; i < number; i++) {
-        this->board.insertRow(0, holePosition, GARBAGE);
-        if (this->touchesGround()) {
-            this->activePiecePosition.y += 1;
-        }
-    }
-}
-
-const Board& GameBoard::getBoard() const {
+Board GameBoard::getBoard() const {
     return this->board;
 }
 
-const std::shared_ptr<Piece>& GameBoard::getActivePiece() const {
-    return this->activePiece;
+Piece GameBoard::getActivePiece() const {
+    return *this->activePiece;
 }
 
-const Position& GameBoard::getActivePiecePosition() const {
+Cell GameBoard::getActivePiecePosition() const {
     return this->activePiecePosition;
 }
 
-const std::shared_ptr<Piece>& GameBoard::getHeldPiece() const {
-    return this->heldPiece;
+Piece GameBoard::getHeldPiece() const {
+    return *this->heldPiece;
 }
 
-const std::vector<Piece>& GameBoard::getNextPieces() const {
+std::vector<Piece> GameBoard::getNextPieces() const {
     return this->nextQueue;
 }
 
-bool GameBoard::activePieceInWall(const Position& shift) const {
-    for (Position position : this->activePiece->getPositions()) {
-        if (this->board.getBlock(position + this->activePiecePosition + shift) != NOTHING) return true;
+bool GameBoard::isActivePieceInWall(const Cell& shift) const {
+    // check if every cell of the active piece is in an empty spot
+    for (Cell cell : this->activePiece->getPositions()) {
+        if (this->board.getBlock(cell + this->activePiecePosition + shift) != NOTHING)
+            return true;
     }
     return false;
 }
 
-bool GameBoard::activePieceOverlaps(const std::set<Position>& safePositions, const Position& shift) const {
-    for (Position position : this->activePiece->getPositions()) {
-        if (safePositions.contains(position + this->activePiecePosition + shift)) return true;
+bool GameBoard::activePieceOverlapsOneCell(const std::set<Cell>& safeCells, const Cell& shift) const {
+    // check if one cell of the translated active piece overlaps with one cell of the given piece set
+    for (Cell cell : this->activePiece->getPositions()) {
+        if (safeCells.contains(cell + shift)) return true;
     }
     return false;
 }
 
 void GameBoard::goToSpawnPosition() {
-    int lowestPosition = this->activePiece->getLength() - 1;
-    for (Position position : this->activePiece->getPositions()) {
-        if (position.y < lowestPosition) lowestPosition = position.y;
+    // get the lowest cell of the piece
+    int lowestCell = this->activePiece->getLength() - 1;
+    for (Cell cell : this->activePiece->getPositions()) {
+        if (cell.y < lowestCell) lowestCell = cell.y;
     }
 
     // set the piece one line above the board
-    this->activePiecePosition.y = this->board.getBaseHeight() - lowestPosition;
+    this->activePiecePosition.y = this->board.getBaseHeight() - lowestCell;
 
     // center the piece horizontally, biased towards left
     this->activePiecePosition.x = (this->board.getWidth() - this->activePiece->getLength()) / 2;
-
-    this->activePiece->defaultRotation();
 }
 
 std::ostream& operator<<(std::ostream& os, const GameBoard& gameboard) {
     // print over the board (only the active piece if it is there)
     if (gameboard.activePiece != nullptr) {
-        Block pieceBlockType = gameboard.activePiece->getBlockType();
-        os << getConsoleColorCode(pieceBlockType);
 
-        // print only the position were the active piece is
+        // change to the color of the active piece
+        ColorEnum pieceColor = gameboard.activePiece->getColor();
+        os << getColorCode(pieceColor);
+
+        // print only the cell were the active piece is
         for (int y = gameboard.activePiecePosition.y + gameboard.activePiece->getLength() - 1; y >= gameboard.board.getBaseHeight(); y--) {
             for (int x = 0; x < gameboard.board.getWidth(); x++) {
-                bool hasActivePiece = gameboard.activePiece->getPositions().contains(Position{x, y} - gameboard.activePiecePosition);
+                bool hasActivePiece = gameboard.activePiece->getPositions().contains(Cell{x, y} - gameboard.activePiecePosition);
                 if (hasActivePiece) {
                     os << "*";
                 }
@@ -342,19 +316,21 @@ std::ostream& operator<<(std::ostream& os, const GameBoard& gameboard) {
     }
 
     // print the board
-    Block pieceBlockType = (gameboard.activePiece == nullptr) ? NOTHING : gameboard.activePiece->getBlockType();
+    ColorEnum pieceColor = (gameboard.activePiece == nullptr) ? NOTHING : gameboard.activePiece->getColor();
     for (int y = gameboard.board.getBaseHeight() - 1; y >= 0; y--) {
         for (int x = 0; x < gameboard.board.getWidth(); x++) {
-            bool hasActivePiece = (gameboard.activePiece == nullptr) ? false : gameboard.activePiece->getPositions().contains(Position{x, y} - gameboard.activePiecePosition);
+            bool hasActivePiece = (gameboard.activePiece == nullptr) ? false : gameboard.activePiece->getPositions().contains(Cell{x, y} - gameboard.activePiecePosition);
 
-            // the active piece takes visual priority over the board
+            // if the active piece is on this cell, print it
             if (hasActivePiece) {
-                os << getConsoleColorCode(pieceBlockType);
+                os << getColorCode(pieceColor);
                 os << "*";
             }
+
+            // else print the cell of the board
             else {
-                Block block = gameboard.board.getBlock(Position{x, y});
-                os << getConsoleColorCode(block);
+                ColorEnum block = gameboard.board.getBlock(Cell{x, y});
+                os << getColorCode(block);
                 if (block != NOTHING) {
                     os << "*";
                 }
@@ -366,7 +342,7 @@ std::ostream& operator<<(std::ostream& os, const GameBoard& gameboard) {
         os << std::endl;
     }
 
-    // print hold box
+    // print held piece
     os << "Hold:" << std::endl;
     if (!(gameboard.heldPiece == nullptr)) {
         os << *gameboard.heldPiece;
@@ -378,7 +354,8 @@ std::ostream& operator<<(std::ostream& os, const GameBoard& gameboard) {
         os << piece;
     }
 
-    os << getResetConsoleColorCode();
+    // reset console color
+    os << getColorCode(NOTHING);
     
     return os;
 }

src/Core/GameBoard.h

@@ -14,137 +14,104 @@
  */
 class GameBoard {
     private:
-        Board board;                        // the board in which pieces moves, (0, 0) is downleft
-        Bag generator;                      // the piece generator
+        Board board; // the board in which pieces moves, (0, 0) is downleft
+        Bag generator; // the piece generator
         std::shared_ptr<Piece> activePiece; // the piece currently in the board
-        Position activePiecePosition;       // the position of the piece currently in the board
-        std::shared_ptr<Piece> heldPiece;   // a piece being holded
-        int nextQueueLength;                // the number of next pieces seeable at a time
-        std::vector<Piece> nextQueue;       // the list of the next pieces to spawn in the board
-        bool isLastMoveKick;                // wheter the last action the piece did was kicking
-
+        Cell activePiecePosition; // the position of the piece currently in the board
+        std::shared_ptr<Piece> heldPiece; // a piece being holded
+        int nextQueueLength; // the number of next pieces seeable at a time
+        std::vector<Piece> nextQueue; // the list of the next pieces to spawn in the board
+        bool isLastMoveKick; // wheter the last action the piece did was kicking
+    
     public:
         /**
          * Creates a new board, generator, and next queue
          */
-        GameBoard(int boardWidth, int boardHeight, const std::shared_ptr<PiecesList>& piecesList, int nextQueueLength);
+        GameBoard(int boardWidth, int boardHeight, const std::vector<Piece>& bag, int nextQueueLength);
 
         /**
-         * Resets the board as if it was newly created
-         */
-        void reset();
-
-    private:
-        /**
-         * Initializes the board
-         */
-        void initialize();
-
-    public:
-        /**
-         * Tries moving the piece one position to the left
-         * @return If it suceeded
+         * Try moving the piece one cell to the left, and returns wheter it was sucessfull
          */
         bool moveLeft();
 
         /**
-         * Tries moving the piece one position to the right
-         * @return If it suceeded
+         * Try moving the piece one cell to the right, and returns wheter it was sucessfull
          */
         bool moveRight();
 
         /**
-         * Tries moving the piece one position down
-         * @return If it suceeded
+         * Try moving the piece one cell down, and returns wheter it was sucessfull
          */
         bool moveDown();
 
         /**
-         * Tries rotating the piece and kicking it if necessary, if it's a 0° rotation, it will forcefully try kicking
-         * @return If it suceeded
+         * Try rotating the piece and kicking it if necessary, and returns wheter it was sucessfull
          */
         bool rotate(Rotation rotation);
     
     private:
         /**
-         * Tries kicking the piece, testing position either above or below the piece's initial position
-         * @return If it suceeded
+         * Try kicking the piece, testing position either above or below the piece's initial position
          */
-        bool tryKicking(bool testingBottom, const std::set<Position>& safePositions);
+        bool tryKicking(bool testingBottom, const std::set<Cell>& safeCells);
 
     public:
         /**
-         * Tries holding the active piece or swapping it if one was already stocked, while trying to apply an initial rotation to the newly spawned piece
-         * @return If it suceeded
+         * Try holding the active piece or swapping it if one was already stocked, while trying to apply an initial rotation to the newly spawned piece,
+         * and returns wheter it was sucessfull
          */
         bool hold(Rotation initialRotation = NONE);
 
         /**
-         * Spawns the next piece from the queue
-         * @return If it spawned in a wall
+         * Spawns the next piece from the queue, and returns wheter it spawns in a wall
          */
         bool spawnNextPiece();
 
         /**
-         * Checks is the active piece as a wall directly below one of its position
-         * @return If it touches a ground
+         * Returns wheter the active piece is touching walls directly below it
          */
-        bool touchesGround() const;
+        bool touchesGround();
 
         /**
-         * Computes what the piece position would be if it were to be dropped down as much as possible
-         * @return The lowest position before hitting a wall
-         */
-        Position lowestPosition() const;
-
-        /**
-         * Locks the active piece into the board and clears lines if needed
-         * @return The resulting line clear
+         * Lock the active piece into the board and returns the resulting line clear
          */
         LineClear lockPiece();
 
         /**
-         * Adds a specified number of garbage rows to the bottom of the board, the hole position being random but the same for all of them
+         * Returns a copy of the board
          */
-        void addGarbageRows(int number);
+        Board getBoard() const;
 
         /**
-         * @return The board
+         * Returns a copy of the active piece
          */
-        const Board& getBoard() const;
+        Piece getActivePiece() const;
 
         /**
-         * @return A pointer to the active piece, can be null
+         * Returns a copy of the position of the active piece
          */
-        const std::shared_ptr<Piece>& getActivePiece() const;
+        Cell getActivePiecePosition() const;
 
         /**
-         * @return The position of the active piece
+         * Returns a copy of the held piece
          */
-        const Position& getActivePiecePosition() const;
+        Piece getHeldPiece() const;
 
         /**
-         * @return A pointer to the held piece, can be null
+         * Returns a copy of the next piece queue
          */
-        const std::shared_ptr<Piece>& getHeldPiece() const;
-
-        /**
-         * @return The next piece queue, can be empty
-         */
-        const std::vector<Piece>& getNextPieces() const;
+        std::vector<Piece> getNextPieces() const;
     
     private:
         /**
-         * Checks if one of the active piece's positions touches a wall in the board
-         * @return If the active piece spawned in a wall
+         * Returns wheter the translated active piece is in a wall
          */
-        bool activePieceInWall(const Position& shift = Position{0, 0}) const;
+        bool isActivePieceInWall(const Cell& shift = Cell{0, 0}) const;
 
         /**
-         * Check if one of the active piece's positions shifted by a specified position would overlap with a set of positions
-         * @return If the shifted active piece overlaps with one of the position
+         * Returns wheter the translated active piece overlaps with at least one of the cells
          */
-        bool activePieceOverlaps(const std::set<Position>& safePositions, const Position& shift = Position{0, 0}) const;
+        bool activePieceOverlapsOneCell(const std::set<Cell>& safeCells, const Cell& shift = Cell{0, 0}) const;
         
         /**
          * Sets the active piece to its spawn position
@@ -154,7 +121,6 @@ class GameBoard {
     public:
         /**
          * Stream output operator, adds the board, the hold box and the next queue
-         * @return A reference to the output stream
          */
         friend std::ostream& operator<<(std::ostream& os, const GameBoard& gameboard);
 };

src/Core/GameParameters.cpp

@@ -4,14 +4,8 @@
 #include "Player.h"
 
 
-GameParameters::GameParameters(Gamemode gamemode, const Player& controls) :
-    gamemode(gamemode),
-    controls(controls) {
-        
-    this->reset();
-}
-
-void GameParameters::reset() {
+GameParameters::GameParameters(Gamemode gamemode, const Player& controls) : gamemode(gamemode), controls(controls) {
+    // initialize lines and level
     this->clearedLines = 0;
     switch (this->gamemode) {
         // lowest gravity
@@ -25,14 +19,17 @@ void GameParameters::reset() {
         default : this->level = 1;
     }
 
+    // initialize stats
     this->updateStats();
 }
 
 void GameParameters::clearLines(int lineNumber) {
+    // update lines and level
     switch (this->gamemode) {
         // modes where level increases
         case MARATHON :
         case MASTER : {
+                // update cleared lines
                 int previousLines = this->clearedLines;
                 this->clearedLines += lineNumber;
 
@@ -48,7 +45,7 @@ void GameParameters::clearLines(int lineNumber) {
     }
 }
 
-bool GameParameters::hasWon(int framesPassed) const {
+bool GameParameters::hasWon(int framesPassed) {
     switch (this->gamemode) {
         // win once 40 lines have been cleared
         case SPRINT : return this->clearedLines >= 40;
@@ -88,38 +85,34 @@ void GameParameters::updateStats() {
     }
 
     /* GRAVITY */
-    // get gravity for an assumed 20-rows board
-    static const int gravityPerLevel[] = {
-        0,      // lvl0 = no gravity
-        1,      // 60f/line, 20s total
-        2,      // 30f/line, 10s total
-        3,      // 20f/line, 6.66s total
-        4,      // 15f/line, 5s total
-        5,      // 12f/line, 4s total
-        6,      // 10f/line, 3.33 total
-        7,      // 8.57f/line, 2.85s total
-        8,      // 7.5f/line, 2.5s total
-        10,     // 6f/line, 2s total
-        12,     // 5f/line, 1.66s total
-        14,     // 4.28f/line, 1.42s total
-        17,     // 3.52f/line, 1.17s total
-        20,     // 3f/line, 60f total
-        24,     // 2.5f/line, 50f total
-        30,     // 2f/line, 40f total
-        40,     // 1.5f/line, 30f total
-        1 * 60, // 1line/f, 20f total
-        2 * 60, // 2line/f, 10f total
-        4 * 60, // 4line/f, 5f total
-        20 * 60 // lvl20 = instant gravity
-    };
-    if (this->level < 0) {
-        this->gravity = gravityPerLevel[0];
-    }
-    else if (this->level > 20) {
-        this->gravity = gravityPerLevel[20];
+    if (level >= 20) {
+        // all levels above 20 are instant gravity
+        this->gravity = 20 * 60;
     }
     else {
-        this->gravity = gravityPerLevel[this->level];
+        // get gravity for an assumed 20-rows board
+        switch (this->level) {
+            case 1 : {this->gravity = 1; break;} // 60f/line, 20s total
+            case 2 : {this->gravity = 2; break;} // 30f/line, 10s total
+            case 3 : {this->gravity = 3; break;} // 20f/line, 6.66s total
+            case 4 : {this->gravity = 4; break;} // 15f/line, 5s total
+            case 5 : {this->gravity = 5; break;} // 12f/line, 4s total
+            case 6 : {this->gravity = 6; break;} // 10f/line, 3.33 total
+            case 7 : {this->gravity = 7; break;} // 8.57f/line, 2.85s total
+            case 8 : {this->gravity = 8; break;} // 7.5f/line, 2.5s total
+            case 9 : {this->gravity = 10; break;} // 6f/line, 2s total
+            case 10 : {this->gravity = 12; break;} // 5f/line, 1.66s total
+            case 11 : {this->gravity = 14; break;} // 4.28f/line, 1.42s total
+            case 12 : {this->gravity = 17; break;} // 3.52f/line, 1.17s total
+            case 13 : {this->gravity = 20; break;} // 3f/line, 60f total
+            case 14 : {this->gravity = 24; break;} // 2.5f/line, 50f total
+            case 15 : {this->gravity = 30; break;} // 2f/line, 40f total
+            case 16 : {this->gravity = 40; break;} // 1.5f/line, 30f total
+            case 17 : {this->gravity = 1 * 60; break;} // 1line/f, 20f total
+            case 18 : {this->gravity = 2 * 60; break;} // 2line/f, 10f total
+            case 19 : {this->gravity = 4 * 60; break;} // 4line/f, 5f total
+            default : this->gravity = 1;
+        }
     }
 
     /* LOCK DELAY */
@@ -195,50 +188,50 @@ void GameParameters::updateStats() {
     }
 }
 
-int GameParameters::getClearedLines() const {
+int GameParameters::getClearedLines() {
     return this->clearedLines;
 }
 
-int GameParameters::getLevel() const {
+int GameParameters::getLevel() {
     return this->level;
 }
 
-int GameParameters::getNextQueueLength() const {
+int GameParameters::getNextQueueLength() {
     return this->nextQueueLength;
 }
 
-bool GameParameters::getBoneBlocks() const {
+bool GameParameters::getBoneBlocks() {
     return this->boneBlocks;
 }
 
-int GameParameters::getGravity() const {
+int GameParameters::getGravity() {
     return this->gravity;
 }
 
-int GameParameters::getLockDelay() const {
+int GameParameters::getLockDelay() {
     return this->lockDelay;
 }
 
-int GameParameters::getForcedLockDelay() const {
+int GameParameters::getForcedLockDelay() {
     return this->forcedLockDelay;
 }
 
-int GameParameters::getARE() const {
+int GameParameters::getARE() {
     return this->ARE;
 }
 
-int GameParameters::getLineARE() const {
+int GameParameters::getLineARE() {
     return this->lineARE;
 }
 
-int GameParameters::getDAS() const {
+int GameParameters::getDAS() {
     return this->DAS;
 }
 
-int GameParameters::getARR() const {
+int GameParameters::getARR() {
     return this->ARR;
 }
 
-int GameParameters::getSDR() const {
+int GameParameters::getSDR() {
     return this->SDR;
 }

src/Core/GameParameters.h

@@ -10,20 +10,20 @@
  */
 class GameParameters {
     private:
-        Gamemode gamemode;   // the current gamemode
-        Player controls;     // the player's controls
-        int clearedLines;    // the number of cleared lines
-        int level;           // the current level
+        Gamemode gamemode; // the current gamemode
+        Player controls; // the player's controls
+        int clearedLines; // the number of cleared lines
+        int level; // the current level
         int nextQueueLength; // the number of pieces visibles in the next queue
-        bool boneBlocks;     // wheter all blocks are bone blocks
-        int gravity;         // the gravity at which pieces drop
-        int lockDelay;       // the time before the piece lock in place
+        bool boneBlocks; // wheter all blocks are bone blocks
+        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
-        int ARE;             // the time before the next piece spawn
-        int lineARE;         // the time before the next piece spawn, after clearing a line
-        int DAS;             // the time before the piece repeats moving
-        int ARR;             // the rate at which the piece repeats moving
-        int SDR;             // the rate at which the piece soft drops
+        int ARE; // the time before the next piece spawn
+        int lineARE; // the time before the next piece spawn, after clearing a line
+        int DAS; // the time before the piece repeats moving
+        int ARR; // the rate at which the piece repeats moving
+        int SDR; // the rate at which the piece soft drops
 
     public:
         /**
@@ -32,20 +32,14 @@ class GameParameters {
         GameParameters(Gamemode gamemode, const Player& controls);
 
         /**
-         * Resets all stats and parameters
-         */
-        void reset();
-
-        /**
-         * Counts the newly cleared lines and update level and stats if needed
+         * Count the newly cleared lines and update level and stats if needed
          */
         void clearLines(int lineNumber);
 
         /**
-         * Checks if the game ended based on the current states and time passed, accorind to the gamemode
-         * @return If the player has won
+         * Returns wheter the game ended
          */
-        bool hasWon(int framesPassed) const;
+        bool hasWon(int framesPassed);
 
     private:
         /**
@@ -55,62 +49,62 @@ class GameParameters {
 
     public:
         /**
-         * @return The current number of cleared line
+         * Returns the current number of cleared line
          */
-        int getClearedLines() const;
+        int getClearedLines();
 
         /**
-         * @return The current level
+         * Returns the current level
          */
-        int getLevel() const;
+        int getLevel();
 
         /**
-         * @return The length of the next queue
+         * Returns the length of the next queue
          */
-        int getNextQueueLength() const;
+        int getNextQueueLength();
 
         /**
          * Returns wheter the blocks are currently bone blocks
          */
-        bool getBoneBlocks() const;
+        bool getBoneBlocks();
         
         /**
-         * @return The current gravity for a 20-line high board
+         * Returns the current gravity for a 20-line high board
          */
-        int getGravity() const;
+        int getGravity();
 
         /**
-         * @return The current lock delay
+         * Returns the current lock delay
          */
-        int getLockDelay() const;
+        int getLockDelay();
 
         /**
-         * @return The current forced lock delay
+         * Returns the current forced lock delay
          */
-        int getForcedLockDelay() const;
+        int getForcedLockDelay();
 
         /**
-         * @return The current ARE
+         * Returns the current ARE
          */
-        int getARE() const;
+        int getARE();
 
         /**
-         * @return The current line ARE
+         * Returns the current line ARE
          */
-        int getLineARE() const;
+        int getLineARE();
         
         /**
-         * @return The current DAS
+         * Returns the current DAS
          */
-        int getDAS() const;
+        int getDAS();
 
         /**
-         * @return The current ARR
+         * Returns the current ARR
          */
-        int getARR() const;
+        int getARR();
 
         /**
-         * @return The current SDR
+         * Returns the current SDR
          */
-        int getSDR() const;
+        int getSDR();
 };

src/Core/LineClear.h

@@ -5,7 +5,7 @@
  * Specify how many lines were cleared and how
  */
 struct LineClear {
-    int lines;       // the number of lines cleared
-    bool isSpin;     // if the move was a spin
+    int lines; // the number of lines cleared
+    bool isSpin; // if the move was a spin
     bool isMiniSpin; // if the move was a spin mini
 };

src/Core/Menu.cpp

@@ -1,52 +0,0 @@
-#include "Menu.h"
-
-#include "PiecesList.h"
-#include "Player.h"
-#include "Game.h"
-
-#include <memory>
-
-static const int DEFAULT_BOARD_WIDTH = 10;  // the default width of the board when starting the menu
-static const int DEFAULT_BOARD_HEIGHT = 20; // the default height of the board when starting the menu
-
-
-Menu::Menu() {
-    this->piecesList = std::make_shared<PiecesList>(PiecesList());
-
-    this->boardWidth = DEFAULT_BOARD_WIDTH;
-    this->boardHeight = DEFAULT_BOARD_HEIGHT;
-}
-
-Game Menu::startGame(Gamemode gamemode) const {
-    return Game(gamemode, this->playerControls, this->boardWidth, this->boardHeight, this->piecesList);
-}
-
-bool Menu::setBoardWidth(int width) {
-    if (width < 1) return false;
-
-    this->boardWidth = width;
-    return true;
-}
-
-bool Menu::setBoardHeight(int height) {
-    if (height < 1) return false;
-
-    this->boardHeight = height;
-    return true;
-}
-
-int Menu::getBoardWidth() const {
-    return this->boardWidth;
-}
-
-int Menu::getBoardHeight() const {
-    return this->boardHeight;
-}
-
-Player& Menu::getPlayerControls() {
-    return this->playerControls;
-}
-
-PiecesList& Menu::getPiecesList() {
-    return *this->piecesList;
-}

src/Core/Menu.h

@@ -1,63 +0,0 @@
-#pragma once
-
-#include "PiecesList.h"
-#include "Player.h"
-#include "Game.h"
-
-static const int FRAMES_PER_SECOND = 60;   // the number of frames per second, all the values in the app were choosen with this number in mind
-
-
-/**
- * The interface between an UI and the core of the app
- */
-class Menu {
-    private:
-        std::shared_ptr<PiecesList> piecesList; // the list of pieces used by the app
-        Player playerControls;                  // the controls of the player
-        int boardWidth;                         // the width of the board for the next game
-        int boardHeight;                        // the height of the board for the next game
-
-    public:
-        /**
-         * Initializes the board size and player controls to their default values
-         */
-        Menu();
-
-        /**
-         * Starts a new game with the current settings
-         * @return The game that has been created
-         */
-        Game startGame(Gamemode gamemode) const;
-
-        /**
-         * Sets the width of the board, which must be greater than 0
-         * @return If the width has been changed
-         */
-        bool setBoardWidth(int width);
-
-        /**
-         * Sets the height of the board, which must be greater than 0
-         * @return If the height has been changed
-         */
-        bool setBoardHeight(int height);
-    
-        /**
-         * @return The width of the board
-         */
-        int getBoardWidth() const;
-
-        /**
-         * @return The height of the board
-         */
-        int getBoardHeight() const;
-    
-        /**
-         * @return A reference to the player's controls
-         */
-        Player& getPlayerControls();
-    
-        /**
-         * @return A reference to the pieces list
-         */
-        PiecesList& getPiecesList();
-};

src/Core/PiecesList.cpp

@@ -1,113 +0,0 @@
-#include "PiecesList.h"
-
-#include "../Pieces/Piece.h"
-#include "../Pieces/PiecesFiles.h"
-
-#include <vector>
-#include <utility>
-
-
-PiecesList::PiecesList() {
-    this->highestLoadedSize = 0;
-    this->selectedPieces.clear();
-
-    // we need to have something at index 0 even if there is no pieces of size 0
-    this->loadedPieces.clear();
-    this->convexPieces.clear();
-    this->holelessPieces.clear();
-    this->otherPieces.clear();
-    this->pushBackEmptyVectors();
-
-    // we always prepare vectors of the next size to be generated
-    this->pushBackEmptyVectors();
-}
-
-bool PiecesList::loadPieces(int size) {
-    if (size < 1) return false;
-
-    PiecesFiles piecesFiles;
-    for (int i = this->highestLoadedSize + 1; i <= size; i++) {
-
-        if (!piecesFiles.loadPieces(i, this->loadedPieces.at(i), this->convexPieces.at(i), this->holelessPieces.at(i), this->otherPieces.at(i))) {
-            return false;
-        }
-        else {
-            this->highestLoadedSize++;
-            this->pushBackEmptyVectors();
-        }
-    }
-
-    return true;
-}
-
-bool PiecesList::selectPiece(int size, int number) {
-    if (size < 1 || size > this->highestLoadedSize || number >= this->loadedPieces.at(size).size()) return false;
-
-    this->selectedPieces.push_back(std::pair<int, int>(size, number));
-    return true;
-}
-
-bool PiecesList::selectAllPieces(int size) {
-    if (size < 1 || size > this->highestLoadedSize) return false;
-
-    for (int i = 0; i < this->loadedPieces.at(size).size(); i++) {
-        this->selectedPieces.push_back(std::pair<int, int>(size, i));
-    }
-    return true;
-}
-
-bool PiecesList::selectConvexPieces(int size) {
-    if (size < 1 || size > this->highestLoadedSize) return false;
-
-    for (int index : this->convexPieces.at(size)) {
-        this->selectedPieces.push_back(std::pair<int, int>(size, index));
-    }
-    return true;
-}
-
-bool PiecesList::selectHolelessPieces(int size) {
-    if (size < 1 || size > this->highestLoadedSize) return false;
-
-    for (int index : this->holelessPieces.at(size)) {
-        this->selectedPieces.push_back(std::pair<int, int>(size, index));
-    }
-    return true;
-}
-
-bool PiecesList::selectOtherPieces(int size) {
-    if (size < 1 || size > this->highestLoadedSize) return false;
-
-    for (int index : this->otherPieces.at(size)) {
-        this->selectedPieces.push_back(std::pair<int, int>(size, index));
-    }
-    return true;
-}
-
-void PiecesList::unselectAll() {
-    this->selectedPieces.clear();
-}
-
-int PiecesList::getHighestLoadedSize() const {
-    return this->highestLoadedSize;
-}
-
-int PiecesList::getNumberOfPieces(int size) const {
-    if (size < 1 || size > this->highestLoadedSize) return 0;
-
-    return this->loadedPieces.at(size).size();
-}
-
-std::vector<std::pair<int, int>> PiecesList::getSelectedPieces() const {
-    return this->selectedPieces;
-}
-
-Piece PiecesList::getPiece(const std::pair<int, int>& pieceIndex) const {
-    return this->loadedPieces.at(pieceIndex.first).at(pieceIndex.second);
-}
-
-void PiecesList::pushBackEmptyVectors() {
-    this->loadedPieces.push_back(std::vector<Piece>());
-    this->convexPieces.push_back(std::vector<int>());
-    this->holelessPieces.push_back(std::vector<int>());
-    this->otherPieces.push_back(std::vector<int>());
-}

src/Core/PiecesList.h

@@ -1,94 +0,0 @@
-#pragma once
-
-#include "../Pieces/Piece.h"
-
-#include <vector>
-#include <utility>
-
-
-/**
- * A container for all loaded pieces to prevent loading and copying them multiple times,
- * also allows for the player to select a list of pieces to be used in a game
- */
-class PiecesList {
-    private:
-        int highestLoadedSize;                           // the highest size of pieces currently loaded
-        std::vector<std::vector<Piece>> loadedPieces;    // every loaded pieces by size
-        std::vector<std::vector<int>> convexPieces;      // the list of convex loaded pieces by size
-        std::vector<std::vector<int>> holelessPieces;    // the list of holeless loaded pieces by size
-        std::vector<std::vector<int>> otherPieces;       // the list of other loaded pieces by size
-        std::vector<std::pair<int, int>> selectedPieces; // the list of all currently selected pieces
-
-    public:
-        /**
-         * Initializes a list of pieces up to size 0 (so no pieces)
-         */
-        PiecesList();
-
-        /**
-         * Makes the list load all pieces of the specified size
-         * @return If it sucessfully loaded the pieces
-         */
-        bool loadPieces(int size);
-
-        /**
-         * Selects the specified piece
-         * @return If the piece could be selected
-         */
-        bool selectPiece(int size, int number);
-
-        /**
-         * Selects all pieces of the specified size
-         * @return If the pieces could be selected
-         */
-        bool selectAllPieces(int size);
-
-        /**
-         * Selects all convex pieces of the specified size
-         * @return If the pieces could be selected
-         */
-        bool selectConvexPieces(int size);
-
-        /**
-         * Selects all holeless pieces of the specified size
-         * @return If the pieces could be selected
-         */
-        bool selectHolelessPieces(int size);
-
-        /**
-         * Selects all other pieces of the specified size
-         * @return If the pieces could be selected
-         */
-        bool selectOtherPieces(int size);
-
-        /**
-         * Unselects all previously selected pieces
-         */
-        void unselectAll();
-
-        /**
-         * @return The highest loaded size of pieces
-         */
-        int getHighestLoadedSize() const;
-
-        /**
-         * @return The number of pieces of the specified size
-         */
-        int getNumberOfPieces(int size) const;
-
-        /**
-         * @return A copy of the indexes of all selected pieces
-         */
-        std::vector<std::pair<int, int>> getSelectedPieces() const;
-
-        /**
-         * @return A copy of the piece corresponding to the specified index
-         */
-        Piece getPiece(const std::pair<int, int>& pieceIndex) const;
-    
-    private:
-        /**
-         * Adds empty vectors at the end of every pieces list
-         */
-        void pushBackEmptyVectors();
-};

src/Core/Player.cpp

@@ -1,5 +1,12 @@
 #include "Player.h"
 
+static const int DAS_MIN_VALUE = 0;
+static const int DAS_MAX_VALUE = 30;
+static const int ARR_MIN_VALUE = 0;
+static const int ARR_MAX_VALUE = 30;
+static const int SDR_MIN_VALUE = 0;
+static const int SDR_MAX_VALUE = 6;
+
 
 Player::Player() {
     // default settings
@@ -29,14 +36,14 @@ bool Player::setSDR(int SDR) {
     return true;
 }
 
-int Player::getDAS() const {
+int Player::getDAS() {
     return this->DAS;
 }
 
-int Player::getARR() const {
+int Player::getARR() {
     return this->ARR;
 }
 
-int Player::getSDR() const {
+int Player::getSDR() {
     return this->SDR;
 }

src/Core/Player.h

@@ -1,12 +1,5 @@
 #pragma once
 
-static const int DAS_MIN_VALUE = 0;  // the minimal selectable DAS value, equals to 0ms
-static const int DAS_MAX_VALUE = 30; // the maximal selectable DAS value, equals to 500ms
-static const int ARR_MIN_VALUE = 0;  // the minimal selectable ARR value, equals to 0ms
-static const int ARR_MAX_VALUE = 30; // the maximal selectable ARR value, equals to 500ms
-static const int SDR_MIN_VALUE = 0;  // the minimal selectable SDR value, equals to 0ms
-static const int SDR_MAX_VALUE = 6;  // the maximal selectable SDR value, equals to 100ms
-
 
 /**
  * The controls of a player
@@ -24,35 +17,32 @@ class Player {
         Player();
 
         /**
-         * Try setting DAS to the desired value
-         * @return If it is possible
+         * Try setting DAS to the desired value, and returns wheter it is possible
          */
         bool setDAS(int DAS);
 
         /**
-         * Try setting ARR to the desired value
-         * @return If it is possible
+         * Try setting ARR to the desired value, and returns wheter it is possible
          */
         bool setARR(int ARR);
 
         /**
-         * Try setting SDR to the desired value
-         * @return If it is possible
+         * Try setting SDR to the desired value, and returns wheter it is possible
          */
         bool setSDR(int SDR);
 
         /**
-         * @return DAS value
+         * Returns DAS value
          */
-        int getDAS() const;
+        int getDAS();
 
         /**
-         * @return ARR value
+         * Returns ARR value
          */
-        int getARR() const;
+        int getARR();
 
         /**
-         * @return SDR value
+         * Returns SDR value
          */
-        int getSDR() const;
+        int getSDR();
 };

src/Core/main.cpp

@@ -1,8 +1,12 @@
-#include "../Pieces/Generator.h"
 #include "../Pieces/PiecesFiles.h"
-#include "TextApp.h"
+#include "../Pieces/Generator.h"
+#include "GameBoard.h"
 
 #include <chrono>
+#include <string>
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
 
 
 void testGeneratorForAllSizes(int amount);
@@ -10,19 +14,12 @@ void testGeneratorForOneSize(int size);
 void testGeneratorByprintingAllNminos(int n);
 void testStoringAndRetrievingPieces(int size);
 void generateFilesForAllSizes(int amount);
-void generateFilesForOneSize(int 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
-    //generateFilesForAllSizes(10);
-
-    TextApp UI;
-    UI.run();
 
     return 0;
 }
@@ -37,11 +34,11 @@ void testGeneratorForAllSizes(int amount) {
 
     for (int i = 1; i <= amount; i++) {
         auto t1 = high_resolution_clock::now();
-        std::vector<Polyomino> n_minos = generator.generatePolyominoes(i);
+        std::vector<Polyomino> n_minos = generator.generatePolyominos(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() << " polyominos of size " << i << " in " << ms_double.count() << "ms" << std::endl;
     }
 }
 
@@ -55,7 +52,7 @@ void testGeneratorForOneSize(int size) {
     std::cout << "Generating " << size << "-minos" << std::endl;
     for (int i = 0; i < 10; i++) {
         auto t1 = high_resolution_clock::now();
-        std::vector<Polyomino> n_minos = generator.generatePolyominoes(size);
+        std::vector<Polyomino> n_minos = generator.generatePolyominos(size);
         auto t2 = high_resolution_clock::now();
     
         duration<double, std::milli> ms_double = t2 - t1;
@@ -65,7 +62,7 @@ void testGeneratorForOneSize(int size) {
 
 void testGeneratorByprintingAllNminos(int n) {
     Generator generator;
-    std::vector<Polyomino> n_minos = generator.generatePolyominoes(n);
+    std::vector<Polyomino> n_minos = generator.generatePolyominos(n);
 
     for (Polyomino& n_mino : n_minos) {
         n_mino.goToSpawnPosition();
@@ -109,8 +106,8 @@ void generateFilesForAllSizes(int amount) {
     using std::chrono::duration_cast;
     using std::chrono::duration;
     using std::chrono::milliseconds;
-    PiecesFiles piecesFiles;
 
+    PiecesFiles piecesFiles;
     for (int i = 1; i <= amount; i++) {
         auto t1 = high_resolution_clock::now();
         piecesFiles.savePieces(i);
@@ -120,12 +117,12 @@ void generateFilesForAllSizes(int amount) {
         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();
+        std::vector<Piece> pieces;
+        std::vector<int> convexPieces;
+        std::vector<int> holelessPieces;
+        std::vector<int> otherPieces;
         piecesFiles.loadPieces(i, pieces, convexPieces, holelessPieces, otherPieces);
         auto t2 = high_resolution_clock::now();
 
@@ -134,46 +131,6 @@ void generateFilesForAllSizes(int amount) {
     }
 }
 
-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++) {

src/GraphicalUI/AppMenus/AppMenu.h

@@ -1,63 +0,0 @@
-#pragma once
-
-#include "../Settings.h"
-
-#include <stack>
-#include <memory>
-#include <SFML/Graphics.hpp>
-
-class AppMenu;
-using MenuStack = std::stack<std::shared_ptr<AppMenu>>;
-
-
-class AppMenu {
-    protected:
-        std::shared_ptr<MenuStack> menuStack;
-        std::shared_ptr<Settings> settings;
-        std::shared_ptr<sf::RenderWindow> renderWindow;
-        bool enterPressed = false;
-        bool enterReleased = false;
-        bool escPressed = false;
-        bool escReleased = false;
-    
-    public:
-        AppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow) :
-            menuStack(menuStack),
-            settings(settings),
-            renderWindow(renderWindow)
-            {
-
-        }
-
-        void updateMetaBinds() {
-            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Enter)) {
-                enterPressed = true;
-                enterReleased = false;
-            }
-            else {
-                enterReleased = enterPressed;
-                enterPressed = false;
-            }
-
-            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Escape)) {
-                escPressed = true;
-                escReleased = false;
-            }
-            else {
-                escReleased = escPressed;
-                escPressed = false;
-            }
-        }
-
-        virtual void computeFrame() = 0;
-
-        virtual void drawFrame() const = 0;
-};
-
-
-inline void changeVideoMode(sf::RenderWindow& window, const sf::VideoMode& videoMode) {
-    window.create(videoMode, "jminos", sf::Style::Close | sf::Style::Titlebar);
-    sf::Vector2u desktopSize = sf::VideoMode::getDesktopMode().size;
-    sf::Vector2u windowSize = window.getSize();
-    window.setPosition(sf::Vector2i((desktopSize.x / 2) - (windowSize.x / 2), (desktopSize.y / 2) - (windowSize.y / 2)));
-}

src/GraphicalUI/AppMenus/GamePlayingAppMenu.cpp

@@ -1,103 +0,0 @@
-#include "GamePlayingAppMenu.h"
-
-#include "AppMenu.h"
-
-#include <stack>
-#include <memory>
-#include <SFML/Graphics.hpp>
-
-
-GamePlayingAppMenu::GamePlayingAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow) :
-    AppMenu(menuStack, settings, renderWindow),
-    game(this->settings->getMenu().startGame(this->settings->getGamemode()))
-    {
-    
-    this->game.start();
-    this->paused = false;
-}
-
-void GamePlayingAppMenu::computeFrame() {
-    this->updateMetaBinds();
-
-    if (this->escReleased) {
-        this->menuStack->pop();
-    }
-    else {
-        std::set<Action> actions;
-        for (Action action : ACTION_LIST_IN_ORDER) {
-            for (sfKey key : this->settings->getKeybinds().getKeybinds(action)) {
-                if (sf::Keyboard::isKeyPressed(key)) {
-                    actions.insert(action);
-                }
-            }
-        }
-    
-        if (actions.contains(RETRY)) {
-            this->game.reset();
-            this->game.start();
-        }
-        if (actions.contains(PAUSE)) {
-            this->paused = (!this->paused);
-        }
-    
-        if (!paused) {
-            this->game.nextFrame(actions);
-        }
-    }
-}
-
-void GamePlayingAppMenu::drawFrame() const {
-    this->renderWindow->clear(sf::Color::Black);
-
-    int sizeMultiplier = this->settings->getWindowSizeMultiplier();
-    sf::Vector2f cellSize((float) sizeMultiplier, (float) sizeMultiplier);
-
-    for (int y = this->game.getBoard().getBaseHeight() + 10; y >= 0; y--) {
-        for (int x = 0; x < this->game.getBoard().getWidth(); x++) {
-            bool isActivePieceHere = (this->game.getActivePiece() != nullptr) && (this->game.getActivePiece()->getPositions().contains(Position{x, y} - this->game.getActivePiecePosition()));
-            bool isGhostPieceHere = (this->game.getActivePiece() != nullptr) && (this->game.getActivePiece()->getPositions().contains(Position{x, y} - this->game.ghostPiecePosition()));
-            Block block = (isActivePieceHere || isGhostPieceHere) ? this->game.getActivePiece()->getBlockType() : this->game.getBoard().getBlock(Position{x, y});
-
-            sf::RectangleShape cell(cellSize);
-            cell.setFillColor(sf::Color(BLOCKS_COLOR[block].red, BLOCKS_COLOR[block].green, BLOCKS_COLOR[block].blue, (isGhostPieceHere && !isActivePieceHere) ? 150 : 255));
-            cell.setPosition(sf::Vector2f(x * sizeMultiplier, (this->game.getBoard().getBaseHeight() + 10 - y) * sizeMultiplier));
-            this->renderWindow->draw(cell);
-        }
-    }
-
-    if (this->game.getNextPieces().size() > 0) {
-        for (int y = 10; y >= 0; y--) {
-            for (int x = 0; x <= 10; x++) {
-                Block block = this->game.getNextPieces().at(0).getBlockType();
-                sf::RectangleShape cell(sf::Vector2f(20.f, 20.f));
-                cell.setPosition(sf::Vector2f((x + 2 + this->game.getBoard().getWidth())*20, (this->game.getBoard().getBaseHeight() - y)*20));
-                if (this->game.getNextPieces().at(0).getPositions().contains(Position({x, y}))) {
-                    cell.setFillColor(sf::Color(BLOCKS_COLOR[block].red, BLOCKS_COLOR[block].green, BLOCKS_COLOR[block].blue));
-                }
-                else {
-                    cell.setFillColor(sf::Color(0, 0, 0));
-                }
-                this->renderWindow->draw(cell);
-            }
-        }
-    }
-
-    if (this->game.getHeldPiece() != nullptr) {
-        for (int y = 10; y >= 0; y--) {
-            for (int x = 0; x <= 10; x++) {
-                Block block = this->game.getHeldPiece()->getBlockType();
-                sf::RectangleShape cell(sf::Vector2f(20.f, 20.f));
-                cell.setPosition(sf::Vector2f((x + 12 + this->game.getBoard().getWidth())*20, (this->game.getBoard().getBaseHeight() - y)*20));
-                if (this->game.getHeldPiece()->getPositions().contains(Position({x, y}))) {
-                    cell.setFillColor(sf::Color(BLOCKS_COLOR[block].red, BLOCKS_COLOR[block].green, BLOCKS_COLOR[block].blue));
-                }
-                else {
-                    cell.setFillColor(sf::Color(0, 0, 0));
-                }
-                this->renderWindow->draw(cell);
-            }
-        }
-    }
-
-    this->renderWindow->display();
-}

src/GraphicalUI/AppMenus/GamePlayingAppMenu.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "AppMenu.h"
-
-#include <stack>
-#include <memory>
-#include <SFML/Graphics.hpp>
-
-
-class GamePlayingAppMenu : public AppMenu {
-    private:
-        Game game;
-        bool paused;
-
-    public:
-        GamePlayingAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow);
-
-        void computeFrame();
-
-        void drawFrame() const;
-};

src/GraphicalUI/AppMenus/GameSettingsAppMenu.cpp

@@ -1,91 +0,0 @@
-#include "GameSettingsAppMenu.h"
-
-#include "AppMenu.h"
-#include "GamePlayingAppMenu.h"
-#include "PlayerCursor.h"
-
-#include <stack>
-#include <memory>
-#include <vector>
-#include <SFML/Graphics.hpp>
-
-
-GameSettingsAppMenu::GameSettingsAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow) :
-    AppMenu(menuStack, settings, renderWindow),
-    playerCursor(std::vector<unsigned int>({2, 3, 1})) {
-
-}
-
-void GameSettingsAppMenu::computeFrame() {
-    this->updateMetaBinds();
-    this->playerCursor.updatePosition();
-
-    switch (this->playerCursor.getPosition().y) {
-        case 1 : {
-            switch (this->playerCursor.getPosition().x) {
-                case 0 : {this->settings->setGamemode(SPRINT); break;}
-                case 1 : {this->settings->setGamemode(MARATHON); break;}
-                case 2 : {this->settings->setGamemode(ULTRA); break;}
-            }
-            break;
-        }
-        case 2 : {
-            switch (this->playerCursor.getPosition().x) {
-                case 0 : {this->settings->setGamemode(MASTER); break;}
-                case 1 : break; //TODO
-                case 2 : break; //TODO
-            }
-            break;
-        }
-    }
-
-    if (this->enterReleased) {
-        if (this->playerCursor.getPosition().y == 0) {
-            //TODO
-        }
-        if (this->playerCursor.getPosition().y > 0) {
-            this->menuStack->push(std::make_shared<GamePlayingAppMenu>(this->menuStack, this->settings, this->renderWindow));
-        }
-    }
-    if (this->escReleased) {
-        this->menuStack->pop();
-    }
-}
-
-void GameSettingsAppMenu::drawFrame() const {
-    this->renderWindow->clear(sf::Color(200, 200, 200));
-
-
-    sf::Font font("data/fonts/pressstart/prstartk.ttf");
-    sf::Text text(font, "", this->settings->getWindowSizeMultiplier() * 2);
-    text.setFillColor(sf::Color(0, 0, 0));
-    text.setOutlineColor(sf::Color(255, 255, 255));
-
-    text.setString("GAME SETTINGS");
-    text.setOrigin(text.getLocalBounds().getCenter());
-    text.setPosition(sf::Vector2f({(float) this->settings->getWindowSizeMultiplier() * 40, (float) this->settings->getWindowSizeMultiplier() * 5}));
-    this->renderWindow->draw(text);
-
-    this->placeText(text, "PIECES SELECT", 5.f, 15.f, 0, 0);
-    this->placeText(text, "BOARD SELECT", 40.f, 15.f, 1, 0);
-
-    this->placeText(text, "SPRINT", 5.f, 25.f, 0, 1);
-    this->placeText(text, "MARATHON", 25.f, 25.f, 1, 1);
-    this->placeText(text, "ULTRA", 50.f, 25.f, 2, 1);
-    this->placeText(text, "MASTER", 5.f, 35.f, 0, 2);
-    this->placeText(text, "TODO", 25.f, 35.f, 1, 2);
-    this->placeText(text, "TOOD", 50.f, 35.f, 2, 2);
-    
-    this->renderWindow->display();
-}
-
-void GameSettingsAppMenu::placeText(sf::Text& text, const sf::String& string, float xPos, float yPos, unsigned int xCursorOutline, unsigned int yCursorOutline) const {
-    float sizeMultiplier = this->settings->getWindowSizeMultiplier();
-
-    text.setString(string);
-    text.setOutlineThickness((this->playerCursor.getPosition().x == xCursorOutline
-                           && this->playerCursor.getPosition().y == yCursorOutline) ? (sizeMultiplier / 2) : 0);
-    text.setOrigin(sf::Vector2f({0, text.getLocalBounds().size.y / 2}));
-    text.setPosition(sf::Vector2f({sizeMultiplier * xPos, sizeMultiplier * yPos}));
-    this->renderWindow->draw(text);
-}

src/GraphicalUI/AppMenus/GameSettingsAppMenu.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include "AppMenu.h"
-#include "PlayerCursor.h"
-
-#include <stack>
-#include <memory>
-#include <SFML/Graphics.hpp>
-
-
-class GameSettingsAppMenu : public AppMenu {
-    private:
-        PlayerCursor playerCursor;
-
-    public:
-        GameSettingsAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow);
-
-        void computeFrame();
-
-        void drawFrame() const;
-
-        void placeText(sf::Text& text, const sf::String& string, float xPos, float yPos, unsigned int xCursorOutline, unsigned int yCursorOutline) const ;
-};

src/GraphicalUI/AppMenus/MainAppMenu.cpp

@@ -1,73 +0,0 @@
-#include "MainAppMenu.h"
-
-#include "AppMenu.h"
-#include "GameSettingsAppMenu.h"
-#include "PlayerCursor.h"
-
-#include <stack>
-#include <memory>
-#include <vector>
-#include <SFML/Graphics.hpp>
-
-
-MainAppMenu::MainAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow) :
-    AppMenu(menuStack, settings, renderWindow),
-    playerCursor(std::vector<unsigned int>({1, 1, 1})) {
-
-}
-
-void MainAppMenu::computeFrame() {
-    this->updateMetaBinds();
-    this->playerCursor.updatePosition();
-
-    if (this->enterReleased) {
-        if (this->playerCursor.getPosition().y == 0) {
-            this->menuStack->push(std::make_shared<GameSettingsAppMenu>(this->menuStack, this->settings, this->renderWindow));
-        }
-        if (this->playerCursor.getPosition().y == 1) {
-            //TODO
-        }
-        if (this->playerCursor.getPosition().y == 2) {
-            //TODO
-        }
-    }
-    if (this->escReleased) {
-        this->menuStack->pop();
-    }
-}
-
-void MainAppMenu::drawFrame() const {
-    this->renderWindow->clear(sf::Color(200, 200, 200));
-
-    float sizeMultiplier = this->settings->getWindowSizeMultiplier();
-
-    sf::Font font("data/fonts/pressstart/prstartk.ttf");
-    sf::Text text(font, "", this->settings->getWindowSizeMultiplier() * 2);
-    text.setFillColor(sf::Color(0, 0, 0));
-    text.setOutlineColor(sf::Color(255, 255, 255));
-
-    text.setString("JMINOS");
-    text.setOrigin(text.getLocalBounds().getCenter());
-    text.setPosition(sf::Vector2f({sizeMultiplier * 40, sizeMultiplier * 10}));
-    this->renderWindow->draw(text);
-
-    text.setString("PLAY");
-    text.setOutlineThickness((this->playerCursor.getPosition().y == 0) ? (sizeMultiplier / 2) : 0);
-    text.setOrigin(text.getLocalBounds().getCenter());
-    text.setPosition(sf::Vector2f({sizeMultiplier * 40, sizeMultiplier * 20}));
-    this->renderWindow->draw(text);
-    
-    text.setString("SETTINGS");
-    text.setOutlineThickness((this->playerCursor.getPosition().y == 1) ? (sizeMultiplier / 2) : 0);
-    text.setOrigin(text.getLocalBounds().getCenter());
-    text.setPosition(sf::Vector2f({sizeMultiplier * 40, sizeMultiplier * 30}));
-    this->renderWindow->draw(text);
-    
-    text.setString("INFO");
-    text.setOutlineThickness((this->playerCursor.getPosition().y == 2) ? (sizeMultiplier / 2) : 0);
-    text.setOrigin(text.getLocalBounds().getCenter());
-    text.setPosition(sf::Vector2f({sizeMultiplier * 40, sizeMultiplier * 40}));
-    this->renderWindow->draw(text);
-    
-    this->renderWindow->display();
-}

src/GraphicalUI/AppMenus/MainAppMenu.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "AppMenu.h"
-#include "PlayerCursor.h"
-
-#include <stack>
-#include <memory>
-#include <SFML/Graphics.hpp>
-
-
-class MainAppMenu : public AppMenu {
-    private:
-        PlayerCursor playerCursor;
-
-    public:
-        MainAppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings> settings, std::shared_ptr<sf::RenderWindow> renderWindow);
-
-        void computeFrame();
-
-        void drawFrame() const;
-};

src/GraphicalUI/AppMenus/PlayerCursor.cpp

@@ -1,105 +0,0 @@
-#include "PlayerCursor.h"
-
-#include "../Keybinds.h"
-#include "../Settings.h"
-
-#include <vector>
-#include <algorithm>
-#include <SFML/Graphics.hpp>
-
-static const int MENU_DAS = FRAMES_PER_SECOND / 2;
-
-
-PlayerCursor::PlayerCursor(std::vector<unsigned int> rows) :
-    rows(rows) {
-
-    this->position = sf::Vector2u({0, 0});
-    this->leftDAS = 0;
-    this->rightDAS = 0;
-    this->upDAS = 0;
-    this->downDAS = 0;
-}
-
-void PlayerCursor::updatePosition() {
-    (sf::Keyboard::isKeyPressed(sfKey::Left)) ? (this->leftDAS++) : (this->leftDAS = 0);
-    if (this->shouldMove(this->leftDAS)) {
-        this->moveLeft();
-    }
-
-    (sf::Keyboard::isKeyPressed(sfKey::Right)) ? (this->rightDAS++) : (this->rightDAS = 0);
-    if (this->shouldMove(this->rightDAS)) {
-        this->moveRight();
-    }
-
-    (sf::Keyboard::isKeyPressed(sfKey::Up)) ? (this->upDAS++) : (this->upDAS = 0);
-    if (this->shouldMove(this->upDAS)) {
-        this->moveUp();
-    }
-
-    (sf::Keyboard::isKeyPressed(sfKey::Down)) ? (this->downDAS++) : (this->downDAS = 0);
-    if (this->shouldMove(this->downDAS)) {
-        this->moveDown();
-    }
-}
-
-void PlayerCursor::goToPosition(const sf::Vector2u& newPosition) {
-    if (this->rows.size() > newPosition.y) {
-        if (this->rows.at(newPosition.y) > newPosition.x) {
-            this->position = newPosition;
-        }
-    }
-}
-
-const sf::Vector2u& PlayerCursor::getPosition() const {
-    return this->position;
-}
-
-bool PlayerCursor::shouldMove(int DAS) const {
-    return (DAS == 1
-        || (DAS > MENU_DAS && (DAS % 5) == 0)
-        || (DAS > (FRAMES_PER_SECOND * 2)));
-}
-
-void PlayerCursor::moveLeft() {
-    if (this->position.x == 0) {
-        this->position.x = this->rows.at(this->position.y) - 1;
-    }
-    else {
-        this->position.x--;
-    }
-}
-
-void PlayerCursor::moveRight() {
-    if (this->position.x == this->rows.at(this->position.y) - 1) {
-        this->position.x = 0;
-    }
-    else {
-        this->position.x++;
-    }
-}
-
-void PlayerCursor::moveUp() {
-    if (this->position.y == 0) {
-        this->position.y = this->rows.size() - 1;
-    }
-    else {
-        this->position.y--;
-    }
-
-    if (this->position.x >= this->rows.at(this->position.y)) {
-        this->position.x = this->rows.at(this->position.y) - 1;
-    }
-}
-
-void PlayerCursor::moveDown() {
-    if (this->position.y == this->rows.size() - 1) {
-        this->position.y = 0;
-    }
-    else {
-        this->position.y++;
-    }
-
-    if (this->position.x >= this->rows.at(this->position.y)) {
-        this->position.x = this->rows.at(this->position.y) - 1;
-    }
-}

src/GraphicalUI/AppMenus/PlayerCursor.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <SFML/Graphics.hpp>
-
-
-class PlayerCursor {
-    private:
-        std::vector<unsigned int> rows;
-        sf::Vector2u position;
-        int leftDAS;
-        int rightDAS;
-        int upDAS;
-        int downDAS;
-
-    public:
-        PlayerCursor(std::vector<unsigned int> rows);
-
-        void updatePosition();
-
-        void goToPosition(const sf::Vector2u& newPosition);
-
-        const sf::Vector2u& getPosition() const;
-    
-    private:
-        bool shouldMove(int DAS) const;
-
-        void moveLeft();
-
-        void moveRight();
-
-        void moveUp();
-
-        void moveDown();
-};

src/GraphicalUI/GraphApp.cpp

@@ -1,52 +0,0 @@
-#include "GraphApp.h"
-
-#include "AppMenus/AppMenu.h"
-#include "AppMenus/MainAppMenu.h"
-#include "Settings.h"
-
-#include <stack>
-#include <memory>
-#include <SFML/Graphics.hpp>
-
-static const double TIME_BETWEEN_FRAMES = (1000.f / FRAMES_PER_SECOND);
-
-
-GraphApp::GraphApp() {
-    this->settings = std::make_shared<Settings>();
-    this->menuStack = std::make_shared<MenuStack>();
-    this->renderWindow = std::make_shared<sf::RenderWindow>();
-}
-
-void GraphApp::run() {
-    changeVideoMode(*this->renderWindow, this->settings->getVideoMode());
-    this->menuStack->push(std::make_shared<MainAppMenu>(this->menuStack, this->settings, this->renderWindow));
-
-    bool quit = false;
-    double timeAtNextFrame = 0;
-    sf::Clock clock;
-    while (!quit) {
-        while (const std::optional event = this->renderWindow->pollEvent()) {
-            if (event->is<sf::Event::Closed>()) {
-                quit = true;
-            }
-        }
-
-        if (!quit) {
-            if (clock.getElapsedTime().asMilliseconds() > timeAtNextFrame) {
-                this->menuStack->top()->computeFrame();
-
-                if (this->menuStack->empty()) {
-                    quit = true;
-                }
-                else {
-                    this->menuStack->top()->drawFrame();
-                }
-
-                while (clock.getElapsedTime().asMilliseconds() > timeAtNextFrame) {
-                    timeAtNextFrame += TIME_BETWEEN_FRAMES;
-                }
-            }
-        }   
-    }
-    renderWindow->close();
-}

src/GraphicalUI/GraphApp.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "AppMenus/AppMenu.h"
-#include "Settings.h"
-
-#include <stack>
-#include <memory>
-#include <SFML/Graphics.hpp>
-
-
-class GraphApp {
-    private:
-        std::shared_ptr<Settings> settings;
-        std::shared_ptr<MenuStack> menuStack;
-        std::shared_ptr<sf::RenderWindow> renderWindow;
-    
-    public:
-        GraphApp();
-
-        void run();
-};

src/GraphicalUI/Keybinds.cpp

@@ -1,86 +0,0 @@
-#include "Keybinds.h"
-
-#include "../Core/Action.h"
-
-#include <map>
-#include <set>
-#include <fstream>
-#include <SFML/Graphics.hpp>
-
-
-Keybinds::Keybinds(int layoutNumber) :
-    layoutNumber(layoutNumber) {
-
-    for (Action action : ACTION_LIST_IN_ORDER) {
-        this->keybinds.insert({action, std::set<sfKey>()});
-    }
-
-    this->loadKeybindsFromFile();
-}
-
-void Keybinds::loadKeybindsFromFile() {
-    std::ifstream layoutFile("data/config/keybinds/layout" + std::to_string(this->layoutNumber) + ".bin", std::ios::binary);
-
-    for (Action action : ACTION_LIST_IN_ORDER) {
-        this->keybinds.at(action).clear();
-    }
-
-    char byte;
-    while (layoutFile.peek() != EOF) {
-        layoutFile.get(byte);
-        Action action = Action(byte);
-
-        bool separatorMet = false;
-        while (!separatorMet) {
-            layoutFile.get(byte);
-            if (byte == (char) 0xFF) {
-                separatorMet = true;
-            }
-            else {
-                this->keybinds.at(action).insert(sfKey(byte));
-            }
-        }
-    }
-}
-
-void Keybinds::saveKeybindsToFile() const {
-    std::ofstream layoutFile("data/config/keybinds/layout" + std::to_string(this->layoutNumber) + ".bin", std::ios::trunc | std::ios::binary);
-
-    char byte;
-    for (Action action : ACTION_LIST_IN_ORDER) {
-        byte = action;
-        layoutFile.write(&byte, 1);
-
-        for (sfKey key : this->keybinds.at(action)) {
-            byte = (int) key;
-            layoutFile.write(&byte, 1);
-        }
-        
-        byte = 0xFF;
-        layoutFile.write(&byte, 1);
-    }
-}
-
-void Keybinds::addKey(Action action, sfKey key) {
-    this->keybinds.at(action).insert(key);
-}
-
-void Keybinds::clearKeys(Action action) {
-    this->keybinds.at(action).clear();
-}
-
-const std::set<Action> Keybinds::getActions(sfKey key) const {
-    std::set<Action> actions;
-
-    for (const auto& [action, keys] : this->keybinds) {
-        if (keys.contains(key)) {
-            actions.insert(action);
-        }
-    }
-
-    return actions;
-}
-
-const std::set<sfKey>& Keybinds::getKeybinds(Action action) const {
-    return this->keybinds.at(action);
-}

src/GraphicalUI/Keybinds.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "../Core/Action.h"
-
-#include <map>
-#include <set>
-#include <SFML/Graphics.hpp>
-
-using sfKey = sf::Keyboard::Key;
-
-static const int NUMBER_OF_KEYBINDS = 5;
-static const int CUSTOMIZABLE_KEYBINDS = NUMBER_OF_KEYBINDS - 1;
-
-
-class Keybinds {
-    private:
-        std::map<Action, std::set<sfKey>> keybinds;
-        int layoutNumber;
-    
-    public:
-        Keybinds(int layoutNumber);
-
-        void loadKeybindsFromFile();
-
-        void saveKeybindsToFile() const;
-
-        void addKey(Action action, sfKey key);
-
-        void clearKeys(Action action);
-
-        const std::set<Action> getActions(sfKey key) const;
-
-        const std::set<sfKey>& getKeybinds(Action action) const;
-};

src/GraphicalUI/PiecesType.h

@@ -1,21 +0,0 @@
-#pragma once
-
-
-enum PiecesType {
-    CONVEX_PIECES,
-    HOLELESS_PIECES,
-    OTHER_PIECES,
-    ALL_PIECES,
-    SINGLE_PIECE
-};
-
-
-inline int getSizeOfPieces(PiecesType type) {
-    if (type < SINGLE_PIECE) return 0;
-
-    else return (type - SINGLE_PIECE + 1);
-}
-
-inline PiecesType createSinglePieceType(int size) {
-    return PiecesType(SINGLE_PIECE + size - 1);
-}

src/GraphicalUI/Settings.cpp

@@ -1,199 +0,0 @@
-#include "Settings.h"
-
-#include "../Core/Menu.h"
-#include "Keybinds.h"
-
-#include <SFML/Graphics.hpp>
-#include <fstream>
-
-static const sf::Vector2u BASE_WINDOW_SIZE = {80, 50};
-static const int WINDOW_SIZE_MULTIPLIERS[] = {4, 6, 10, 14, 20};
-static const int WINDOW_SIZE_LAST_MODE = (sizeof(WINDOW_SIZE_MULTIPLIERS) / sizeof(int)) - 1;
-
-
-Settings::Settings() {
-    for (int i = 1; i <= MAXIMUM_PIECES_SIZE; i++) {
-        this->menu.getPiecesList().loadPieces(i);
-    }
-
-    this->keybinds.reserve(NUMBER_OF_KEYBINDS);
-    for (int i = 0; i < NUMBER_OF_KEYBINDS; i++) {
-        this->keybinds.emplace_back(i);
-    }
-
-    this->loadSettingsFromFile();
-}
-
-void Settings::loadSettingsFromFile() {
-    std::ifstream settingsFile("data/config/settings.bin", std::ios::binary);
-    char byte;
-
-    // keybind layout
-    settingsFile.get(byte);
-    this->chosenKeybinds = byte;
-
-    // window size mode
-    settingsFile.get(byte);
-    this->windowSizeMode = byte;
-
-    // gamemode
-    settingsFile.get(byte);
-    this->gamemode = Gamemode(byte);
-
-    // board width
-    settingsFile.get(byte);
-    this->menu.setBoardWidth(byte);
-
-    // board height
-    settingsFile.get(byte);
-    this->menu.setBoardHeight(byte);
-
-    // piece distribution
-    settingsFile.get(byte);
-    //TODO
-
-    // selected pieces
-    char pieceType;
-    char pieceValue;
-    this->selectedPieces.clear();
-    while (settingsFile.get(pieceType)) {
-        if (settingsFile.eof()) break;
-        
-        settingsFile.get(pieceValue);
-        this->selectedPieces.push_back({PiecesType(pieceType), pieceValue});
-    }
-    this->confirmSelectedPieces();
-}
-
-void Settings::saveSettingsToFile() const {
-    std::ofstream settingsFile("data/config/settings.bin", std::ios::trunc | std::ios::binary);
-    char byte;
-
-    // keybind layout
-    byte = this->chosenKeybinds;
-    settingsFile.write(&byte, 1);
-
-    // window size mode
-    byte = this->windowSizeMode;
-    settingsFile.write(&byte, 1);
-
-    // gamemode
-    byte = this->gamemode;
-    settingsFile.write(&byte, 1);
-
-    // board width
-    byte = this->menu.getBoardWidth();
-    settingsFile.write(&byte, 1);
-
-    // board height
-    byte = this->menu.getBoardHeight();
-    settingsFile.write(&byte, 1);
-
-    // piece distribution
-    //TODO
-    settingsFile.write(&byte, 1);
-
-    // selected pieces
-    for (const auto& [type, value] : this->selectedPieces) {
-        byte = type;
-        settingsFile.write(&byte, 1);
-        byte = value;
-        settingsFile.write(&byte, 1);
-    }
-}
-
-bool Settings::selectNextKeybinds() {
-    if (this->chosenKeybinds < NUMBER_OF_KEYBINDS) {
-        this->chosenKeybinds++;
-        return true;
-    }
-    return false;
-}
-
-bool Settings::selectPreviousKeybinds() {
-    if (this->chosenKeybinds > 0) {
-        this->chosenKeybinds--;
-        return true;
-    }
-    return false;
-}
-
-bool Settings::canModifyCurrentKeybinds() const {
-    return (this->chosenKeybinds == CUSTOMIZABLE_KEYBINDS);
-}
-
-void Settings::setGamemode(Gamemode gamemode) {
-    this->gamemode = gamemode;
-}
-
-bool Settings::widenWindow() {
-    if (this->windowSizeMode < WINDOW_SIZE_LAST_MODE) {
-        this->windowSizeMode++;
-        return true;
-    }
-    return false;
-}
-
-bool Settings::shortenWindow() {
-    if (this->windowSizeMode > 0) {
-        this->windowSizeMode--;
-        return true;
-    }
-    return false;
-}
-
-void Settings::selectPieces(PiecesType type, int value) {
-    this->selectedPieces.emplace_back(type, value);
-}
-
-void Settings::unselectPieces(int index) {
-    if (index >= this->selectedPieces.size()) return;
-
-    this->selectedPieces.erase(this->selectedPieces.begin() + index);
-}
-
-void Settings::confirmSelectedPieces() {
-    this->menu.getPiecesList().unselectAll();
-
-    for (const auto& [type, value] : this->selectedPieces) {
-        int size = getSizeOfPieces(type);
-
-        if (size == 0) {
-            switch (type) {
-                case CONVEX_PIECES : {this->menu.getPiecesList().selectConvexPieces(value); break;}
-                case HOLELESS_PIECES : {this->menu.getPiecesList().selectHolelessPieces(value); break;}
-                case OTHER_PIECES : {this->menu.getPiecesList().selectOtherPieces(value); break;}
-                case ALL_PIECES : {this->menu.getPiecesList().selectAllPieces(value); break;}
-            }
-        }
-        else {
-            if (size > MAXIMUM_PIECES_SIZE) return;
-
-            this->menu.getPiecesList().selectPiece(size, value);
-        }
-    }
-}
-
-Menu& Settings::getMenu() {
-    return this->menu;
-}
-
-Keybinds& Settings::getKeybinds() {
-    return this->keybinds.at(this->chosenKeybinds);
-}
-
-Gamemode Settings::getGamemode() const {
-    return this->gamemode;
-}
-
-int Settings::getWindowSizeMultiplier() const {
-    return WINDOW_SIZE_MULTIPLIERS[this->windowSizeMode];
-}
-
-const sf::VideoMode Settings::getVideoMode() const {
-    return sf::VideoMode(BASE_WINDOW_SIZE * (unsigned int) WINDOW_SIZE_MULTIPLIERS[this->windowSizeMode]);
-}
-
-const std::vector<std::pair<PiecesType, int>>& Settings::getSelectedPieces() const {
-    return this->selectedPieces;
-}

src/GraphicalUI/Settings.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include "../Core/Menu.h"
-#include "Keybinds.h"
-#include "PiecesType.h"
-
-#include <SFML/Graphics.hpp>
-#include <vector>
-
-static const int MAXIMUM_BOARD_WIDTH = 40;
-static const int MAXIMUM_BOARD_HEIGHT = 40;
-
-//#define __JMINOS_RELEASE__
-#ifdef __JMINOS_RELEASE__
-static const int MAXIMUM_PIECES_SIZE = 15;
-#else
-static const int MAXIMUM_PIECES_SIZE = 10;
-#endif
-
-
-class Settings {
-    private:
-        Menu menu;
-        std::vector<Keybinds> keybinds;
-        int chosenKeybinds;
-        Gamemode gamemode;
-        int windowSizeMode;
-        std::vector<std::pair<PiecesType, int>> selectedPieces;
-
-    public:
-        Settings();
-
-        void loadSettingsFromFile();
-
-        void saveSettingsToFile() const;
-
-        bool selectNextKeybinds();
-
-        bool selectPreviousKeybinds();
-
-        bool canModifyCurrentKeybinds() const;
-
-        void setGamemode(Gamemode gamemode);
-
-        bool widenWindow();
-
-        bool shortenWindow();
-
-        void selectPieces(PiecesType type, int value);
-
-        void unselectPieces(int index);
-
-        void confirmSelectedPieces();
-
-        Menu& getMenu();
-
-        Keybinds& getKeybinds();
-
-        Gamemode getGamemode() const;
-
-        int getWindowSizeMultiplier() const;
-
-        const sf::VideoMode getVideoMode() const;
-
-        const std::vector<std::pair<PiecesType, int>>& getSelectedPieces() const;
-};

src/GraphicalUI/main.cpp

@@ -1,156 +0,0 @@
-#include "GraphApp.h"
-#include "../Pieces/PiecesFiles.h"
-
-#include <fstream>
-
-
-void resetConfigFiles();
-void resetSettingsFile();
-void resetKeybindFile(int layout);
-
-
-int main() {
-    std::srand(std::time(NULL));
-
-#ifndef __JMINOS_RELEASE__
-
-    PiecesFiles pf;
-    for (int i = 1; i <= MAXIMUM_PIECES_SIZE; i++) {
-        if (!std::filesystem::exists("data/pieces/" + std::to_string(i) + "minos.bin")) {
-            std::cout << "pieces files for size " << i << " not found, generating..." << std::endl;
-            pf.savePieces(i);
-        }
-    }
-    if (!std::filesystem::exists("data/config/settings.bin")) {
-        resetSettingsFile();
-    }
-    for (int i = 0; i < 5; i++) {
-        if (!std::filesystem::exists("data/config/keybinds/layout" + std::to_string(i) + ".bin")) {
-            resetKeybindFile(i);
-        }
-    }
-
-    // uncomment before compiling release version
-    //resetConfigFiles();
-
-#endif
-
-    GraphApp UI;
-    UI.run();
-
-    return 0;
-}
-
-
-void resetConfigFiles() {
-    resetSettingsFile;
-    for (int i = 0; i < 5; i++) {
-        resetKeybindFile(i);
-    }
-}
-
-void resetSettingsFile() {
-    std::ofstream settingsFile("data/config/settings.bin", std::ios::trunc | std::ios::binary);
-    char byte;
-
-    // keybind layout
-    byte = 0;
-    settingsFile.write(&byte, 1);
-
-    // window size mode
-    byte = 2;
-    settingsFile.write(&byte, 1);
-
-    // gamemode
-    byte = SPRINT;
-    settingsFile.write(&byte, 1);
-
-    // board width
-    byte = 10;
-    settingsFile.write(&byte, 1);
-
-    // board height
-    byte = 20;
-    settingsFile.write(&byte, 1);
-
-    // piece distribution
-    byte = 0;
-    settingsFile.write(&byte, 1);
-
-    // selected pieces
-    byte = ALL_PIECES;
-    settingsFile.write(&byte, 1);
-    byte = 4;
-    settingsFile.write(&byte, 1);
-}
-
-void resetKeybindFile(int layout) {
-    if (layout < 0 || layout > 4) return;
-
-    std::ofstream layoutFile("data/config/keybinds/layout" + std::to_string(layout) + ".bin", std::ios::trunc | std::ios::binary);
-    std::map<Action, sfKey> keybinds;
-
-    if (layout != 4) {
-        keybinds.insert({PAUSE, sfKey::P});
-        keybinds.insert({RETRY, sfKey::R});
-    }
-
-    if (layout == 0) {
-        keybinds.insert({MOVE_LEFT, sfKey::Left});
-        keybinds.insert({MOVE_RIGHT, sfKey::Right});
-        keybinds.insert({SOFT_DROP, sfKey::Down});
-        keybinds.insert({HARD_DROP, sfKey::Space});
-        keybinds.insert({ROTATE_CW, sfKey::Up});
-        keybinds.insert({ROTATE_CCW, sfKey::Z});
-        keybinds.insert({ROTATE_180, sfKey::X});
-        keybinds.insert({ROTATE_0, sfKey::LShift});
-        keybinds.insert({HOLD, sfKey::C});
-    }
-    if (layout == 1) {
-        keybinds.insert({MOVE_LEFT, sfKey::Z});
-        keybinds.insert({MOVE_RIGHT, sfKey::C});
-        keybinds.insert({SOFT_DROP, sfKey::X});
-        keybinds.insert({HARD_DROP, sfKey::S});
-        keybinds.insert({ROTATE_CW, sfKey::M});
-        keybinds.insert({ROTATE_CCW, sfKey::Comma});
-        keybinds.insert({ROTATE_180, sfKey::J});
-        keybinds.insert({ROTATE_0, sfKey::K});
-        keybinds.insert({HOLD, sfKey::LShift});
-    }
-    if (layout == 2) {
-        keybinds.insert({MOVE_LEFT, sfKey::A});
-        keybinds.insert({MOVE_RIGHT, sfKey::D});
-        keybinds.insert({SOFT_DROP, sfKey::W});
-        keybinds.insert({HARD_DROP, sfKey::S});
-        keybinds.insert({ROTATE_CW, sfKey::Left});
-        keybinds.insert({ROTATE_CCW, sfKey::Right});
-        keybinds.insert({ROTATE_180, sfKey::Up});
-        keybinds.insert({ROTATE_0, sfKey::Down});
-        keybinds.insert({HOLD, sfKey::RShift});
-    }
-    if (layout == 3) {
-        keybinds.insert({MOVE_LEFT, sfKey::Left});
-        keybinds.insert({MOVE_RIGHT, sfKey::Right});
-        keybinds.insert({SOFT_DROP, sfKey::Down});
-        keybinds.insert({HARD_DROP, sfKey::Up});
-        keybinds.insert({ROTATE_CW, sfKey::E});
-        keybinds.insert({ROTATE_CCW, sfKey::A});
-        keybinds.insert({ROTATE_180, sfKey::Num2});
-        keybinds.insert({ROTATE_0, sfKey::Tab});
-        keybinds.insert({HOLD, sfKey::Z});
-    }
-
-    char byte;
-    for (Action action : ACTION_LIST_IN_ORDER) {
-        byte = action;
-        layoutFile.write(&byte, 1);
-
-        if (keybinds.contains(action)) {
-            byte = (int) keybinds.at(action);
-            layoutFile.write(&byte, 1);
-        }
-        
-        byte = 0xFF;
-        layoutFile.write(&byte, 1);
-    }
-}

src/Pieces/Block.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <string>
-
-
-/**
- * Every possible block type
- */
-enum Block {
-    NOTHING,
-    OUT_OF_BOUNDS,
-    GARBAGE,
-    PURPLE,
-    ORANGE,
-    CYAN,
-    PINK,
-    YELLOW,
-    RED,
-    BLUE,
-    GREEN
-};
-
-
-/**
- * Gets the first block type a piece can be
- * @return The block type
- */
-inline Block firstPieceBlockType() {
-    return Block(PURPLE);
-}
-
-/**
- * Sets the block to the next available piece block type
- */
-inline void nextPieceBlockType(Block& block) {
-    block = (block == GREEN) ? PURPLE : Block(block + 1);
-}

src/Pieces/Cell.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <iostream>
+
+
+/**
+ * A cell on a 2D grid
+ */
+struct Cell {
+    int x; // x position
+    int y; // y position
+};
+
+
+/**
+ * Addition operator, returns the sums of the coordinates of both cells
+ */
+inline Cell operator+(const Cell& left, const Cell& right) {
+    return Cell{left.x + right.x, left.y + right.y};
+}
+
+/**
+ * Additive assignation operator, adds the coordinates of the right cell to the left one
+ */
+inline Cell& operator+=(Cell& left, const Cell& right) {
+    left = left + right;
+    return left;
+}
+
+/**
+ * Substraction operator, returns the difference of the coordinate between the left and right cell
+ */
+inline Cell operator-(const Cell& left, const Cell& right) {
+    return Cell{left.x - right.x, left.y - right.y};
+
+}
+
+/**
+ * Substractive assignation operator, substract the coordinates of the right cell from the left one
+ */
+inline Cell& operator-=(Cell& left, const Cell& right) {
+    left = left - right;
+    return left;
+}
+
+/**
+ * Strict inferiority operator, a cell is inferior to another if it is lower or at the same height and more to the left
+ */
+inline bool operator<(const Cell& left, const Cell& right) {
+    return (left.x == right.x) ? (left.y < right.y) : (left.x < right.x);
+}
+
+/**
+ * Equality operator, two cells are equal if they have the same coordinates
+ */
+inline bool operator==(const Cell& left, const Cell& right) {
+    return (left.x == right.x) && (left.y == right.y);
+}
+
+/**
+ * Stream output operator, adds the coordinates of the cell to the stream
+ */
+inline std::ostream& operator<<(std::ostream& os, const Cell& cell) {
+    os << "x: " << cell.x << " y: " << cell.y;
+    return os;
+}

src/Pieces/Color.cpp

@@ -0,0 +1,38 @@
+#include "Color.h"
+
+static const Color C_NOTHING = {255, 255, 255};
+static const Color C_OUT_OF_BOUNDS = C_NOTHING;
+static const Color C_GARBAGE = {150, 150, 150};
+static const Color C_PURPLE = {150, 0, 255};
+static const Color C_ORANGE = {255, 150, 0};
+static const Color C_CYAN = {0, 255, 0};
+static const Color C_PINK = {255, 0, 200};
+static const Color C_YELLOW = {255, 255, 0};
+static const Color C_RED = {255, 0, 0};
+static const Color C_BLUE = {0, 100, 255};
+static const Color C_GREEN = {0, 255, 0};
+
+static const Color colors[] = {
+	C_NOTHING,
+    C_OUT_OF_BOUNDS,
+    C_GARBAGE,
+    C_PURPLE,
+    C_ORANGE,
+    C_CYAN,
+    C_PINK,
+    C_YELLOW,
+    C_RED,
+    C_BLUE,
+    C_GREEN
+};
+
+const Color& getColor(ColorEnum color) {
+	return colors[color];
+}
+
+void setNextPieceColor(ColorEnum& color) {
+    if (color == GREEN)
+        color = PURPLE;
+    else
+        color = ColorEnum(color + 1);
+}

src/Pieces/Color.h

@@ -1,55 +1,48 @@
 #pragma once
 
-#include "Block.h"
-
-#include "string"
-
+#include <string>
 
 /**
- * A color encoded in RGB
+ * Every possible colors a block can take
  */
+enum ColorEnum {
+    NOTHING,
+    OUT_OF_BOUNDS,
+    GARBAGE,
+    PURPLE,
+    ORANGE,
+    CYAN,
+    PINK,
+    YELLOW,
+    RED,
+    BLUE,
+    GREEN
+};
+
 struct Color {
-    unsigned char red;   // the red component of the color
-    unsigned char green; // the green component of the color
-    unsigned char blue;  // the blue component of the color
-};
-
-
-static const Color EMPTY_BLOCK_COLOR = {255, 255, 255}; // color of an empty block
-static const Color BLOCKS_COLOR[] = {                   // color for each block type
-    EMPTY_BLOCK_COLOR, // NOTHING
-    EMPTY_BLOCK_COLOR, // OUT_OF_BOUNDS
-    {150, 150, 150},   // GARBAGE
-    {150, 0, 255},     // PURPLE
-    {255, 150, 0},     // ORANGE
-    {0, 255, 255},     // CYAN
-    {255, 0, 200},     // PINK
-    {255, 255, 0},     // YELLOW
-    {255, 0, 0},       // RED
-    {0, 100, 255},     // BLUE
-    {0, 255, 0}        // GREEN
+    std::uint8_t r;
+    std::uint8_t g;
+    std::uint8_t b;
 };
 
 /**
- * Translates the color into a color code to change the console's color
- * @return A string to print in the console
+ * Returns the first color a piece can take
  */
-inline std::string getConsoleColorCode(const Color& color) {
-    return "\033[38;2;" + std::to_string(color.red) + ";" + std::to_string(color.green) + ";" + std::to_string(color.blue) + "m";
+inline ColorEnum firstPieceColor() {
+    return PURPLE;
 }
 
-/**
- * Translates the color into a color code to change the console's color
- * @return A string to print in the console
- */
-inline std::string getConsoleColorCode(const Block block) {
-    return getConsoleColorCode(BLOCKS_COLOR[block]);
-}
+const Color& getColor(ColorEnum color);
 
 /**
- * Gets a color code to reset the console's color
- * @return A string to print in the console
+ * Sets the color to the next available piece color
  */
-inline std::string getResetConsoleColorCode() {
-    return getConsoleColorCode(EMPTY_BLOCK_COLOR);
+void setNextPieceColor(ColorEnum& color);
+
+inline std::string getColorCode(const Color& color) {
+    return "\033[38;2;" + std::to_string(color.r) + ";" + std::to_string(color.g) + ";" + std::to_string(color.b) + "m";
 }
+
+inline std::string getColorCode(ColorEnum color) {
+    return getColorCode(color);
+}

src/Pieces/Generator.cpp

@@ -11,29 +11,31 @@
 Generator::Generator() {
 }
 
-std::vector<Polyomino> Generator::generatePolyominoes(int polyominoSize) {
-    this->validPolyominoes.clear();
+std::vector<Polyomino> Generator::generatePolyominos(unsigned int order) {
+    // initialization
+    this->validPolyominos.clear();
     this->currentTestedShape.clear();
 
-    // a polyomino has at least 1 square
-    if (polyominoSize < 1) return this->validPolyominoes;
+    // no polyomino with 0 cells
+    if (order == 0) return this->validPolyominos;
 
-    // always place the first cell at (0, 0)
-    this->currentTestedShape.insert(Position{0, 0});
+    // start generating from the monomino
+    this->currentTestedShape.insert(Cell{0, 0});
     
-    std::map<Position, int> candidatePositions;
-    this->generate(polyominoSize, 0, 1, candidatePositions);
-    return this->validPolyominoes;
+    // generate polyominos
+    std::map<Cell, int> candidateCells;
+    this->generate(order, 0, 1, candidateCells);
+    return this->validPolyominos;
 }
 
-void Generator::generate(int polyominoSize, int lastAddedPositionNumber, int nextAvaibleNumber, std::map<Position, int> candidatePositions) {
+void Generator::generate(unsigned int order, int lastAddedCellNumber, int nextAvaibleNumber, std::map<Cell, int> candidateCells) {
     // recursion stop
-    if (polyominoSize == this->currentTestedShape.size()) {
+    if (order == this->currentTestedShape.size()) {
+        // we test the polyomino formed by the current shape
         Polyomino candidate(this->currentTestedShape);
 
-        // we sort the rotations of the polyominoes
+        // we sort the rotations of the polyominos
         std::vector<Polyomino> candidateRotations;
-        candidateRotations.reserve(4);
         for (int i = 0; i < 4; i++) {
             candidate.normalize();
             candidateRotations.push_back(candidate);
@@ -43,41 +45,41 @@ void Generator::generate(int polyominoSize, int lastAddedPositionNumber, int nex
 
         // we keep the polyomino only if it was generated in its lowest rotation
         if (candidate == candidateRotations.at(0)) {
-            this->validPolyominoes.push_back(candidate);
+            this->validPolyominos.push_back(candidate);
         }
 
         return;
     }
 
-    // generate the list of candidate positions
-    for (Position position : this->currentTestedShape) {
-        this->tryToAddCandidatePosition(Position{position.x, position.y + 1}, nextAvaibleNumber, candidatePositions);
-        this->tryToAddCandidatePosition(Position{position.x + 1, position.y}, nextAvaibleNumber, candidatePositions);
-        this->tryToAddCandidatePosition(Position{position.x, position.y - 1}, nextAvaibleNumber, candidatePositions);
-        this->tryToAddCandidatePosition(Position{position.x - 1, position.y}, nextAvaibleNumber, candidatePositions);
+    // generate the list of candidate cells
+    for (Cell cell : this->currentTestedShape) {
+        this->tryToAddCandidateCell(Cell{cell.x, cell.y + 1}, nextAvaibleNumber, candidateCells);
+        this->tryToAddCandidateCell(Cell{cell.x + 1, cell.y}, nextAvaibleNumber, candidateCells);
+        this->tryToAddCandidateCell(Cell{cell.x, cell.y - 1}, nextAvaibleNumber, candidateCells);
+        this->tryToAddCandidateCell(Cell{cell.x - 1, cell.y}, nextAvaibleNumber, candidateCells);
     }
     
-    // try adding a square only to positions with a higher number than the last one
-    for (auto [key, val] : candidatePositions) {
-        if (val > lastAddedPositionNumber) {
+    // generate polyominos for all cells with a higher number than the last one
+    for (auto [key, val] : candidateCells) {
+        if (val > lastAddedCellNumber) {
             this->currentTestedShape.insert(key);
-            this->generate(polyominoSize, val, nextAvaibleNumber, (polyominoSize == this->currentTestedShape.size()) ? std::map<Position, int>() : candidatePositions);
+            this->generate(order, val, nextAvaibleNumber, (order == this->currentTestedShape.size()) ? std::map<Cell, int>() : candidateCells);
             this->currentTestedShape.erase(key);
         }
     }
 }
 
-void Generator::tryToAddCandidatePosition(const Position& candidate, int& nextAvaibleNumber, std::map<Position, int>& candidatepositions) {
-    // we declared the first position as the lower-left square, since we always start with a monomino at (0,0) we can test with 0 directly
+void Generator::tryToAddCandidateCell(const Cell& candidate, int& nextAvaibleNumber, std::map<Cell, int>& candidateCells) {
+    // we declared the first cell as the lower-left square, since we always start with a monomino at (0,0) we can test with hard values
     if (candidate.y < 0 || (candidate.y == 0 && candidate.x < 0)) return;
 
-    // if the position was already marked then we should not mark it again
-    if (candidatepositions.contains(candidate)) return;
+    // if the cell was already marked then we should not mark it again
+    if (candidateCells.contains(candidate)) return;
 
     // if the candidate overlaps with the shape there is no reason to add it
     if (this->currentTestedShape.contains(candidate)) return;
 
-    // once all tests passed we can add the position
-    candidatepositions.insert({candidate, nextAvaibleNumber});
+    // once all tests passed we can add the cell
+    candidateCells.insert({candidate, nextAvaibleNumber});
     nextAvaibleNumber++;
 }

src/Pieces/Generator.h

@@ -8,33 +8,32 @@
 
 
 /**
- * A generator of one-sided polyominoes of any size
+ * A generator of one-sided polyominos of any size
  */
 class Generator {
     private:
-        std::vector<Polyomino> validPolyominoes; // the list of already generated polyominoes
-        std::set<Position> currentTestedShape;  // the polyomino being created
+        std::vector<Polyomino> validPolyominos; // the list of already generated polyominos
+        std::set<Cell> currentTestedShape; // the polyomino being created
 
     public:
         /**
-         * Default constructor
+         * Initializes generator
          */
         Generator();
         
         /**
-         * Generates the list of all one-sided polyominoes of the specified size
-         * @return The list of polyominoes
+         * Returns the list of all one-sided polyominos of the specified size
          */
-        std::vector<Polyomino> generatePolyominoes(int polyominoSize);
+        std::vector<Polyomino> generatePolyominos(unsigned int order);
 
     private:
         /**
-         * Generates all one-sided polyominoes of the specified size using the current tested shape
+         * Generates all one-sided polyominos of the specified using the current tested shape
          */
-        void generate(int polyominoSize, int lastAddedPositionNumber, int nextAvaibleNumber, std::map<Position, int> candidatePositions);
+        void generate(unsigned int order, int lastAddedCellNumber, int nextAvaibleNumber, std::map<Cell, int> candidateCells);
 
         /**
-         * Checks wheter a candidate position can be added to the current tested shape
+         * Check wheter a candidate cell can be added to the current tested shape
          */
-        void tryToAddCandidatePosition(const Position& candidate, int& nextAvaibleNumber, std::map<Position, int>& candidatePositions);
+        void tryToAddCandidateCell(const Cell& candidate, int& nextAvaibleNumber, std::map<Cell, int>& candidateCells);
 };

src/Pieces/Piece.cpp

@@ -2,18 +2,13 @@
 
 #include "Polyomino.h"
 #include "Rotation.h"
-#include "Block.h"
 #include "Color.h"
 
 #include <set>
 #include <string>
 
 
-Piece::Piece(const Polyomino& polyomino, Block blockType) :
-    polyomino(polyomino),
-    blockType(blockType) {
-
-    this->rotationState = NONE;
+Piece::Piece(const Polyomino& polyomino, ColorEnum color) : polyomino(polyomino), color(color) {
 }
 
 void Piece::rotate(Rotation rotation) {
@@ -23,34 +18,21 @@ void Piece::rotate(Rotation rotation) {
         this->polyomino.rotate180();
     if (rotation == COUNTERCLOCKWISE)
         this->polyomino.rotateCCW();
-    
-    this->rotationState += rotation;
 }
 
-void Piece::defaultRotation() {
-    if (this->rotationState == CLOCKWISE)
-        this->polyomino.rotateCCW();
-    if (this->rotationState == DOUBLE)
-        this->polyomino.rotate180();
-    if (this->rotationState == COUNTERCLOCKWISE)
-        this->polyomino.rotateCW();
-
-    this->rotationState = NONE;
-}
-
-const std::set<Position>& Piece::getPositions() const {
-    return this->polyomino.getPositions();
+std::set<Cell> Piece::getPositions() const {
+    return this->polyomino.getCells();
 }
 
 int Piece::getLength() const {
     return this->polyomino.getLength();
 }
 
-Block Piece::getBlockType() const {
-    return this->blockType;
+ColorEnum Piece::getColor() const {
+    return this->color;
 }
 
 std::ostream& operator<<(std::ostream& os, const Piece& piece) {
-    os << getConsoleColorCode(piece.blockType) << piece.polyomino << getResetConsoleColorCode();
+    os << getColorCode(piece.color) << piece.polyomino << getColorCode(NOTHING);
     return os;
 }

src/Pieces/Piece.h

@@ -2,7 +2,6 @@
 
 #include "Polyomino.h"
 #include "Rotation.h"
-#include "Block.h"
 #include "Color.h"
 
 #include <set>
@@ -13,15 +12,14 @@
  */
 class Piece {
     private:
-        Polyomino polyomino;    // a polyomino representing the piece, (0, 0) is downleft
-        Block blockType;        // the block type of the piece
-        Rotation rotationState; // the current rotation of the piece
+        Polyomino polyomino; // a polyomino representing the piece, (0, 0) is downleft
+        ColorEnum color; // the color of the piece
 
     public:
         /**
-         * Creates a piece with a specified shape and block type
+         * Creates a piece with a specified shape and color
          */
-        Piece(const Polyomino& piece, Block blockType);
+        Piece(const Polyomino& piece, ColorEnum color);
 
         /**
          * Rotates the piece in the specified direction
@@ -29,28 +27,22 @@ class Piece {
         void rotate(Rotation rotation);
 
         /**
-         * Rotates the piece to its default rotation
+         * Returns a copy of the list of cells of the piece
          */
-        void defaultRotation();
+        std::set<Cell> getPositions() const;
 
         /**
-         * @return The list of positions of the piece
-         */
-        const std::set<Position>& getPositions() const;
-
-        /**
-         * @return The length of the piece
+         * Returns the length of the piece
          */
         int getLength() const;
 
         /**
-         * @return The block type of the piece
+         * Returns the color of the piece
          */
-        Block getBlockType() const;
+        ColorEnum getColor() const;
 
         /**
          * Stream output operator, adds a 2D grid representing the piece
-         * @return A reference to the output stream
          */
         friend std::ostream& operator<<(std::ostream& os, const Piece& piece);
 };

src/Pieces/PiecesFiles.cpp

@@ -14,9 +14,10 @@
 PiecesFiles::PiecesFiles() {
 }
 
-bool PiecesFiles::savePieces(int polyominoSize) const {
+bool PiecesFiles::savePieces(int order) const {
+    // open pieces file
     std::string filePath;
-    if (!this->getFilePath(polyominoSize, filePath)) {
+    if (!this->getFilePath(order, filePath)) {
         return false;
     }
     std::ofstream piecesFile(filePath, std::ios::trunc | std::ios::binary);
@@ -24,34 +25,47 @@ bool PiecesFiles::savePieces(int polyominoSize) const {
         return false;
     }
 
+    // generates the polyominos
     Generator generator;
-    std::vector<Polyomino> nMinos = generator.generatePolyominoes(polyominoSize);
+    std::vector<Polyomino> nMinos = generator.generatePolyominos(order);
 
-    // sorting the polyominoes is done after setting spawn position to ensure the order is always the same
+    // set the polyominos to their spawn position
     for (Polyomino& nMino : nMinos) {
         nMino.goToSpawnPosition();
     }
+    
+    // sort the polyominos, is done after setting spawn position to ensure the order is always the same
     std::sort(nMinos.begin(), nMinos.end());
-
+    
+    // write pieces
+    ColorEnum pieceColor = firstPieceColor();
+    for (int i = 0; i < order; i++) 
+        setNextPieceColor(pieceColor);
     for (const Polyomino& nMino : nMinos) {
-        // write the characteristics of the piece
-        char infoByte = (nMino.isConvex() << 7) + (nMino.hasHole() << 6) + nMino.getLength();
+        // write polyomino length
+        char lengthByte = nMino.getLength();
+        piecesFile.write(&lengthByte, 1);
+
+        // write the type and color of the piece
+        char infoByte = (nMino.isConvex() << 7) + (nMino.hasHole() << 6) + pieceColor;
+        setNextPieceColor(pieceColor);
         piecesFile.write(&infoByte, 1);
 
-        // write the positions of the piece
-        char positionByte;
-        for (Position position : nMino.getPositions()) {
-            positionByte = (position.x << 4) + position.y;
-            piecesFile.write(&positionByte, 1);
+        // write the cells of the piece
+        char cellByte;
+        for (Cell cell : nMino.getCells()) {
+            cellByte = (cell.x << 4) + cell.y;
+            piecesFile.write(&cellByte, 1);
         }
     }
 
     return true;
 }
 
-bool PiecesFiles::loadPieces(int polyominoSize, std::vector<Piece>& pieces, std::vector<int>& convexPieces, std::vector<int>& holelessPieces, std::vector<int>& otherPieces) const {
+bool PiecesFiles::loadPieces(int order, std::vector<Piece>& pieces, std::vector<int>& convexPieces, std::vector<int>& holelessPieces, std::vector<int>& otherPieces) const {
+    // open pieces file
     std::string filePath;
-    if (!this->getFilePath(polyominoSize, filePath)) {
+    if (!this->getFilePath(order, filePath)) {
         return false;
     }
     std::ifstream piecesFile(filePath, std::ios::binary);
@@ -59,48 +73,47 @@ bool PiecesFiles::loadPieces(int polyominoSize, std::vector<Piece>& pieces, std:
         return false;
     }
 
+    // get empty vectors
     pieces.clear();
     convexPieces.clear();
     holelessPieces.clear();
     otherPieces.clear();
 
-    // we shift the first color of each size so that the small polyominoes (size 1-2-3) don't all have the same color
-    Block pieceBlock = firstPieceBlockType();
-    for (int i = 0; i < polyominoSize; i++) {
-        nextPieceBlockType(pieceBlock);
-    }
-
+    // set up masks
     char convexMask = 0b1000'0000;
     char holeMask = 0b0100'0000;
-    char lengthMask = 0b0011'1111;
+    char colorMask = 0b0011'1111;
     char xMask = 0b1111'0000;
     char yMask = 0b0000'1111;
 
-    char infoByte;
+    // read the pieces
+    char lengthByte;
     int i = 0;
-    while (piecesFile.get(infoByte)) {
+    while (piecesFile.get(lengthByte)) {
         if (piecesFile.eof()) break;
-
+        
         // read piece infos
+        char infoByte;
+        piecesFile.get(infoByte);
         bool isConvex = (infoByte & convexMask) >> 7;
         bool hasHole = (infoByte & holeMask) >> 6;
-        int length = (infoByte & lengthMask);
+        ColorEnum color = ColorEnum(infoByte & colorMask);
 
-        // read positions
-        std::set<Position> piecePositions;
-        char positionByte;
-        for (int i = 0; i < polyominoSize; i++) {
-            piecesFile.get(positionByte);
-            int x = (positionByte & xMask) >> 4;
-            int y = positionByte & yMask;
-            piecePositions.insert(Position{x, y});
+        // read cells
+        std::set<Cell> pieceCells;
+        char cellByte;
+        for (int i = 0; i < order; i++) {
+            piecesFile.get(cellByte);
+            int x = (cellByte & xMask) >> 4;
+            int y = cellByte & yMask;
+            pieceCells.insert(Cell{x, y});
         }
 
         // create piece
-        Piece readPiece(Polyomino(piecePositions, length), pieceBlock);
-        nextPieceBlockType(pieceBlock);
-        
+        Piece readPiece(Polyomino(pieceCells, lengthByte), color);
         pieces.push_back(readPiece);
+
+        // link it to its type
         if (isConvex) {
             convexPieces.push_back(i);
         }
@@ -117,12 +130,14 @@ bool PiecesFiles::loadPieces(int polyominoSize, std::vector<Piece>& pieces, std:
     return true;
 }
 
-bool PiecesFiles::getFilePath(int polyominoSize, std::string& filePath) const {
+bool PiecesFiles::getFilePath(int order, std::string& filePath) const {
+    // verify that the data folder exists
     std::string dataFolderPath = "data/pieces/";
     if (!std::filesystem::is_directory(dataFolderPath)) {
         return false;
     }
 
-    filePath = dataFolderPath + std::to_string(polyominoSize) + "minos.bin";
+    // return the file path
+    filePath = dataFolderPath + std::to_string(order) + "minos.bin";
     return true;
 }

src/Pieces/PiecesFiles.h

@@ -12,26 +12,26 @@
 class PiecesFiles {
     public:
         /**
-         * Default constructor
+         * Initializes file manager
          */
         PiecesFiles();
 
         /**
-         * Generate a file containing all the pieces of the specified size
-         * @return If the file could be created
+         * Generate a file containing all the pieces of the specified size,
+         * returns false if the file couldn't be created
          */
-        bool savePieces(int polyominoSize) const;
+        bool savePieces(int order) 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
+         * Replace the content of the vectors by the pieces of the specified size, if the file wasn't found the vectors stays untouched,
+         * returns false if the file wasn't found
          */
-        bool loadPieces(int polyominoSize, std::vector<Piece>& pieces, std::vector<int>& convexPieces, std::vector<int>& holelessPieces, std::vector<int>& otherPieces) const;
+        bool loadPieces(int order, 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
+         * Puts the path to the piece file of the specified size in order, if the data folder wasn't found the string stays untouched,
+         * returns false if the data folder wasn't found
          */
-        bool getFilePath(int polyominoSize, std::string& filePath) const;
+        bool getFilePath(int order, std::string& filePath) const;
 };

src/Pieces/Polyomino.cpp

@@ -1,85 +1,88 @@
 #include "Polyomino.h"
 
-#include "Position.h"
+#include "Cell.h"
 
 #include <vector>
 #include <set>
 #include <iostream>
 #include <climits>
 #include <algorithm>
-#include <utility>
 
 
-Polyomino::Polyomino(const std::set<Position>& positions) {
+Polyomino::Polyomino(const std::set<Cell>& cells) {
+    // find min/max
     int minX = INT_MAX;
     int maxX = INT_MIN;
     int minY = INT_MAX;
     int maxY = INT_MIN;
-    for (Position position : positions) {
-        if (position.x < minX) minX = position.x;
-        if (position.x > maxX) maxX = position.x;
-        if (position.y < minY) minY = position.y;
-        if (position.y > maxY) maxY = position.y;
+    for (Cell cell : cells) {
+        if (cell.x < minX) minX = cell.x;
+        if (cell.x > maxX) maxX = cell.x;
+        if (cell.y < minY) minY = cell.y;
+        if (cell.y > maxY) maxY = cell.y;
     }
 
+    // normalize
+    std::set<Cell> newCells;
+    for (Cell cell : cells) {
+        newCells.insert(Cell{cell.x - minX, cell.y - minY});
+    }
+    this->cells = newCells;
+
+    // set polyomino length
     this->length = std::max(maxX - minX + 1, maxY - minY + 1);
-
-    // we normalize here instead of calling this->normalize() to reduce the number of calculations for the generation algorithm
-    std::set<Position> newPositions;
-    for (Position position : positions) {
-        newPositions.insert(Position{position.x - minX, position.y - minY});
-    }
-    this->positions = std::move(newPositions);
 }
 
-Polyomino::Polyomino(const std::set<Position>& positions, int length) :
-    positions(positions),
-    length(length) {
+Polyomino::Polyomino(const std::set<Cell>& cells, int length) : cells(cells), length(length) {
 }
 
 void Polyomino::normalize() {
+    // find min values
     int minX = INT_MAX;
     int minY = INT_MAX;
-    for (Position position : this->positions) {
-        if (position.x < minX) minX = position.x;
-        if (position.y < minY) minY = position.y;
+    for (Cell cell : this->cells) {
+        if (cell.x < minX) minX = cell.x;
+        if (cell.y < minY) minY = cell.y;
     }
 
-    std::set<Position> newPositions;
-    for (Position position : this->positions) {
-        newPositions.insert(Position{position.x - minX, position.y - minY});
+    // translate the polyomino to the lowest unsigned values
+    std::set<Cell> newCells;
+    for (Cell cell : this->cells) {
+        newCells.insert(Cell{cell.x - minX, cell.y - minY});
     }
-    this->positions = std::move(newPositions);
+    this->cells = newCells;
 }
 
 void Polyomino::rotateCW() {
-    std::set<Position> newPositions;
-    for (Position position : this->positions) {
-        newPositions.insert(Position{position.y, (length - 1) - (position.x)});
+    // rotate 90° clockwise
+    std::set<Cell> newCells;
+    for (Cell cell : this->cells) {
+        newCells.insert(Cell{cell.y, (length - 1) - (cell.x)});
     }
-    this->positions = std::move(newPositions);
+    this->cells = newCells;
 }
 
 void Polyomino::rotate180() {
-    std::set<Position> newPositions;
-    for (Position position : this->positions) {
-        newPositions.insert(Position{(length - 1) - (position.x), (length - 1) - (position.y)});
+    // rotate 180°
+    std::set<Cell> newCells;
+    for (Cell cell : this->cells) {
+        newCells.insert(Cell{(length - 1) - (cell.x), (length - 1) - (cell.y)});
     }
-    this->positions = std::move(newPositions);
+    this->cells = newCells;
 }
 
 void Polyomino::rotateCCW() {
-    std::set<Position> newPositions;
-    for (Position position : this->positions) {
-        newPositions.insert(Position{(length - 1) - (position.y), position.x});
+    // rotate 90° counter-clockwise
+    std::set<Cell> newCells;
+    for (Cell cell : this->cells) {
+        newCells.insert(Cell{(length - 1) - (cell.y), cell.x});
     }
-    this->positions = std::move(newPositions);
+    this->cells = newCells;
 }
 
 void Polyomino::goToSpawnPosition() {
     // initialize array
     std::vector<std::vector<int>> linesCompleteness;
-    linesCompleteness.reserve(4);
     std::vector<int> empty;
     for (int j = 0; j < this->length; j++) {
         empty.push_back(0);
@@ -88,23 +91,23 @@ void Polyomino::goToSpawnPosition() {
         linesCompleteness.push_back(empty);
     }
 
-    // calculates amount of squares per rows and columns
-    for (Position position : this->positions) {
-        linesCompleteness.at(0).at(position.y) += 1;                // 0 = bottom to top = no rotation
-        linesCompleteness.at(1).at((length - 1) - position.x) += 1; // 1 = right to left = CW
-        linesCompleteness.at(2).at((length - 1) - position.y) += 1; // 2 = top to bottom = 180
-        linesCompleteness.at(3).at(position.x) += 1;                // 3 = left to right = CCW
+    // calculates amount of cells per rows and columns
+    for (Cell cell : this->cells) {
+        linesCompleteness.at(0).at(cell.y) += 1; // 0 = bottom to top = no rotation
+        linesCompleteness.at(1).at((length - 1) - cell.x) += 1; // 1 = right to left = CW
+        linesCompleteness.at(2).at((length - 1) - cell.y) += 1; // 2 = top to bottom = 180
+        linesCompleteness.at(3).at(cell.x) += 1; // 3 = left to right = CCW
     }
 
-    // count empty lines and push the non-empty lines to the start of each vector
+    // checks for empty lines
     int horizontalEmptyLines = 0;
     int verticalEmptyLines = 0;
     for (int i = 0; i < 4; i++) {
         for (int j = this->length - 1; j >= 0; j--) {
             if (linesCompleteness.at(i).at(j) == 0) {
+                // push the non-empty lines to the start of each vector
                 linesCompleteness.at(i).erase(linesCompleteness.at(i).begin() + j);
                 linesCompleteness.at(i).push_back(0);
-
                 if (i == 0) horizontalEmptyLines++;
                 if (i == 1) verticalEmptyLines++;
             }
@@ -122,11 +125,11 @@ void Polyomino::goToSpawnPosition() {
         currentFlattestSides[3] = false;
     }
 
-    // checks for the flattest side
+    // checks for the flattest sides
     int sideToBeOn = -1;
     this->checkForFlattestSide(linesCompleteness, currentFlattestSides, sideToBeOn, false);
 
-    // if ther's no winner, checks for the side which has the flattest side to its left
+    // if all sides are as flat, checks for the most left-biased side
     if (sideToBeOn == -1) {
         this->checkForFlattestSide(linesCompleteness, currentFlattestSides, sideToBeOn, true);
     }
@@ -146,44 +149,47 @@ void Polyomino::goToSpawnPosition() {
         sideToBeOn = candidateSides.at(std::distance(candidateRotations.begin(), std::min_element(candidateRotations.begin(), candidateRotations.end())));
     }
     
-    switch (sideToBeOn) {
-        case 1 : {this->rotateCW(); break;}
-        case 2 : {this->rotate180(); break;}
-        case 3 : {this->rotateCCW(); break;}
-        default: break;
+    // do the correct rotation
+    if (sideToBeOn == 1) this->rotateCW();
+    if (sideToBeOn == 2) this->rotate180();
+    if (sideToBeOn == 3) this->rotateCCW();
+    
+    // find min
+    int minX = INT_MAX;
+    int minY = INT_MAX;
+    for (Cell cell : this->cells) {
+        if (cell.x < minX) minX = cell.x;
+        if (cell.y < minY) minY = cell.y;
     }
+
+    // center the piece with an up bias if it is assymetric
     if (sideToBeOn % 2 == 1) {
         std::swap(verticalEmptyLines, horizontalEmptyLines);
     }
-    
-    int minX = INT_MAX;
-    int minY = INT_MAX;
-    for (Position position : this->positions) {
-        if (position.x < minX) minX = position.x;
-        if (position.y < minY) minY = position.y;
+    std::set<Cell> newCells;
+    for (Cell cell : cells) {
+        newCells.insert(Cell{(cell.x - minX) + (verticalEmptyLines / 2), (cell.y - minY) + ((horizontalEmptyLines + 1) / 2)});
     }
-
-    // center the piece with an up bias
-    std::set<Position> newPositions;
-    for (Position position : positions) {
-        newPositions.insert(Position{(position.x - minX) + (verticalEmptyLines / 2), (position.y - minY) + ((horizontalEmptyLines + 1) / 2)});
-    }
-    this->positions = std::move(newPositions);
+    this->cells = newCells;
 }
 
 void Polyomino::checkForFlattestSide(const std::vector<std::vector<int>>& linesCompleteness, bool currentFlattestSides[4], int& sideToBeOn, bool checkLeftSide) const {
+    // for each line
     for (int j = 0; j < this->length; j++) {
-        // we check which sides are the flattest on this line
+        // we check which sides are the flattest
         int max = 0;
         std::set<int> maxOwners;
         for (int i = 0; i < 4; i++) {
+            // only the candidate sides are compared
             if (!currentFlattestSides[i]) continue;
 
+            // if we need to check the flatness of the side to the left
             int sideToCheck = i;
             if (checkLeftSide) {
                 sideToCheck = (i + 3) % 4;
             }
 
+            // we check which sides are the flattest
             if (linesCompleteness.at(sideToCheck).at(j) > max) {
                 max = linesCompleteness.at(sideToCheck).at(j);
                 maxOwners.clear();
@@ -194,13 +200,13 @@ void Polyomino::checkForFlattestSide(const std::vector<std::vector<int>>& linesC
             }
         }
 
-        // if there's no tie we choose the only side
+        // if there's no tie we choose this side
         if (maxOwners.size() == 1) {
             sideToBeOn = *maxOwners.begin();
             return;
         }
 
-        // else we only keep the flattest on this line and ignore the others
+        // else we only keep the flattest from this round and ignore the others
         else {
             for (int i = 0; i < 4; i++) {
                 currentFlattestSides[i] = currentFlattestSides[i] && maxOwners.contains(i);
@@ -210,21 +216,23 @@ void Polyomino::checkForFlattestSide(const std::vector<std::vector<int>>& linesC
 }
 
 bool Polyomino::isConvex() const {
+    // for each line and column we check if every cells are adjacent to each others
     for (int j = 0; j < this->length; j++) {
         bool startedLine = false;
         bool completedLine = false;
         bool startedColumn = false;
         bool completedColumn = false;
         for (int i = 0; i < this->length; i++) {
-            if (this->positions.contains(Position{i, j})) {
+            // line check
+            if (this->cells.contains(Cell{i, j})) {
                 if (completedLine) return false;
                 else startedLine = true;
             }
             else {
                 if (startedLine) completedLine = true;
             }
-
-            if (this->positions.contains(Position{j, i})) {
+            // column check
+            if (this->cells.contains(Cell{j, i})) {
                 if (completedColumn) return false;
                 else startedColumn = true;
             }
@@ -237,64 +245,71 @@ bool Polyomino::isConvex() const {
 }
 
 bool Polyomino::hasHole() const {
-    // add every empty square on the outer of the box containing the polyomino
-    std::set<Position> emptyPositions;
+    // add every outer cells of the square containing the polyomino
+    std::set<Cell> emptyCells;
     for (int i = 0; i < this->length - 1; i++) {
-        this->tryToInsertPosition(emptyPositions, Position{i, 0});                                   // up row
-        this->tryToInsertPosition(emptyPositions, Position{this->length - 1, i});                    // rigth column
-        this->tryToInsertPosition(emptyPositions, Position{this->length - 1 - i, this->length - 1}); // bottom row
-        this->tryToInsertPosition(emptyPositions, Position{0, this->length - 1 - i});                // left column
+        this->tryToInsertCell(emptyCells, Cell{i, 0}); // up row
+        this->tryToInsertCell(emptyCells, Cell{this->length - 1, i}); // rigth column
+        this->tryToInsertCell(emptyCells, Cell{this->length - 1 - i, this->length - 1}); // bottom row
+        this->tryToInsertCell(emptyCells, Cell{0, this->length - 1 - i}); // left column
     }
 
-    // if we didn't reached all empty squares in the box then there was some contained within the polyomino, i.e. there was a hole
-    return (emptyPositions.size() < (this->length * this->length) - this->positions.size());
+    // if we didn't reached all empty cells in the square then there was some contained within the polyomino, i.e. there was a hole
+    return (emptyCells.size() < (this->length * this->length) - this->cells.size());
 }
 
-void Polyomino::tryToInsertPosition(std::set<Position>& emptyPositions, const Position& candidate) const {
+void Polyomino::tryToInsertCell(std::set<Cell>& emptyCells, const Cell& candidate) const {
+    // check if the cell is in the square containing the polyomino
     if (candidate.x >= this->length || candidate.x < 0 || candidate.y >= this->length || candidate.y < 0) return;
-    if (this->positions.contains(candidate) || emptyPositions.contains(candidate)) return;
 
-    // if it's a new empty square, try its neighbors
-    emptyPositions.insert(candidate);
-    tryToInsertPosition(emptyPositions, Position{candidate.x, candidate.y + 1});
-    tryToInsertPosition(emptyPositions, Position{candidate.x + 1, candidate.y});
-    tryToInsertPosition(emptyPositions, Position{candidate.x, candidate.y - 1});
-    tryToInsertPosition(emptyPositions, Position{candidate.x - 1, candidate.y});
+    // check if the cell is empty and hasn't already been tested
+    if (this->cells.contains(candidate) || emptyCells.contains(candidate)) return;
+
+    // adds the cell to the list of empty cells and try its neighbors
+    emptyCells.insert(candidate);
+    tryToInsertCell(emptyCells, Cell{candidate.x, candidate.y + 1});
+    tryToInsertCell(emptyCells, Cell{candidate.x + 1, candidate.y});
+    tryToInsertCell(emptyCells, Cell{candidate.x, candidate.y - 1});
+    tryToInsertCell(emptyCells, Cell{candidate.x - 1, candidate.y});
 }
 
-const std::set<Position>& Polyomino::getPositions() const {
-    return this->positions;
+std::set<Cell> Polyomino::getCells() const {
+    return this->cells;
 }
 
 int Polyomino::getLength() const {
     return this->length;
 }
 
-int Polyomino::getPolyominoSize() const {
-    return this->positions.size();
+int Polyomino::getPolyominoOrder() const {
+    return this->cells.size();
 }
 
 bool Polyomino::operator<(const Polyomino& other) const {
+    // if one has an inferior length then it is deemed inferior
     if (this->length != other.length) return this->length < other.length;
 
+    // else we check for all cells from left to right and top to bottom, until one has a cell that the other doesn't
     for (int y = this->length - 1; y >= 0; y--) {
         for (int x = 0; x < this->length; x++) {
-            bool hasThisPosition = this->positions.contains(Position{x, y});
-            bool hasOtherPosition = other.positions.contains(Position{x, y});
-            if (hasThisPosition != hasOtherPosition) return hasThisPosition;
+            bool hasThisCell = this->cells.contains(Cell{x, y});
+            bool hasOtherCell = other.cells.contains(Cell{x, y});
+            if (hasThisCell != hasOtherCell) return hasThisCell;
         }
     }
+
+    // if they are equal
     return false;
 }
 
-bool Polyomino::operator==(const Polyomino& other) const {
-    return this->positions == other.positions;
+bool Polyomino::operator ==(const Polyomino& other) const {
+    return this->cells == other.cells;
 }
 
 std::ostream& operator<<(std::ostream& os, const Polyomino& polyomino) {
     for (int y = polyomino.length - 1; y >= 0; y--) {
         for (int x = 0; x < polyomino.length; x++) {
-            if (polyomino.positions.contains(Position{x, y})) {
+            if (polyomino.cells.contains(Cell{x, y})) {
                 os << "*";
             }
             else {

src/Pieces/Polyomino.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Position.h"
+#include "Cell.h"
 
 #include <vector>
 #include <set>
@@ -12,19 +12,19 @@
  */
 class Polyomino {
     private:
-        std::set<Position> positions; // the squares composing the polyomino, (0,0) is downleft
-        int length;                   // the size of the smallest square box in which the polyomino can fit on any rotation
+        std::set<Cell> cells; // the squares composing the polyomino, (0,0) is downleft
+        int length; // the size of the smallest square in which the polyomino can fit on any rotation
 
     public:
         /**
-         * Creates a polyomino with the specified positions and normalizes it, wheter it is actually a polyonimo is not checked
+         * Creates a polyomino with the specified cells and normalizes it, wheter it is actually a polyonimo is not checked
          */
-        Polyomino(const std::set<Position>& positions);
+        Polyomino(const std::set<Cell>& cells);
 
         /**
-         * Creates a polyomino with the specified positions and length, wheter it is actually a polyonimo of this length is not checked
+         * Creates a polyomino with the specified cells and length, wheter it is actually a polyonimo of this length is not checked
          */
-        Polyomino(const std::set<Position>& positions, int length);
+        Polyomino(const std::set<Cell>& cells, int length);
 
         /**
          * Translates the polyomino to the lowest unsigned values (lower row on y = 0, and left-most column on x = 0)
@@ -32,17 +32,17 @@ class Polyomino {
         void normalize();
 
         /**
-         * Rotates the polyomino 90° clockwise, the center of rotation being the middle of the box going from (0,0) to (length-1, length-1)
+         * Rotates the polyomino 90° clockwise, the center of rotation being the middle of the square going from (0,0) to (length-1, length-1)
          */
         void rotateCW();
 
         /**
-         * Rotates the polyomino 180°, the center of rotation being the middle of the box going from (0,0) to (length-1, length-1)
+         * Rotates the polyomino 180°, the center of rotation being the middle of the square going from (0,0) to (length-1, length-1)
          */
         void rotate180();
 
         /**
-         * Rotates the polyomino 90° counter-clockwise, the center of rotation being the middle of the box going from (0,0) to (length-1, length-1)
+         * Rotates the polyomino 90° counter-clockwise, the center of rotation being the middle of the square going from (0,0) to (length-1, length-1)
          */
         void rotateCCW();
 
@@ -59,14 +59,12 @@ class Polyomino {
 
     public:
         /**
-         * Check if the polyomino is convex, that is if every line and column has at most one continuous line of positions
-         * @return If the polyomino is convex
+         * Returns wheter the polyomino is convex, that is if every line and column has at most one continuous line of cells
          */
         bool isConvex() const;
 
         /**
-         * Check if the polyomino has at least one hole
-         * @return If the polyomino has at least one hole
+         * Returns wheter the polyomino has at least one hole
          */
         bool hasHole() const;
     
@@ -74,40 +72,37 @@ class Polyomino {
         /**
          * Auxiliary method of hasHole()
          */
-        void tryToInsertPosition(std::set<Position>& emptypositions, const Position& candidate) const;
+        void tryToInsertCell(std::set<Cell>& emptyCells, const Cell& candidate) const;
 
     public:
         /**
-         * @return The positions of the polyomino
+         * Returns a copy of the cells of the polyomino
          */
-        const std::set<Position>& getPositions() const;
+        std::set<Cell> getCells() const;
 
         /**
-         * @return The length of the polyomino
+         * Returns the length of the polyomino
          */
         int getLength() const;
 
         /**
-         * @return The number of squares in the polyomino
+         * Returns the number of squares in the polyomino
          */
-        int getPolyominoSize() const;
+        int getPolyominoOrder() const;
 
         /**
          * Strict inferiority operator, a polyomino is inferior than another if it has a smaller length, or if they are the same length,
-         * while checking from left to right and top to bottom, is the first which has a square while the other don't
-         * @return If the polyomino is inferior than another
+         * while checking from left to right and top to bottom, is the first which has a cell while the other doesn't
          */
         bool operator<(const Polyomino& other) const;
 
         /**
-         * Equality operator, two polyominoes are equal if their positions are the same, that means two polyominoes of the same shape at different places will not be equal
-         * @return If the polyomino is equal to another
+         * Equality operator, two polyominos are equal if they overlap, that means two polyominos of the same shape but different positions will not be equal
          */
-        bool operator==(const Polyomino& other) const;
+        bool operator ==(const Polyomino& other) const;
 
         /**
          * Stream output operator, adds a 2D grid representing the polyomino
-         * @return A reference to the output stream
          */
         friend std::ostream& operator<<(std::ostream& os, const Polyomino& polyomino);
 };

src/Pieces/Position.h

@@ -1,80 +0,0 @@
-#pragma once
-
-#include <iostream>
-
-
-/**
- * A position on a 2D grid
- */
-struct Position {
-    int x; // x position
-    int y; // y position
-};
-
-
-/**
- * Addition operator
- * @return The sums of the coordinates of both positions
- */
-inline Position operator+(const Position& left, const Position& right) {
-    return Position{left.x + right.x, left.y + right.y};
-}
-
-/**
- * Additive assignation operator, adds the coordinates of the right position to the left one
- * @return A reference to the left position
- */
-inline Position& operator+=(Position& left, const Position& right) {
-    left = left + right;
-    return left;
-}
-
-/**
- * Substraction operator
- * @return The difference of the coordinate between the left and right position
- */
-inline Position operator-(const Position& left, const Position& right) {
-    return Position{left.x - right.x, left.y - right.y};
-}
-
-/**
- * Substractive assignation operator, substracts the coordinates of the right position from the left one
- * @return A reference to the left position
- */
-inline Position& operator-=(Position& left, const Position& right) {
-    left = left + right;
-    return left;
-}
-
-/**
- * Strict inferiority operator, a position is inferior to another if it is lower or at the same height and more to the left
- * @return If the left position is inferior to the right position
- */
-inline bool operator<(const Position& left, const Position& right) {
-    return (left.x == right.x) ? (left.y < right.y) : (left.x < right.x);
-}
-
-/**
- * Equality operator, two positions are equal if they have the same coordinates
- * @return If the two positions are equals
- */
-inline bool operator==(const Position& left, const Position& right) {
-    return (left.x == right.x) && (left.y == right.y);
-}
-
-/**
- * Inequality operator, two positions aren't equal if their coordinates aren't
- * @return If the two positions aren't equals
- */
-inline bool operator!=(const Position& left, const Position& right) {
-    return (left.x != right.x) || (left.y != right.y);
-}
-
-/**
- * Stream output operator, adds the coordinates of the position to the stream
- * @return A reference to the output stream
- */
-inline std::ostream& operator<<(std::ostream& os, const Position& position) {
-    os << "x: " << position.x << " y: " << position.y;
-    return os;
-}

src/Pieces/Rotation.h

@@ -13,16 +13,14 @@ enum Rotation {
 
 
 /**
- * Addition operator
- * @return A rotation corresponding to doing both rotations
+ * Addition operator, returns a rotation corresponding to doing both rotations
  */
 inline Rotation operator+(const Rotation& left, const Rotation& right) {
-    return Rotation(((int) left + (int) right) % 4);
+    return Rotation((left + right) % 4);
 }
 
 /**
- * Additive assignation operator, rotates the left rotation by the right rotation
- * @return A reference to the left rotation
+ * Additive assignation operator, rotate the left rotation by the right rotation
  */
 inline Rotation& operator+=(Rotation& left, const Rotation& right) {
     left = left + right;

src/TextUI/TextApp.cpp

@@ -1,344 +0,0 @@
-#include "TextApp.h"
-
-#include "../Core/Menu.h"
-
-#include <map>
-#include <set>
-#include <string>
-#include <sstream>
-#include <algorithm>
-#include <cstdlib>
-#include <exception>
-
-static const int FRAMES_PER_INPUT = FRAMES_PER_SECOND / 2; // the number of frames that will pass everytime the player gives an input
-static const int MAXIMUM_PIECE_SIZE = 10;                  // the maximum size of pieces that will be loaded and utilizable
-static const int DEFAULT_PIECE_SIZE = 4;                   // the default size of pieces that will be selected when first running the app
-static const int MAXIMUM_BOARD_WIDTH = 30;                 // the maximum selectable width of the board
-static const int MAXIMUM_BOARD_HEIGHT = 40;                // the maximum selectable height of the board
-static const Gamemode DEFAULT_GAMEMODE = SPRINT;           // the gamemode that will be used when starting a new game
-
-
-TextApp::TextApp() {
-    this->defaultKeybinds();
-
-    this->gameMenu.getPiecesList().loadPieces(MAXIMUM_PIECE_SIZE);
-    this->gameMenu.getPiecesList().selectAllPieces(DEFAULT_PIECE_SIZE);
-
-    this->gameMenu.getPlayerControls().setDAS(FRAMES_PER_INPUT);
-    this->gameMenu.getPlayerControls().setARR(FRAMES_PER_INPUT);
-    this->gameMenu.getPlayerControls().setSDR(0);
-}
-
-void TextApp::run() {
-    bool quit = false;
-    while (!quit) {
-        std::cout << "\n\n\n";
-        std::cout << "===| WELCOME TO JMINOS! |===" << std::endl;
-        std::cout << "1- Change pieces" << std::endl;
-        std::cout << "2- Change board" << std::endl;
-        std::cout << "3- See controls" << std::endl;
-        std::cout << "4- Start game" << std::endl;
-        std::cout << "5- Quit" << std::endl;
-        std::cout << "Choice: ";
-
-        std::string answer;
-        std::getline(std::cin, answer);
-        int selectedAnswer = 0;
-        try {
-            selectedAnswer = std::stoi(answer);
-        }
-        catch (std::exception ignored) {}
-
-        switch (selectedAnswer) {
-            case 1 : {this->choosePieces(); break;}
-            case 2 : {this->chooseBoardSize(); break;}
-            case 3 : {this->seeKeybinds(); break;}
-            case 4 : {this->startGame(); break;}
-            case 5 : {quit = true; break;}
-            default : std::cout << "Invalid answer!" << std::endl;
-        }
-    }
-    std::cout << "===| SEE YA NEXT TIME! |===" << std::endl;
-}
-
-void TextApp::choosePieces() {
-    std::cout << "\n\n\n";
-    std::cout << "Choose which piece sizes to play with (from 1 to " << MAXIMUM_PIECE_SIZE << "), separate mutltiple sizes with blank spaces." << std::endl;
-    std::cout << "Choice: ";
-    std::string answer;
-    std::getline(std::cin, answer);
-
-    this->gameMenu.getPiecesList().unselectAll();
-    std::cout << "Selected pieces of sizes:"; 
-    std::stringstream answerStream(answer);
-    for (std::string size; std::getline(answerStream, size, ' ');) {
-        try {
-            int selectedSize = std::stoi(size);
-            if (selectedSize >= 1 && selectedSize <= MAXIMUM_PIECE_SIZE) {
-                if (this->gameMenu.getPiecesList().selectAllPieces(selectedSize)) {
-                    std::cout << " " << selectedSize;
-                }
-            }
-        }
-        catch (std::exception ignored) {}
-    }
-
-    std::string waiting;
-    std::getline(std::cin, waiting);
-}
-
-void TextApp::chooseBoardSize() {
-    std::string answer;
-
-    std::cout << "\n\n\n";
-    std::cout << "Current board width and height: " << this->gameMenu.getBoardWidth() << "x" << this->gameMenu.getBoardHeight() << std::endl;
-
-    std::cout << "Choose the width of the board (from 1 to " << MAXIMUM_BOARD_WIDTH << ")." << std::endl;
-    std::cout << "Choice: ";
-    std::getline(std::cin, answer);
-    try {
-        int selectedSize = std::stoi(answer);
-        if (selectedSize >= 1 && selectedSize <= MAXIMUM_BOARD_WIDTH) {
-            this->gameMenu.setBoardWidth(selectedSize);
-        }
-    }
-    catch (std::exception ignored) {}
-
-    std::cout << "Choose the height of the board (from 1 to " << MAXIMUM_BOARD_HEIGHT << ")." << std::endl;
-    std::cout << "Choice: ";
-    std::getline(std::cin, answer);
-    try {
-        int selectedSize = std::stoi(answer);
-        if (selectedSize >= 1 && selectedSize <= MAXIMUM_BOARD_HEIGHT) {
-            this->gameMenu.setBoardHeight(selectedSize);
-        }
-    }
-    catch (std::exception ignored) {}
-
-    std::cout << "New board width and height: " << this->gameMenu.getBoardWidth() << "x" << this->gameMenu.getBoardHeight();
-
-    std::string waiting;
-    std::getline(std::cin, waiting);
-}
-
-void TextApp::seeKeybinds() const {
-    std::cout << "\n\n\n";
-    std::cout << "Quit/Pause/Retry: quit/pause/retry" << std::endl;
-    std::cout << "Hold : h" << std::endl;
-    std::cout << "Soft/Hard drop : sd/hd" << std::endl;
-    std::cout << "Move left/right : l/r" << std::endl;
-    std::cout << "Rotate 0/CW/180/CCW: c/cw/cc/ccw" << std::endl;
-    std::cout << "\n";
-    std::cout << "To do several actions at the same time, separe them with blank spaces." << std::endl;
-    std::string waiting;
-    std::getline(std::cin, waiting);
-}
-
-void TextApp::defaultKeybinds() {
-    this->keybinds.clear();
-    this->keybinds.insert({"pause", PAUSE});
-    this->keybinds.insert({"retry", RETRY});
-    this->keybinds.insert({"h", HOLD});
-    this->keybinds.insert({"sd", SOFT_DROP});
-    this->keybinds.insert({"hd", HARD_DROP});
-    this->keybinds.insert({"l", MOVE_LEFT});
-    this->keybinds.insert({"r", MOVE_RIGHT});
-    this->keybinds.insert({"c", ROTATE_0});
-    this->keybinds.insert({"cw", ROTATE_CW});
-    this->keybinds.insert({"cc", ROTATE_180});
-    this->keybinds.insert({"ccw", ROTATE_CCW});
-}
-
-void TextApp::startGame() const {
-    Game game = this->gameMenu.startGame(DEFAULT_GAMEMODE);
-    game.start();
-
-    std::cout << "\n\n\n";
-    this->printGame(game);
-
-    bool quit = false;
-    bool paused = false;
-    std::string answer;
-    while (!quit) {
-        std::cout << "Actions: ";
-        std::getline(std::cin, answer);
-        std::stringstream answerStream(answer);
-        std::vector<std::string> actions;
-        for (std::string action; std::getline(answerStream, action, ' ');) {
-            actions.push_back(action);
-        }
-
-        std::set<Action> playerActions;
-        std::set<Action> lastFrameActions;
-        bool retrying = false;
-        for (std::string action : actions) {
-            if (action == "quit") {
-                quit = true;
-            }
-            else {
-                try {
-                    Action playerAction = this->keybinds.at(action);
-                    if (playerAction == RETRY) {
-                        retrying = true;
-                    }
-                    else if (playerAction == PAUSE) {
-                        paused = (!paused);
-                    }
-                    else if (playerAction == SOFT_DROP || playerAction == MOVE_LEFT || playerAction == MOVE_RIGHT) {
-                        playerActions.insert(playerAction);
-                        lastFrameActions.insert(playerAction);
-                    }
-                    else if (playerAction == HOLD || playerAction == HARD_DROP) {
-                        lastFrameActions.insert(playerAction);
-                    }
-                    else {
-                        playerActions.insert(playerAction);
-                    }
-                }
-                catch (std::exception ignored) {}
-            }
-        }
-
-        if (!paused && !quit) {
-            if (retrying) {
-                game.reset();
-                game.start();
-            }
-            else {
-                for (int i = 0; i < (FRAMES_PER_INPUT - 1); i++) {
-                    game.nextFrame(playerActions);
-                }
-                game.nextFrame(lastFrameActions);
-            }
-        }
-
-        if (!quit) {
-            std::cout << "\n\n\n";
-            if (paused) {
-                std::cout << "--<[PAUSED]>--" << std::endl;
-            }
-            this->printGame(game);
-        }
-
-        if (game.hasLost()) {
-            quit = true;
-            std::cout << "You lost!" << std::endl;
-        }
-        else if (game.hasWon()) {
-            quit = true;
-            std::cout << "You won!" << std::endl;
-        }
-    }
-}
-
-void TextApp::printGame(const Game& game) const {
-    int maxHeight = game.getBoard().getGridHeight();
-    if (game.getActivePiece() != nullptr) {
-        for (const Position& position : game.getActivePiece()->getPositions()) {
-            maxHeight = std::max(maxHeight, position.y + game.getActivePiecePosition().y);
-        }
-    }
-    
-    bool lineCountPrinted = false;
-    bool holdBoxStartedPrinting = false;
-    bool holdBoxFinishedPrinting = false;
-    bool nextQueueStartedPrinting = false;
-    bool nextQueueFinishedPrinting = false;
-    int nextQueuePrintedPiece;
-    int printedPieceLineHeight;
-
-    for (int y = maxHeight; y >= 0; y--) {
-        for (int x = 0; x < game.getBoard().getWidth(); x++) {
-            /* BOARD PRINTING */
-            bool isActivePieceHere = (game.getActivePiece() != nullptr) && (game.getActivePiece()->getPositions().contains(Position{x, y} - game.getActivePiecePosition()));
-            bool isGhostPieceHere = (game.getActivePiece() != nullptr) && (game.getActivePiece()->getPositions().contains(Position{x, y} - game.ghostPiecePosition()));
-            Block block = (isActivePieceHere || isGhostPieceHere) ? game.getActivePiece()->getBlockType() : game.getBoard().getBlock(Position{x, y});
-
-            if (isActivePieceHere || isGhostPieceHere) {
-                std::cout << getConsoleColorCode(block);
-            }
-            else {
-                std::cout << getResetConsoleColorCode();
-            }
-
-            if (block != NOTHING && (!(isGhostPieceHere && !isActivePieceHere))) {
-                std::cout << "*";
-            }
-            else {
-                if (y < game.getBoard().getBaseHeight()) {
-                    if (isGhostPieceHere) {
-                        std::cout << "=";
-                    }
-                    else {
-                        std::cout << "-";
-                    }
-                }
-                else {
-                    std::cout << " ";
-                }
-            }
-        }
-
-        if (y < game.getBoard().getGridHeight()) {
-            /* SIDEBAR PRINTING */
-            std::cout << "     ";
-            if (!lineCountPrinted) {
-                std::cout << getResetConsoleColorCode() << "Lines: " << game.getClearedLines();
-                lineCountPrinted = true;
-            }
-            else if (!holdBoxFinishedPrinting) {
-                if (!holdBoxStartedPrinting) {
-                    std::cout << getResetConsoleColorCode() << "Hold:";
-                    printedPieceLineHeight = (game.getHeldPiece() == nullptr) ? -1 : (game.getHeldPiece()->getLength() - 1);
-                    holdBoxStartedPrinting = true;
-                }
-                else {
-                    for (int i = 0; i < game.getHeldPiece()->getLength(); i++) {
-                        if (game.getHeldPiece()->getPositions().contains(Position{i, printedPieceLineHeight})) {
-                            std::cout << getConsoleColorCode(game.getHeldPiece()->getBlockType()) << "*";
-                        }
-                        else {
-                            std::cout << getResetConsoleColorCode() << "-";
-                        }
-                    }
-                    printedPieceLineHeight--;
-                }
-                if (printedPieceLineHeight < 0) {
-                    holdBoxFinishedPrinting = true;
-                }
-            }
-            else if (!nextQueueFinishedPrinting) {
-                if (!nextQueueStartedPrinting) {
-                    std::cout << getResetConsoleColorCode() << "Next:";
-                    printedPieceLineHeight = (game.getNextPieces().size() == 0) ? -1 : (game.getNextPieces().at(0).getLength() - 1);
-                    nextQueuePrintedPiece = 0;
-                    nextQueueStartedPrinting = true;
-                }
-                else {
-                    for (int i = 0; i < game.getNextPieces().at(nextQueuePrintedPiece).getLength(); i++) {
-                        if (game.getNextPieces().at(nextQueuePrintedPiece).getPositions().contains(Position{i, printedPieceLineHeight})) {
-                            std::cout << getConsoleColorCode(game.getNextPieces().at(nextQueuePrintedPiece).getBlockType()) << "*";
-                        }
-                        else {
-                            std::cout << getResetConsoleColorCode() << "-";
-                        }
-                    }
-                    printedPieceLineHeight--;
-                }
-                if (printedPieceLineHeight < 0) {
-                    nextQueuePrintedPiece++;
-                    if (nextQueuePrintedPiece >= game.getNextPieces().size()) {
-                        nextQueueFinishedPrinting = true;
-                    }
-                    else {
-                        printedPieceLineHeight = game.getNextPieces().at(nextQueuePrintedPiece).getLength() - 1;
-                    }
-                }
-            }
-        }
-        
-        std::cout << "\n";
-    }
-
-    std::cout << getResetConsoleColorCode();
-}

src/TextUI/TextApp.h

@@ -1,58 +0,0 @@
-#pragma once
-
-#include "../Core/Menu.h"
-
-#include <map>
-#include <string>
-
-
-/**
- * Textual interface for the app
- */
-class TextApp {
-    private:
-        Menu gameMenu;                          // the interface with the core of the app
-        std::map<std::string, Action> keybinds; // what the player needs to type to perform in-game actions
-
-    public:
-        /**
-         * Initializes the app with default settings
-         */
-        TextApp();
-
-        /**
-         * Runs the app
-         */
-        void run();
-    
-    private:
-        /**
-         * Sub-menu to select which pieces to play with
-         */
-        void choosePieces();
-
-        /**
-         * Sub-menu to change the size of the board
-         */
-        void chooseBoardSize();
-
-        /**
-         * Sub-menu to see the in-game controls
-         */
-        void seeKeybinds() const;
-
-        /**
-         * Sets the controls to their default values
-         */
-        void defaultKeybinds();
-
-        /**
-         * Starts a new game with the current settings
-         */
-        void startGame() const;
-
-        /**
-         * Prints the current state of a game to the console
-         */
-        void printGame(const Game& game) const;
-};

xmake.lua

@@ -1,29 +1,12 @@
-add_rules("mode.debug", "mode.release")
-
-add_requires("sfml 3.0.0")
-
 set_languages("c++20")
 
-set_rundir(".")
-
-set_optimize("fastest")
-
-target("core")
-    set_kind("$(kind)")
-    add_files("src/Pieces/*.cpp")
-    add_files("src/Core/*.cpp")
-
-target("text")
+target("main")
     set_kind("binary")
-    set_default(false)
-    add_files("./src/TextUI/*.cpp")
-    add_deps("core")
+    set_rundir(".")
+    add_files("./src/Pieces/*.cpp")
+    add_files("./src/Core/*.cpp")
+    set_optimize("fastest")
     
-target("graph")
-    set_kind("binary")
-    add_files("./src/GraphicalUI/**.cpp")
-    add_deps("core")
-    add_packages("sfml")
 
 --
 -- If you want to known more usage about xmake, please see https://xmake.io