validate subgame

lib/game.dart

@@ -6,8 +6,8 @@ class TTCGame extends StatelessWidget {
   const TTCGame({
     super.key,
     required this.turn,
-    required this.cellOnTapCallback,
     required this.data,
+    this.cellOnTapCallback,
     this.cellTextStyle,
   });
 
@@ -18,7 +18,7 @@ class TTCGame extends StatelessWidget {
   final TextStyle? cellTextStyle;
 
   /// hook into end of turn cycle;
-  final Function cellOnTapCallback;
+  final void Function(int)? cellOnTapCallback;
 
   @override
   Widget build(BuildContext context) {
@@ -39,7 +39,7 @@ class GameHash extends StatelessWidget {
   const GameHash({super.key, required this.children, this.cellOnTapCallback});
   final List<Widget> children;
 
-  final Function? cellOnTapCallback;
+  final void Function(int)? cellOnTapCallback;
 
   Border _genCellBorder(
     int index, {
@@ -93,6 +93,8 @@ class HashCell extends StatelessWidget {
   @override
   Widget build(BuildContext context) => InkWell(
         onTap: stateSetCallback,
-        child: Center(child: child),
+        child: IgnorePointer(
+          child: Center(child: child),
+        ),
       );
 }

lib/main.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
-import 'clasic.dart';
+import 'package:super_tic_tac_toe/super.dart';
+import 'classic.dart';
 
 void main() {
   runApp(const MyApp());
@@ -75,7 +76,7 @@ class _MyHomePageState extends State<MyHomePage> {
           padding: const EdgeInsets.all(10),
           child: type == GameType.classicTTC
               ? const ClassicGame()
-              : const Center(child: Text("Under Construction")),
+              : const SuperGame(),
         ));
   }
 }

lib/super.dart

@@ -0,0 +1,196 @@
+import 'package:flutter/material.dart';
+import 'package:super_tic_tac_toe/game.dart';
+import 'package:super_tic_tac_toe/state.dart';
+import 'package:super_tic_tac_toe/util.dart';
+
+class SuperGame extends StatefulWidget {
+  const SuperGame({super.key});
+
+  @override
+  State<SuperGame> createState() => _SuperGameState();
+}
+
+class _SuperGameState extends State<SuperGame> {
+  TTCState turn = TTCState.x;
+  List<List<TTCState>> data = Util.emptyBoardSuper;
+
+  List<TTCState> subGameWinners = [
+    TTCState.empty,
+    TTCState.empty,
+    TTCState.empty,
+    TTCState.empty,
+    TTCState.empty,
+    TTCState.empty,
+    TTCState.empty,
+    TTCState.empty,
+    TTCState.empty,
+  ];
+  bool subGameEnded(int i) => subGameWinners[i] != TTCState.empty;
+
+  int nextPlay = -1;
+
+  void _swapTurn() {
+    switch (turn) {
+      case TTCState.x:
+        turn = TTCState.o;
+        break;
+      case TTCState.o:
+        turn = TTCState.x;
+        break;
+      default:
+        turn = TTCState.x;
+    }
+  }
+
+  TTCState _validateSubGame(int index) {
+    subGameWinners[index] = Util.checkWin(data[index]);
+    return subGameWinners[index];
+  }
+
+  bool _checkValidChoice(List<TTCState> game, int index) =>
+      game[index] == TTCState.empty;
+
+  void Function(int) subGameCellOnTapCallback(int subGame) {
+    return (int i) {
+      if (!_checkValidChoice(data[subGame], i)) {
+        showDialog(
+            context: context,
+            builder: (context) => AlertDialog(
+                  content: Text("${data[subGame][i].name.toUpperCase()}"
+                      " already claimed "
+                      "[${i % 3}, ${(i / 3).floor()}]"),
+                  actions: [
+                    ElevatedButton(
+                        onPressed: () => Navigator.pop(context),
+                        child: const Text("Close"))
+                  ],
+                ));
+        return;
+      }
+
+      nextPlay = subGameEnded(i) ? -1 : i;
+      setState(() {
+        data[subGame][i] = turn;
+        _validateSubGame(subGame);
+        _swapTurn();
+      });
+      Navigator.pop(context);
+    };
+  }
+
+  Widget _subGameDialog(int subGame) {
+    return Dialog(
+      child: Padding(
+        padding: const EdgeInsets.all(10),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Padding(
+              padding: const EdgeInsets.only(bottom: 5),
+              child: Text(
+                "${Util.stateText(turn)} select cell",
+                style: const TextStyle(fontWeight: FontWeight.bold),
+              ),
+            ),
+            TTCGame(
+              turn: turn,
+              cellOnTapCallback: subGameCellOnTapCallback(subGame),
+              data: data[subGame],
+            ),
+            Padding(
+              padding: const EdgeInsets.only(top: 5),
+              child: Row(
+                mainAxisAlignment: MainAxisAlignment.end,
+                children: [
+                  ElevatedButton(
+                      onPressed: () {
+                        Navigator.pop(context);
+                      },
+                      child: const Text("Close"))
+                ],
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  void endedSubGameNotification(int index) {
+    ScaffoldMessenger.of(context)
+      ..clearSnackBars()
+      ..showSnackBar(
+        SnackBar(
+          content: Text("${Util.stateText(subGameWinners[index])}"
+              " already won the game at "
+              "[${Util.cellAddress(index)}]"),
+        ),
+      );
+  }
+
+  void _showSubGameDialog(int i) {
+    if (nextPlay == i || nextPlay == -1) {
+      showDialog(
+        context: context,
+        builder: (context) => _subGameDialog(i),
+      );
+    } else {
+      ScaffoldMessenger.of(context)
+        ..clearSnackBars()
+        ..showSnackBar(
+          SnackBar(
+            content: Text(
+              "You can only play at [${(nextPlay % 3) + 1},"
+              "${(nextPlay / 3).floor() + 1}]",
+            ),
+          ),
+        );
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    Iterable.generate(subGameWinners.length)
+        .map((i) => subGameEnded(i))
+        .forEach(print);
+
+    return Column(
+      children: [
+        const Spacer(flex: 5),
+        Center(
+          child: Text(
+            "${Util.stateText(turn)}'s Turn",
+            style: const TextStyle(fontSize: 25),
+          ),
+        ),
+        const Spacer(flex: 1),
+        GameHash(
+            cellOnTapCallback: (i) => subGameEnded(i)
+                ? endedSubGameNotification(i)
+                : _showSubGameDialog(i),
+            children: Iterable.generate(data.length)
+                .map(
+                  (i) => DecoratedBox(
+                    decoration: BoxDecoration(
+                      color: nextPlay == i ? Colors.lightGreenAccent : null,
+                    ),
+                    child: Padding(
+                      padding: const EdgeInsets.all(15),
+                      child: !subGameEnded(i)
+                          ? TTCGame(
+                              turn: turn,
+                              data: data[i],
+                            )
+                          : Text(
+                              subGameWinners[i].name.toUpperCase(),
+                              style: const TextStyle(fontSize: 40),
+                            ),
+                    ),
+                  ),
+                )
+                .toList()),
+        const Spacer(flex: 5),
+      ],
+    );
+  }
+}

lib/util.dart

@@ -1,6 +1,34 @@
 import 'state.dart';
 
 class Util {
+  static List<TTCState> get emptyBoardClassic => [
+        TTCState.empty,
+        TTCState.empty,
+        TTCState.empty,
+        TTCState.empty,
+        TTCState.empty,
+        TTCState.empty,
+        TTCState.empty,
+        TTCState.empty,
+        TTCState.empty,
+      ];
+
+  static List<List<TTCState>> get emptyBoardSuper => [
+        emptyBoardClassic,
+        emptyBoardClassic,
+        emptyBoardClassic,
+        emptyBoardClassic,
+        emptyBoardClassic,
+        emptyBoardClassic,
+        emptyBoardClassic,
+        emptyBoardClassic,
+        emptyBoardClassic,
+      ];
+
+  static String stateText(TTCState state) => state.name.toUpperCase();
+  static String cellAddress(int index) =>
+      "${index % 3}, ${(index / 3).floor()}";
+
   static Iterable<TTCState> getRow(int index, List<TTCState> data) =>
       data.getRange(index, index + 3);
   static Iterable<TTCState> getCol(int index, List<TTCState> data) => [