Allow non square sub-blocks, add 3x2 game mode

lib/utils/board_utils.dart

@@ -22,30 +22,33 @@ class BoardUtils {
 
 
   static Future<void> pickGrid(Data myProvider) async {
-    int size = myProvider.size;
-
     String grid;
     RandomPickGrid randomPickGrid;
 
     randomPickGrid = RandomPickGrid();
-    await randomPickGrid.init(myProvider.level, size);
+    await randomPickGrid.init(myProvider.level, myProvider.size);
 
     if (randomPickGrid.grid != null) {
       grid = randomPickGrid.grid;
     }
 
-    if (grid.length == pow(size, 4)) {
-      myProvider.updateCells = BoardUtils.createBoardFromTemplate(grid);
+    int blockSizeHorizontal = myProvider.blockSizeHorizontal;
+    int blockSizeVertical = myProvider.blockSizeVertical;
+
+    if (grid.length == pow(blockSizeHorizontal * blockSizeVertical, 2)) {
+      print('Picked grid from template: ' + grid);
+      bool isSymetric = (blockSizeHorizontal == blockSizeVertical);
+      myProvider.updateCells = BoardUtils.createBoardFromTemplate(grid, isSymetric);
     }
   }
 
 
-  static List createEmptyBoard(int size) {
+  static List createEmptyBoard(int boardSize) {
     int index = 0;
     List cells = [];
-    for (var rowIndex = 0; rowIndex < pow(size, 2); rowIndex++) {
+    for (var rowIndex = 0; rowIndex < boardSize; rowIndex++) {
       List row = [];
-      for (var colIndex = 0; colIndex < pow(size, 2); colIndex++) {
+      for (var colIndex = 0; colIndex < boardSize; colIndex++) {
         row.add(Cell(0, false));
       }
       cells.add(row);
@@ -55,44 +58,51 @@ class BoardUtils {
   }
 
 
-  static List createBoardFromTemplate(String grid) {
+  static List createBoardFromTemplate(String grid, bool isSymetric) {
     List cells = [];
-    int size = int.parse(pow(grid.length, 1/4).toStringAsFixed(0));
-    int sideLength = pow(size, 2);
+    int boardSize = int.parse(pow(grid.length, 1/2).toStringAsFixed(0));
 
     int index = 0;
-    for (var rowIndex = 0; rowIndex < sideLength; rowIndex++) {
+    for (var rowIndex = 0; rowIndex < boardSize; rowIndex++) {
       List row = [];
-      for (var colIndex = 0; colIndex < sideLength; colIndex++) {
+      for (var colIndex = 0; colIndex < boardSize; colIndex++) {
         int value = int.parse(grid[index++]);
         row.add(Cell(value, (value != 0)));
       }
       cells.add(row);
     }
 
-    List<String> allowedFlip = ['', 'horizontal', 'vertical'];
-    List<String> allowedRotate = ['', 'left', 'right'];
+    List<String> allowedFlip = ['none', 'horizontal', 'vertical'];
+    List<String> allowedRotate = ['none', 'left', 'right'];
+
+    // Forbid rotation if blocks are not symetric
+    if (!isSymetric) {
+      allowedRotate = ['none'];
+    }
 
     var rand = new Random();
     String flip = allowedFlip[rand.nextInt(allowedFlip.length)];
     String rotate = allowedRotate[rand.nextInt(allowedRotate.length)];
 
+    print('flip board: ' + flip);
+    print('rotate board: ' + rotate);
+
     switch(flip) {
       case 'horizontal': {
-        List transformedBoard = createEmptyBoard(size);
-        for (var rowIndex = 0; rowIndex < sideLength; rowIndex++) {
-          for (var colIndex = 0; colIndex < sideLength; colIndex++) {
-            transformedBoard[rowIndex][colIndex].value = cells[sideLength - rowIndex - 1][colIndex].value;
+        List transformedBoard = createEmptyBoard(boardSize);
+        for (var rowIndex = 0; rowIndex < boardSize; rowIndex++) {
+          for (var colIndex = 0; colIndex < boardSize; colIndex++) {
+            transformedBoard[rowIndex][colIndex].value = cells[boardSize - rowIndex - 1][colIndex].value;
           }
         }
         cells = transformedBoard;
       }
       break;
       case 'vertical': {
-        List transformedBoard = createEmptyBoard(size);
-        for (var rowIndex = 0; rowIndex < sideLength; rowIndex++) {
-          for (var colIndex = 0; colIndex < sideLength; colIndex++) {
-            transformedBoard[rowIndex][colIndex].value = cells[rowIndex][sideLength - colIndex - 1].value;
+        List transformedBoard = createEmptyBoard(boardSize);
+        for (var rowIndex = 0; rowIndex < boardSize; rowIndex++) {
+          for (var colIndex = 0; colIndex < boardSize; colIndex++) {
+            transformedBoard[rowIndex][colIndex].value = cells[rowIndex][boardSize - colIndex - 1].value;
           }
         }
         cells = transformedBoard;
@@ -102,20 +112,20 @@ class BoardUtils {
 
     switch(rotate) {
       case 'left': {
-        List transformedBoard = createEmptyBoard(size);
-        for (var rowIndex = 0; rowIndex < sideLength; rowIndex++) {
-          for (var colIndex = 0; colIndex < sideLength; colIndex++) {
-            transformedBoard[rowIndex][colIndex].value = cells[colIndex][sideLength - rowIndex - 1].value;
+        List transformedBoard = createEmptyBoard(boardSize);
+        for (var rowIndex = 0; rowIndex < boardSize; rowIndex++) {
+          for (var colIndex = 0; colIndex < boardSize; colIndex++) {
+            transformedBoard[rowIndex][colIndex].value = cells[colIndex][boardSize - rowIndex - 1].value;
           }
         }
         cells = transformedBoard;
       }
       break;
       case 'right': {
-        List transformedBoard = createEmptyBoard(size);
-        for (var rowIndex = 0; rowIndex < sideLength; rowIndex++) {
-          for (var colIndex = 0; colIndex < sideLength; colIndex++) {
-            transformedBoard[rowIndex][colIndex].value = cells[sideLength - colIndex - 1][rowIndex].value;
+        List transformedBoard = createEmptyBoard(boardSize);
+        for (var rowIndex = 0; rowIndex < boardSize; rowIndex++) {
+          for (var colIndex = 0; colIndex < boardSize; colIndex++) {
+            transformedBoard[rowIndex][colIndex].value = cells[boardSize - colIndex - 1][rowIndex].value;
           }
         }
         cells = transformedBoard;
@@ -124,8 +134,8 @@ class BoardUtils {
     }
 
     // Fix cells fixed states
-    for (var rowIndex = 0; rowIndex < sideLength; rowIndex++) {
-      for (var colIndex = 0; colIndex < sideLength; colIndex++) {
+    for (var rowIndex = 0; rowIndex < boardSize; rowIndex++) {
+      for (var colIndex = 0; colIndex < boardSize; colIndex++) {
         cells[rowIndex][colIndex].isFixed = (cells[rowIndex][colIndex].value != 0) ? true : false;
       }
     }
@@ -138,21 +148,24 @@ class BoardUtils {
 
   static bool checkBoardIsSolved(Data myProvider) {
     List cells = myProvider.cells;
-    int size = myProvider.size;
-    int sideLength = pow(size, 2);
+
+    int blockSizeHorizontal = myProvider.blockSizeHorizontal;
+    int blockSizeVertical = myProvider.blockSizeVertical;
+
+    int boardSize = blockSizeHorizontal * blockSizeVertical;
 
     bool isSolved = true;
 
     // reset conflict states
-    for (var row = 0; row < sideLength; row++) {
-      for (var col = 0; col < sideLength; col++) {
+    for (var row = 0; row < boardSize; row++) {
+      for (var col = 0; col < boardSize; col++) {
         cells[row][col].conflictsCount = 0;
       }
     }
 
     // check grid is fully completed
-    for (var row = 0; row < sideLength; row++) {
-      for (var col = 0; col < sideLength; col++) {
+    for (var row = 0; row < boardSize; row++) {
+      for (var col = 0; col < boardSize; col++) {
         if (cells[row][col].value == 0) {
           isSolved = false;
         }
@@ -160,9 +173,9 @@ class BoardUtils {
     }
 
     // check lines does not contains a value twice
-    for (var row = 0; row < sideLength; row++) {
+    for (var row = 0; row < boardSize; row++) {
       List values = [];
-      for (var col = 0; col < sideLength; col++) {
+      for (var col = 0; col < boardSize; col++) {
         int value = cells[row][col].value;
         if (value != 0) {
           values.add(value);
@@ -172,7 +185,7 @@ class BoardUtils {
       if (values.length != distinctValues.length) {
         print('line ' + row.toString() + ' contains duplicates');
         // Add line to cells in conflict
-        for (var col = 0; col < sideLength; col++) {
+        for (var col = 0; col < boardSize; col++) {
           cells[row][col].conflictsCount++;
         }
         isSolved = false;
@@ -180,9 +193,9 @@ class BoardUtils {
     }
 
     // check columns does not contains a value twice
-    for (var col = 0; col < sideLength; col++) {
+    for (var col = 0; col < boardSize; col++) {
       List values = [];
-      for (var row = 0; row < sideLength; row++) {
+      for (var row = 0; row < boardSize; row++) {
         int value = cells[row][col].value;
         if (value != 0) {
           values.add(value);
@@ -192,7 +205,7 @@ class BoardUtils {
       if (values.length != distinctValues.length) {
         print('column ' + col.toString() + ' contains duplicates');
         // Add column to cells in conflict
-        for (var row = 0; row < sideLength; row++) {
+        for (var row = 0; row < boardSize; row++) {
           cells[row][col].conflictsCount++;
         }
         isSolved = false;
@@ -200,14 +213,16 @@ class BoardUtils {
     }
 
     // check blocks does not contains a value twice
-    for (var blockRow = 0; blockRow < size; blockRow++) {
-      for (var blockCol = 0; blockCol < size; blockCol++) {
+    int horizontalBlocksCount = blockSizeVertical;
+    int verticalBlocksCount = blockSizeHorizontal;
+    for (var blockRow = 0; blockRow < verticalBlocksCount; blockRow++) {
+      for (var blockCol = 0; blockCol < horizontalBlocksCount; blockCol++) {
         List values = [];
 
-        for (var rowInBlock = 0; rowInBlock < size; rowInBlock++) {
-          for (var colInBlock = 0; colInBlock < size; colInBlock++) {
-            int row = (blockRow * size) + rowInBlock;
-            int col = (blockCol * size) + colInBlock;
+        for (var rowInBlock = 0; rowInBlock < blockSizeVertical; rowInBlock++) {
+          for (var colInBlock = 0; colInBlock < blockSizeHorizontal; colInBlock++) {
+            int row = (blockRow * blockSizeVertical) + rowInBlock;
+            int col = (blockCol * blockSizeHorizontal) + colInBlock;
             int value = cells[row][col].value;
             if (value != 0) {
               values.add(value);
@@ -219,10 +234,10 @@ class BoardUtils {
         if (values.length != distinctValues.length) {
           print('block [' + blockCol.toString() + ',' + blockRow.toString() + '] contains duplicates');
           // Add blocks to cells in conflict
-          for (var rowInBlock = 0; rowInBlock < size; rowInBlock++) {
-            for (var colInBlock = 0; colInBlock < size; colInBlock++) {
-              int row = (blockRow * size) + rowInBlock;
-              int col = (blockCol * size) + colInBlock;
+          for (var rowInBlock = 0; rowInBlock < blockSizeVertical; rowInBlock++) {
+            for (var colInBlock = 0; colInBlock < blockSizeHorizontal; colInBlock++) {
+              int row = (blockRow * blockSizeVertical) + rowInBlock;
+              int col = (blockCol * blockSizeHorizontal) + colInBlock;
               cells[row][col].conflictsCount++;
             }
           }

lib/utils/game_utils.dart

@@ -8,8 +8,9 @@ class GameUtils {
   }
 
   static Future<void> startGame(Data myProvider) async {
+    print('Start new game: ' + myProvider.size);
     myProvider.updateStateRunning = true;
-    myProvider.updateCells = BoardUtils.createEmptyBoard(myProvider.size);
+    myProvider.updateCells = BoardUtils.createEmptyBoard(myProvider.blockSizeHorizontal * myProvider.blockSizeVertical);
     BoardUtils.pickGrid(myProvider);
   }
 }

lib/utils/random_pick_grid.dart

@@ -6,27 +6,25 @@ class RandomPickGrid {
 
   String _grid;
 
-  init(String difficulty, int size) async {
+  init(String difficulty, String size) async {
     _grid = '';
     await gridFromLocalFile(difficulty, size);
   }
 
-  Future<void> gridFromLocalFile(String difficulty, int size) async {
-    String sizeAsString = size.toString() + 'x' + size.toString();
-
+  Future<void> gridFromLocalFile(String difficulty, String size) async {
     // Get global grids list
     List grids;
     try {
       String jsonString = await rootBundle.loadString('assets/files/templates.json');
       final jsonResponse = await json.decode(jsonString);
-      grids = jsonResponse['templates'][sizeAsString][difficulty];
+      grids = jsonResponse['templates'][size][difficulty];
     } catch (e) {
       print("$e");
     }
 
     // Check we have enough grids
     if (grids.length < 1) {
-      print('Not enough grids [' + sizeAsString + ', ' + difficulty + '] in templates.');
+      print('Not enough grids [' + size + ', ' + difficulty + '] in templates.');
     }
 
     // Randomize grids list