reset usermod TetrisAI back to initial version

usermods/TetrisAI_v2/gridbw.h

@@ -34,7 +34,7 @@ class GridBW
     {
         if (width > 32)
         {
-            throw std::invalid_argument("maximal width is 32");
+            this->width = 32;
         }
     }
 
@@ -112,6 +112,17 @@ class GridBW
     {
         return pixels[y] == (uint32_t)((1 << width) - 1);
     }
+
+    void reset()
+    {
+        if (width > 32)
+        {
+            width = 32;
+        }
+
+        pixels.clear();
+        pixels.resize(height);
+    }
 };
 
 #endif /* __GRIDBW_H__ */

usermods/TetrisAI_v2/gridcolor.h

@@ -127,6 +127,14 @@ class GridColor
             }
         }
     }
+
+    void reset()
+    {
+        gridBW.reset();
+        pixels.clear();
+        pixels.resize(width* height);
+        clear();
+    }
 };
 
 #endif /* __GRIDCOLOR_H__ */

usermods/TetrisAI_v2/rating.h

@@ -32,7 +32,7 @@ class Rating
     uint8_t fullLines;
     uint16_t bumpiness;
     uint16_t aggregatedHeight;
-    double score;
+    float score;
     uint8_t width;
     std::vector<uint8_t> lineHights;
 
@@ -57,7 +57,7 @@ class Rating
         this->fullLines = 0;
         this->bumpiness = 0;
         this->aggregatedHeight = 0;
-        this->score = -DBL_MAX;
+        this->score = -FLT_MAX;
     }
 };
 

usermods/TetrisAI_v2/readme.md

@@ -1,16 +1,22 @@
 # Tetris AI effect usermod
 
-This usermod brings you a effect brings a self playing Tetris game. The mod needs version 0.14 or above as it is based on matrix support. The effect was tested on an ESP32 with a WS2812B 16x16 matrix.
+This usermod adds a self-playing Tetris game as an 'effect'. The mod requires version 0.14 or higher as it relies on matrix support. The effect was tested on an ESP32 4MB with a WS2812B 16x16 matrix.
 
 Version 1.0
 
 ## Installation 
 
-Just activate the usermod with `-D USERMOD_TETRISAI` and the effect will become available under the name 'Tetris AI'.
+Just activate the usermod with `-D USERMOD_TETRISAI` and the effect will become available under the name 'Tetris AI'. If you are running out of flash memory, use a different memory layout (e.g. [WLED_ESP32_4MB_256KB_FS.csv](https://github.com/Aircoookie/WLED/blob/main/tools/WLED_ESP32_4MB_256KB_FS.csv)).
+
+If needed simply add to `platformio_override.ini` (or `platformio_override.ini`):
+
+```ini
+board_build.partitions = tools/WLED_ESP32_4MB_256KB_FS.csv
+```
 
 ## Usage
 
-It is best to set the background color to black, the border color to light grey and the game over color (foreground) to dark grey.
+It is best to set the background color to black 🖤, the border color to light grey 🤍, the game over color (foreground) to dark grey 🩶, and color palette to 'Rainbow' 🌈.
 
 ### Sliders and boxes
 
@@ -19,15 +25,18 @@ It is best to set the background color to black, the border color to light grey
 * speed: speed the game plays
 * look ahead: how many pieces is the AI allowed to know the next pieces (0 - 2)
 * intelligence: how good the AI will play
-* Rotate color: make the colors shift (rotate) every few cicles
-* Mistakes free: how many good moves between mistakes (if activated)
+* Rotate color: make the colors shift (rotate) every few moves
+* Mistakes free: how many good moves between mistakes (if enabled)
 
 #### Checkboxes
 
-* show next: if true a space of 5 pixels from the right is used to show the next pieces. The whole segment is used for the grid otherwise.
+* show next: if true, a space of 5 pixels from the right will be used to show the next pieces. Otherwise the whole segment is used for the grid.
 * show border: if true an additional column of 1 pixel is used to draw a border between the grid and the next pieces
-* mistakes: if true the worst instead of the best move is choosen every few moves (read above)
+* mistakes: if true, the worst decision will be made every few moves instead of the best (see above).
 
 ## Best results
 
- If the speed is set to be a little bit faster than a good human could play with maximal intelligence and very few mistakes it makes people furious/happy at a party.
+ If the speed is set to be a little bit faster than a good human could play with maximal intelligence and very few mistakes it makes people furious/happy at a party 😉.
+
+## Limits
+The game grid is limited to a maximum width of 32 and a maximum height of 255 due to the internal structure of the code. The canvas of the effect will be centred in the segment if the segment exceeds the maximum width or height.

usermods/TetrisAI_v2/tetrisai.h

@@ -22,10 +22,10 @@ class TetrisAI
 {
 private:
 public:
-    double aHeight;
-    double fullLines;
-    double holes;
-    double bumpiness;
+    float aHeight;
+    float fullLines;
+    float holes;
+    float bumpiness;
     bool findWorstMove = false;
 
     uint8_t countOnes(uint32_t vector)
@@ -107,10 +107,10 @@ class TetrisAI
         rating->score = (aHeight * (rating->aggregatedHeight)) + (fullLines * (rating->fullLines)) + (holes * (rating->holes)) + (bumpiness * (rating->bumpiness));
     }
 
-    TetrisAI(): TetrisAI(-0.510066, 0.760666, -0.35663, -0.184483)
+    TetrisAI(): TetrisAI(-0.510066f, 0.760666f, -0.35663f, -0.184483f)
     {}
 
-    TetrisAI(double aHeight, double fullLines, double holes, double bumpiness):
+    TetrisAI(float aHeight, float fullLines, float holes, float bumpiness):
         aHeight(aHeight),
         fullLines(fullLines),
         holes(holes),
@@ -178,9 +178,9 @@ class TetrisAI
                 if(findWorstMove)
                 {
                     //init rating for worst
-                    if(bestRating->score == -DBL_MAX)
+                    if(bestRating->score == -FLT_MAX)
                     {
-                        bestRating->score = DBL_MAX;
+                        bestRating->score = FLT_MAX;
                     }
 
                     // update if we found a worse one
@@ -202,101 +202,6 @@ class TetrisAI
             }
         }
     }
-
-    bool findBestMoveNonBlocking(GridBW grid, std::vector<Piece>::iterator start, std::vector<Piece>::iterator end, Rating* bestRating)
-    {
-        //vector with pieces
-        //for every piece
-            //for every 
-        switch (expression)
-        {
-            case INIT:
-                break;
-
-            default:
-                break;
-        }
-    }
-
-    bool findBestMoveNonBlocking(GridBW grid, std::vector<Piece>::iterator start, std::vector<Piece>::iterator end, Rating* bestRating)
-    {
-        //INIT
-        grid.cleanupFullLines();
-        Rating curRating(grid.width);
-        Rating deeperRating(grid.width);
-        Piece piece = *start;
-
-        // for every rotation of the piece
-        piece.rotation = 0;
-
-        //HANDLE
-        while (piece.rotation < piece.pieceData->rotCount)
-        {
-            // put piece to top left corner
-            piece.x = 0;
-            piece.y = 0;
-
-            //test for every column
-            piece.x = 0;
-            while (piece.x <= grid.width - piece.getRotation().width)
-            {
-
-                //todo optimise by the use of the previous grids height
-                piece.landingY = 0;
-                //will set landingY to final position
-                grid.findLandingPosition(&piece);
-
-                // draw piece
-                grid.placePiece(&piece, piece.x, piece.landingY);
-
-                if(start == end - 1)
-                {
-                    //at the deepest level
-                    updateRating(grid, &curRating);
-                }
-                else
-                {
-                    //go deeper to take another piece into account
-                    findBestMove(grid, start + 1, end, &deeperRating);
-                    curRating = deeperRating;
-                }
-
-                // eraese piece
-                grid.erasePiece(&piece, piece.x, piece.landingY);
-
-                if(findWorstMove)
-                {
-                    //init rating for worst
-                    if(bestRating->score == -DBL_MAX)
-                    {
-                        bestRating->score = DBL_MAX;
-                    }
-
-                    // update if we found a worse one
-                    if (bestRating->score > curRating.score)
-                    {
-                        *bestRating = curRating;
-                        (*start) = piece;
-                    }
-                }
-                else
-                {
-                    // update if we found a better one
-                    if (bestRating->score < curRating.score)
-                    {
-                        *bestRating = curRating;
-                        (*start) = piece;
-                    }
-                }
-                piece.x++;
-            }
-            piece.rotation++;
-        }
-
-        //EXIT
-
-        return true;
-    }
 };
 
 #endif /* __AI_H__ */

usermods/TetrisAI_v2/tetrisaigame.h

@@ -54,6 +54,7 @@ class TetrisAIGame
     uint8_t width;
     uint8_t height;
     uint8_t nLookAhead;
+    uint8_t nPieces;
     TetrisBag bag;
     GridColor grid;
     TetrisAI ai;
@@ -65,6 +66,7 @@ class TetrisAIGame
         width(width),
         height(height),
         nLookAhead(nLookAhead),
+        nPieces(nPieces),
         bag(nPieces, 1, nLookAhead),
         grid(width, height + 4),
         ai(),
@@ -142,8 +144,10 @@ class TetrisAIGame
 
     void reset()
     {
-        grid.clear();
-        bag.init();
+        grid.width = width;
+        grid.height = height + 4;
+        grid.reset();
+        bag.reset();
     }
 };
 

usermods/TetrisAI_v2/tetrisbag.h

@@ -25,13 +25,15 @@ class TetrisBag
 public:
     uint8_t nPieces;
     uint8_t nBagLength;
+    uint8_t queueLength;
     uint8_t bagIdx;
     std::vector<uint8_t> bag;
     std::vector<Piece> piecesQueue;
 
     TetrisBag(uint8_t nPieces, uint8_t nBagLength, uint8_t queueLength):
         nPieces(nPieces),
         nBagLength(nBagLength),
+        queueLength(queueLength),
         bag(nPieces * nBagLength),
         piecesQueue(queueLength)
     {
@@ -95,6 +97,15 @@ class TetrisBag
         std::rotate(piecesQueue.begin(), piecesQueue.begin() + 1, piecesQueue.end());
         piecesQueue[piecesQueue.size() - 1] = Piece(idx % nPieces);
     }
+
+    void reset()
+    {
+        bag.clear();
+        bag.resize(nPieces * nBagLength);
+        piecesQueue.clear();
+        piecesQueue.resize(queueLength);
+        init();
+    }
 };
 
 #endif /* __TETRISBAG_H__ */