Add minimal "pick random tetrimino" feature

android/gradle.properties

 org.gradle.jvmargs=-Xmx1536M
 android.useAndroidX=true
 android.enableJetifier=true
-app.versionName=0.0.1
-app.versionCode=1
+app.versionName=0.0.2
+app.versionCode=2

fastlane/metadata/android/en-US/changelogs/2.txt

+Add minimal "pick random tetrimino" feature

fastlane/metadata/android/fr-FR/changelogs/2.txt

+Ajout du minimal "pioche un tetrimino au hasard"

lib/layout/board.dart

 import 'package:flutter/material.dart';
 import 'package:tetrisdual/layout/board_painter.dart';
 import 'package:tetrisdual/provider/data.dart';
+import 'package:tetrisdual/utils/game_utils.dart';
 
 class Board {
   static Container buildGameBoard(Data myProvider, double boardWidth) {
@@ -13,9 +14,7 @@ class Board {
             child: Center(
               child: GestureDetector(
                 onTapUp: (details) {
-                  double xTap = details.localPosition.dx;
-                  double yTap = details.localPosition.dy;
-                  print('xTap: ' + xTap.toString() + ' / yTap: ' + yTap.toString());
+                  GameUtils.pickRandomTetrimino(myProvider);
                 },
                 child: Container(
                   child: CustomPaint(

lib/layout/board_painter.dart

+import 'dart:math';
+
 import 'package:flutter/material.dart';
 import 'package:tetrisdual/provider/data.dart';
 
@@ -6,9 +8,118 @@ class BoardPainter extends CustomPainter {
 
   final Data myProvider;
 
+  void drawPixels(List<List<int>> pixels, Canvas canvas, double drawSize, Color pixelColor) {
+    int blockWidth = 1;
+    int blockHeight = 1;
+    pixels.forEach((pixel) {
+      int x = pixel[0] + 1;
+      int y = pixel[1] + 1;
+      if (x > blockWidth) {
+        blockWidth = x;
+      }
+      if (y > blockHeight) {
+        blockHeight = y;
+      }
+    });
+
+    double pixelSize = drawSize / (max(blockWidth, blockHeight) + 2);
+    double xOffset =
+        (blockHeight > blockWidth) ? (blockHeight - blockWidth) * pixelSize / 2 : 0;
+    double yOffset =
+        (blockWidth > blockHeight) ? (blockWidth - blockHeight) * pixelSize / 2 : 0;
+
+    // Fill background
+    final paintPixelBackground = Paint();
+    paintPixelBackground.color = pixelColor;
+    paintPixelBackground.style = PaintingStyle.fill;
+    pixels.forEach((pixel) {
+      int x = pixel[0];
+      int y = pixel[1];
+      final Rect pixelBackground = Rect.fromPoints(
+          Offset(xOffset + pixelSize * (x + 1), yOffset + pixelSize * (y + 1)),
+          Offset(xOffset + pixelSize * (x + 2), yOffset + pixelSize * (y + 2)));
+      canvas.drawRect(pixelBackground, paintPixelBackground);
+    });
+
+    // Border lines
+    final paintPixelBorder = Paint();
+    paintPixelBorder.color = Colors.white;
+    paintPixelBorder.style = PaintingStyle.stroke;
+    paintPixelBorder.strokeWidth = 4;
+    pixels.forEach((pixel) {
+      int x = pixel[0];
+      int y = pixel[1];
+      final Rect rectBackground = Rect.fromPoints(
+          Offset(xOffset + pixelSize * (x + 1), yOffset + pixelSize * (y + 1)),
+          Offset(xOffset + pixelSize * (x + 2), yOffset + pixelSize * (y + 2)));
+      canvas.drawRect(rectBackground, paintPixelBorder);
+    });
+  }
+
   @override
   void paint(Canvas canvas, Size size) {
-    print('paint');
+    double drawSize = min(size.width, size.height);
+
+    // Fill background
+    final paintBackground = Paint();
+    paintBackground.color = Colors.black;
+    paintBackground.style = PaintingStyle.fill;
+
+    final Rect rectBackground = Rect.fromPoints(Offset(0, 0), Offset(drawSize, drawSize));
+    canvas.drawRect(rectBackground, paintBackground);
+
+    // Add tetrimino
+    switch (myProvider.currentTetrimino) {
+      // empty
+      case 0:
+        break;
+      // straight
+      case 1:
+        drawPixels([
+          [0, 0],
+          [1, 0],
+          [2, 0],
+          [3, 0]
+        ], canvas, drawSize, Colors.cyan);
+        break;
+      // square
+      case 2:
+        drawPixels([
+          [0, 0],
+          [0, 1],
+          [1, 0],
+          [1, 1]
+        ], canvas, drawSize, Colors.amber);
+        break;
+      // T
+      case 3:
+        drawPixels([
+          [0, 0],
+          [1, 0],
+          [2, 0],
+          [1, 1]
+        ], canvas, drawSize, Colors.purple);
+        break;
+      // L
+      case 4:
+        drawPixels([
+          [0, 0],
+          [0, 1],
+          [0, 2],
+          [1, 2]
+        ], canvas, drawSize, Colors.deepOrange);
+        break;
+      // skew
+      case 5:
+        drawPixels([
+          [0, 0],
+          [0, 1],
+          [1, 1],
+          [1, 2]
+        ], canvas, drawSize, Colors.green);
+        break;
+      default:
+    }
   }
 
   @override

lib/layout/color_theme.dart

-class ColorTheme {
-  static Map<String, Map<String, int>> colors = {
-    'default': {
-      '0': 0xffffff,
-      '1': 0xff6f43,
-      '2': 0x708cfd,
-    },
-  };
-  static int defaultColor = 0x808080;
-
-  static int getColorCode(String skin, String value) {
-    if (colors.containsKey(skin) && null != colors[skin]) {
-      Map<String, int>? skinColors = colors[skin];
-      if (null != skinColors && skinColors.containsKey(value) && null != skinColors[value]) {
-        return (skinColors[value] ?? defaultColor) | 0xFF000000;
-      }
-    }
-    return defaultColor | 0xFF000000;
-  }
-}

lib/layout/game.dart

@@ -33,36 +33,10 @@ class Game {
         TableRow(
           children: [
             Column(
-              children: [
-                Text(
-                  'X',
-                  style: TextStyle(
-                    fontSize: 40,
-                    fontWeight: FontWeight.w600,
-                    color: Colors.black,
-                  ),
-                ),
-                Text(
-                  'Y',
-                  style: TextStyle(
-                    fontSize: 15,
-                    fontWeight: FontWeight.w600,
-                    color: Colors.grey,
-                  ),
-                ),
-              ],
+              children: [],
             ),
             Column(
-              children: [
-                Text(
-                  'Z',
-                  style: TextStyle(
-                    fontSize: 20,
-                    fontWeight: FontWeight.w600,
-                    color: Colors.green,
-                  ),
-                ),
-              ],
+              children: [],
             ),
           ],
         ),

lib/provider/data.dart

@@ -32,6 +32,7 @@ class Data extends ChangeNotifier {
   // Game data
   bool _gameIsRunning = false;
   bool _gameIsFinished = false;
+  int _currentTetrimino = 0;
 
   bool get isGameRunning => _gameIsRunning;
   void updateGameIsRunning(bool gameIsRunning) {
@@ -45,6 +46,12 @@ class Data extends ChangeNotifier {
     notifyListeners();
   }
 
+  int get currentTetrimino => _currentTetrimino;
+  void updateCurrentTetrimino(int currentTetrimino) {
+    _currentTetrimino = currentTetrimino;
+    notifyListeners();
+  }
+
   void resetGame() {
     _gameIsRunning = false;
     _gameIsFinished = false;

lib/utils/game_utils.dart

+import 'dart:math';
+
 import 'package:tetrisdual/provider/data.dart';
 
 class GameUtils {
@@ -11,4 +13,12 @@ class GameUtils {
     myProvider.resetGame();
     myProvider.updateGameIsRunning(true);
   }
+
+  static void pickRandomTetrimino(Data myProvider) {
+    int newTetrimino = myProvider.currentTetrimino;
+    while (newTetrimino == myProvider.currentTetrimino) {
+      newTetrimino = Random().nextInt(5) + 1;
+    }
+    myProvider.updateCurrentTetrimino(newTetrimino);
+  }
 }