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

+Improve grid display.

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

+Add grid generator, add default templates.

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

+Amélioration de l'affichage de la grille.

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

+Ajout d'un générateur de grilles et de grilles de démarrage.

generator/.gitignore

+__pycache__

generator/cell.py

+from shapes import *
+from functions import *
+
+
+class Cell:
+    # 1st char = name, 2nd = number of rotations, 3rd = number of reflections
+    s = {"s1": ["p00"],  # List of all the shapes possible, indexed by the number of cells
+         "s2": ["s00", "s10"],
+         "s3": ["l00", "l10",
+                "c00", "c10", "c20", "c30"],
+         "s4": ["O00",
+                "J00", "J10", "J20", "J30", "J01", "J11", "J21", "J31",
+                "i00", "i10",
+                "z00", "z10", "z01", "z11",
+                "t00", "t10", "t20", "t30"],
+         "s5": ["L00", "L10", "L20", "L30", "L01", "L11", "L21", "L31",
+                "T00", "T10", "T20", "T30",
+                "N00", "N10", "N20", "N30", "N01", "N11", "N21", "N31",
+                "Z00", "Z10", "Z01", "Z11",
+                "I00", "I10",
+                "P00", "P10", "P20", "P30", "P01", "P11", "P21", "P31",
+                "W00", "W10", "W20", "W30",
+                "F00", "F10", "F20", "F30", "F01", "F11", "F21", "F31",
+                "X00",
+                "Y00", "Y10", "Y20", "Y30", "Y01", "Y11", "Y21", "Y31"]}
+
+    def __init__(self, co: list, val: int):  # Initialisaiton
+        self.co = co  # Coordinates
+        self.val = val  # Value
+        self.numGroup = None  # Number of group
+        # List of possible positions
+        self.lpos = [z + 1 for z in range(self.val)]
+        self.lform = list(Cell.s["s" + str(self.val)]
+                          )  # List of possible forms
+        self.selForm = None  # Selected form
+        self.selPos = None  # Selected position
+        self.coefx = None  # Coefficient of x
+        self.coefy = None  # Coefficient of y
+
+    def give(self):  # Give a new form and/or position
+        if self.selForm == None:
+            self.selForm = select(extract(self.lform))
+        elif len(self.lpos) == 0:
+            if len(self.lform) == 0:
+                return False
+            else:
+                self.selForm = select(extract(self.lform))
+                self.lpos = [z + 1 for z in range(self.val)]
+        self.selPos = extract(self.lpos)
+
+        z = 0  # Determination of the position of the selected form corresponding to the number
+        for y in range(len(self.selForm)):
+            for x in range(len(self.selForm[0])):
+                if self.selForm[y][x] == 1:
+                    z += 1
+                    if z == self.selPos:
+                        # Coordinates of the point inside the form
+                        coForme = [y, x]
+
+        self.coefx = self.co[1] - coForme[1]
+        self.coefy = self.co[0] - coForme[0]
+
+        return True
+
+    def getSelForm(self):
+        return self.selForm
+
+    def getCoefx(self):
+        return self.coefx
+
+    def getCoefy(self):
+        return self.coefy
+
+    def getNum(self):
+        return self.numGroup
+
+    def setNum(self, num: int):
+        self.numGroup = num

generator/cell2.py

+class Cell2:
+    def __init__(self, co: tuple):
+        self.pos = [1, 2, 3, 4, 5]
+        self.num = 0
+        self.co = co
+
+    def give(self):
+        if len(self.pos) == 0:
+            return False
+        else:
+            self.num = self.pos[0]
+            self.pos = self.pos[1:]
+            return True
+
+    def getNum(self):
+        return self.num
+
+    def getCo(self):
+        return self.co

generator/functions.py

+from random import choice
+
+
+def isFin(m, arg):
+    '''Check if a matrix (m) has a cell with arg in it'''
+    for i in range(len(m)):
+        for j in range(len(m[0])):
+            if m[i][j] == arg:
+                return True
+    return False
+
+
+def next(t, tform):
+    '''Find the next cell without any form in it, and with the biggest number'''
+    a = [0, None, None]
+    for i in range(len(t)):
+        for j in range(len(t[0])):
+            if tform[i][j] == 0:
+                if t[i][j] > a[0]:
+                    a[0] = t[i][j]
+                    a[1] = i
+                    a[2] = j
+    return a
+
+
+def inGrid(cx, cy, tf, tm):
+    '''Check if a matrix f can fit in a matrix m with the coefficients cx and cy'''
+    if cx < 0 or cy < 0 or tf[0] + cy > tm[0] or tf[1] + cx > tm[1]:
+        return False
+    return True
+
+
+def with0(fo, gr, cx, cy):
+    '''Check if a form can fit in a formTab'''
+    for i in range(len(fo)):
+        for j in range(len(fo[0])):
+            if fo[i][j] == 1 and gr[i + cy][j + cx] != 0:
+                return False
+    return True
+
+
+def allNums(fo, tab, cx, cy):
+    '''Check if all the nums in the form are from 1 to n'''
+    liste = []
+    for i in range(len(fo)):
+        for j in range(len(fo[0])):
+            if fo[i][j] == 1:
+                liste.append(tab[i + cy][j + cx])
+
+    liste.sort()
+    if liste[0] != 1:
+        return False
+    for i in range(1, len(liste)):
+        if liste[i] - liste[i - 1] != 1:
+            return False
+    return True
+
+
+def testNear(co, tab):
+    '''Check if the number at co is not present in the surrounding cells'''
+    for i in range(-1, 2):
+        for j in range(-1, 2):
+            if i != 0 or j != 0:
+                y = co[0] + i
+                x = co[1] + j
+                if y >= 0 and x >= 0 and len(tab) > y and len(tab[0]) > x:
+                    if tab[y][x] == tab[co[0]][co[1]]:
+                        return False
+    return True
+
+
+def testForm(co, tab, formTab):
+    '''Check if the numbers in the form are valid'''
+    l = []
+    for i in range(-4, 5):
+        for j in range(-4, 5):
+            y = co[0] + i
+            x = co[1] + j
+            if y >= 0 and x >= 0 and len(tab) > y and len(tab[0]) > x:
+                if 0 <= abs(i) + abs(j) < 5:
+                    if formTab[y][x] == formTab[co[0]][co[1]]:
+                        l.append(tab[y][x])
+
+    l.sort()
+    if l[-1] > len(l):
+        return False
+    l = [elt for elt in l if elt != 0]
+    for i in range(1, len(l)):
+        if l[i] == l[i - 1]:
+            return False
+    return True
+
+
+def next2(tab):
+    '''Find the next cell to put a number in'''
+    for j in range(len(tab)):
+        for i in range(len(tab[0])):
+            if tab[j][i] == 0:
+                return j, i
+
+
+def extract(liste):
+    '''Choose randomly an item from a list, remove it, and return it'''
+    if len(liste) > 0:
+        a = choice(liste)
+        liste.remove(a)
+        return a
+    return None

generator/generate.py

+from math import floor
+from tectonic import *
+
+
+def build_and_print_grid(size_x, size_y):
+    print('building ' + str(size_x) + 'x' + str(size_y) + '...')
+    cells_count = size_x * size_y
+
+    if cells_count > 47:
+        print('too big')
+    else:
+        tab, formTab = generate(size_x, size_y)
+        if tab == 'Error':
+            error = ''
+            for elt in formTab:
+                for i in elt:
+                    error += str(i)
+            print(
+                'Error : no shape placement configuration found - Code error : ' + str(size_y) + str(size_x) + error)
+        else:
+            print('values: ' + str(tab))
+            print('blocks: ' + str(formTab))
+
+            # size
+            template = str(size_x)+'x'+str(size_y)
+            template += ';'
+
+            # blocks
+            max_block_index = 0
+            for line in formTab:
+                for block in line:
+                    template += chr(block+64)
+                    if (block > max_block_index):
+                        max_block_index = block
+            template += ';'
+
+            # values
+            empty_cells_count = 0
+            for line in tab:
+                for cell in line:
+                    template += str(cell)
+                    if (cell == 0):
+                        empty_cells_count += 1
+
+            size = ''
+            if (cells_count < 26):  # < 5x5
+                size = 'small'
+            else:
+                if (cells_count < 37): # < 6x6
+                    size = 'medium'
+                else:
+                    size = 'large'
+
+            ratio = floor(100 * empty_cells_count / cells_count)
+
+            level = ''
+            if (ratio < 70):  # < 5x5
+                level = 'easy'
+            else:
+                if (ratio < 80): # < 6x6
+                    level = 'medium'
+                else:
+                    level = 'hard'
+
+            debug = ''
+            debug += ' (size:'+size+')'
+            debug += ' (level:'+level+')'
+            # debug += ' (blocks:' + str(max_block_index)+')'
+            # debug += ' (empty:'+str(empty_cells_count)+')'
+            # debug += ' (ratio:'+str(ratio)+')'
+
+            print('template:' + debug + ' ' + template)
+
+
+size_min = 4
+size_max = 9
+
+for count in range(5):
+    for size_x in range(size_min, size_max + 1):
+        for size_y in range(size_min, size_max + 1):
+            build_and_print_grid(size_x, size_y)

generator/generate.sh

+#!/bin/bash -i
+
+python3 ./generate.py

generator/shapes.py

+c = {"p": [[1]],  # 1
+
+     "s": [[1, 1]],  # 2
+
+     "l": [[1, 1, 1]],  # 3
+     "c": [[1, 1], [1, 0]],
+
+     "O": [[1, 1], [1, 1]],  # 4
+     "J": [[1, 1, 1], [1, 0, 0]],
+     "i": [[1, 1, 1, 1]],
+     "z": [[1, 1, 0], [0, 1, 1]],
+     "t": [[1, 1, 1], [0, 1, 0]],
+
+     "L": [[1, 1, 1, 1], [1, 0, 0, 0]],  # 5
+     "T": [[1, 0, 0], [1, 1, 1], [1, 0, 0]],
+     "N": [[0, 1, 1, 1], [1, 1, 0, 0]],
+     "Z": [[0, 0, 1], [1, 1, 1], [1, 0, 0]],
+     "I": [[1, 1, 1, 1, 1]],
+     "P": [[1, 1, 1], [1, 1, 0]],
+     "W": [[1, 1, 0], [0, 1, 1], [0, 0, 1]],
+     "F": [[0, 1, 0], [1, 1, 1], [0, 0, 1]],
+     "X": [[0, 1, 0], [1, 1, 1], [0, 1, 0]],
+     "Y": [[1, 1, 1, 1], [0, 1, 0, 0]]}
+
+
+def select(name):
+    na = name[0]
+    ro = int(name[1])
+    re = int(name[2])
+    ans = c[na]
+    for i in range(ro):
+        ans = rotate(ans)
+    for i in range(re):
+        ans = reflect(ans)
+    return ans
+
+
+def rotate(m):
+    return [[m[len(m) - j - 1][i] for j in range(len(m))] for i in range(len(m[0]))]
+
+
+def reflect(m):
+    return m[::-1]

generator/solver.py

+from cell2 import *
+from functions import *
+
+
+def numOfSol(tab, formTab):
+    all = []
+    c = True
+    state = True
+    nbSol = 0
+    while len(all) > 0 or c:
+        c = False
+        if state:
+            a = next2(tab)
+            if a != None:
+                current = a
+                all.append(Cell2(current))  # Creation of a new element
+            state = False
+        current = all[-1].getCo()
+
+        if all[-1].give():
+            n = all[-1].getNum()
+            tab[current[0]][current[1]] = n
+            if testNear(current, tab) and testForm(current, tab, formTab):
+                state = True
+            else:
+                tab[current[0]][current[1]] = 0
+        else:
+            tab[current[0]][current[1]] = 0
+            all.pop()
+
+        if not isFin(tab, 0):
+            nbSol += 1
+
+    return nbSol == 1

generator/tectonic.py

+from random import randint, choice
+from cell import *
+from solver import *
+from functions import *
+
+
+def generate(x, y) -> list:
+
+    xMatrice = x
+    yMatrice = y
+
+    #### Phase 1 : Creation of a matrix of numbers ####
+
+    tab = [[0 for i in range(xMatrice)] for j in range(
+        yMatrice)]  # Creation of the matrix (empty)
+    for i in range(yMatrice):
+        for j in range(xMatrice):
+            cond = True
+            while cond:
+                cond = False
+                nb = randint(1, 5)
+                for k in range(-1, 2):
+                    for l in range(-1, 2):
+                        if i + k >= 0 and i + k < yMatrice and j + l >= 0 and j + l < xMatrice and nb == tab[k + i][l + j]:
+                            cond = True
+            tab[i][j] = nb
+
+    # Counting occurrences of numbers in the matrix
+    l = [[1, 0], [2, 0], [3, 0], [4, 0], [5, 0]]
+    for i in range(yMatrice):
+        for j in range(xMatrice):
+            a = tab[i][j]
+            l[a - 1][1] += 1
+
+    for i in range(1, len(l)):  # Sort occurrences in ascending order
+        j = i
+        while l[j][1] > l[j - 1][1] and j > 0:
+            l[j], l[j - 1] = l[j - 1], l[j]
+            j -= 1
+
+    t2 = [[0 for i in range(xMatrice)] for j in range(yMatrice)]
+    # Exchange of the numbers to respect the rule ( nb 1 >= nb 2 >= nb 3 >= nb 4 >= nb 5)
+    for k in range(len(l)):
+        for i in range(yMatrice):
+            for j in range(xMatrice):
+                if tab[i][j] == l[k][0]:
+                    t2[i][j] = k + 1
+    tab = list(t2)
+
+    #### Phase 2 : Setting up shapes ####
+
+    formTab = [[0 for i in range(xMatrice)] for j in range(
+        yMatrice)]  # Creation of the form matrix
+    all = []
+    tailleMatrice = [yMatrice, xMatrice]
+    state = True
+    while isFin(formTab, 0):
+        if state:
+            current = next(tab, formTab)
+            # Creation of a new element
+            all.append(Cell(current[1:], current[0]))
+            state = False
+
+        if all[-1].give():  # See if the element is finished
+            forme = all[-1].getSelForm()  # Retrieving the shape of the element
+            # Retrieving of the size of the form
+            tailleForme = len(forme), len(forme[0])
+            # Retrieving of the coefficient in x of the element
+            coefx = all[-1].getCoefx()
+            # Retrieving of the coefficient in y of the element
+            coefy = all[-1].getCoefy()
+
+            if inGrid(coefx, coefy, tailleForme, tailleMatrice):  # Verifications
+                if with0(forme, formTab, coefx, coefy):
+                    if allNums(forme, tab, coefx, coefy):
+                        n = len(all)
+                        # Affectation of the number of the form
+                        all[-1].setNum(n)
+                        for y in range(tailleForme[0]):
+                            for x in range(tailleForme[1]):
+                                if forme[y][x] == 1:
+                                    formTab[y + coefy][x + coefx] = n
+                        state = True
+        else:
+            all.pop()
+            if len(all) == 0:
+                return 'Error', tab
+            for y in range(len(tab)):
+                for x in range(len(tab[0])):
+                    if all[-1].getNum() == formTab[y][x]:
+                        formTab[y][x] = 0
+
+    ### Phase 3 : Clearing some cells ###
+
+    tabCheck = [[False for i in range(xMatrice)] for j in range(yMatrice)]
+    tabNumber = [[(j, i) for i in range(xMatrice)] for j in range(yMatrice)]
+    while isFin(tabCheck, False):
+        y, x = choice(choice(tabNumber))
+        if tabCheck[y][x] == False:
+            save = tab[y][x]
+            tab[y][x] = 0
+            if not numOfSol(tab, formTab):
+                tab[y][x] = save
+            tabCheck[y][x] = True
+
+    return tab, formTab

lib/data/game_data.dart

@@ -7,44 +7,185 @@ class GameData {
     // },
     'small': {
       'easy': [
-        // ok
-        '5x5;AABBBAABBCADECCDDCCFGGGGG;0205030001000300000040003',
+        '4x4;AAAACADBCCBBCCBB;0004000530200004',
+        '4x4;AAACAACCBBCDBBBD;0140230000000500',
+        '4x4;BBAABBAACBADCCCC;0050204000000420',
+        '4x4;BBAABBAACBADCCCD;2001100040000100',
+        '4x4;CAAACAABCBBBCCBD;0001052020053000',
+        '4x4;DDCCAACCAABBABBB;0003304002034000',
+        '4x5;BAAEBBAABBCADDCCDDCC;25000023000000302100',
+        '4x5;EAAAAABBCBBBCCDDCCDD;02100300021000000401',
+        '4x6;AAAEAAEEBBBECBBDCCDDCCDD;020000304500000005052101',
+        '4x6;DDAADDAABBBABBEECCEEFCCC;205000010230000103000510',
+        '4x6;EAAAEEAAEBCCBBCCBBCDDDDD;052020400010030002020430',
+        '5x4;DDDAABBAAABBCCEBCCCE;00050140310310020000',
+        '5x5;AAFBBAAEBBAEEEBCCCDDCCDDD;0300414030000020023004000',
+        '5x5;BBAAABBAAEDBCEEDDCCCDDFCG;0000140040120000400520000',
+        '6x4;BBBAEEBBAAEEDAACCCDDDDCC;012031400000000000504004',
+        '6x4;DAABBBDAABBEDACCEEDDCCCE;051305400000000040300300',
       ],
       'medium': [
-        // duplicate // to replace
-        '5x5;AAABCAADBBEEEEBEFFFBEEGGG;1000002004504000000000000',
+        '4x4;AACCBAACBBACBBDD;0020400000001001',
+        '4x4;CCAACAAACDDBBBBB;0030200030000040',
+        '4x5;BAAEBBAACBBACCDDCCDD;00201003400000001020',
+        '4x5;BBBBAABDAAADCCCDCCDD;40100300000000045010',
+        '4x5;DDAABDAEBAAEBCCCBBCC;03000040000250000003',
+        '4x5;DDAADAABDABBCBBECCCC;20040000300400005000',
+        '4x5;DDDBAABBAABBACCCCCEE;20005004020000500002',
+        '4x6;BAAABBAAEBFCEBFCDDCCDDDC;000440001000000400005040',
+        '4x6;EEAAEAAAFBBDBBBDCCCDCCDD;100200300000000210002005',
+        '4x6;EEACEAACBBACBBACFBDDFFDD;305020000000100000000030',
+        '4x6;EEBBEAABAAABCDDBCCDDCCFD;010105000005000050400002',
+        '4x6;EEEFABBBAABBAACCDCCCDDDD;000000050200000500003041',
+        '5x4;AAAABACEEBDCCBBDDCCB;01405000000040030000',
+        '5x4;AAABBAABBBCCCDDECCDD;20040300002042000000',
+        '5x4;AADDBAAADBCEEBBCCCCB;00000304020000050300',
+        '5x4;EAADDAAADDBBBCCBBCCC;00201000000500401020',
+        '6x4;AAAFDDAABBBDEBBCCDEECCCD;000000300043000010003000',
+        '6x4;BFAAAEBBAAEEBBCCCCDDDDDC;000000400000100004403000',
+        '6x4;EEAAADEBAADDFBBCCDBBCCCD;000000003020000005040040',
+        '6x4;FABBBBAAABEEACCCEDCCDDDD;040040020000300204000000',
+        '6x4;FBBBAABBCAADEECADDECCCDD;000000005310020003100000',
+        '6x4;FDAAAABDDDACBBDECCBBEECC;030400000005300002000000',
       ],
       'hard': [
-        // to check
-        '5x5;AAABCAADBBEEEEBEFFFBEEGGG;1000002004504000000000000',
+        '4x5;DDDDAABBAABBEABCCCCC;04000000305000000005',
+        '5x4;DDDBEDABBBAAABCACCCC;00020000000200040100',
+        '5x4;EAAAACCCCAFBBDDBBBDD;00040400000000303000',
+        '5x5;AAAEEAABBEBBBDFCCGDDCCCDD;0000050000200305000000200',
+        '5x5;ABBBBAADBFAADDFCCCDDCCEEE;1003005000000004000300000',
+        '5x5;DDAAADDAAFEBBBFEBBCCEGCCC;0100500000000000003400000',
+        '5x5;EEADDEAADDCAABBCCCBBGCFFB;0050100030000020000400000',
+        '5x5;GAAAACCADDCCBDDEEBBFEEBBF;0052002000000040000000000',
+        '5x5;GABBBAAABBFCAEEFCDDDCCCDD;0013003000000000405000000',
       ],
     },
     'medium': {
       'easy': [
-        // to check
-        '8x5;ABBBBCDDAABECCDDFAAECCGDFFEEHHGGFFEHHHIG;0005005040300404020500001040000002000500',
+        '4x7;AABBAABBDACBDCCCDDCEFDEEFFEE;0402300000051000300000002015',
+        '4x8;BBBABBAACCCACCEADEEEDDFEDDFFGGFF;02055100000001000300000530100005',
+        '7x4;GCCAABBCCCAABBDDDAEEBDDFFEEE;0000052540214003005014000040',
       ],
       'medium': [
-        // to check
-        '8x5;AABBCCCDAABBCCDDAEBFFGDHIIIFFJJHIIKFJJJH;2020003000000000003050005000000000001050',
+        '4x7;AAAAAEEEBBBECCBBDCCCDDFFGDDF;1032000001000200000504000000',
+        '4x7;AABBAABBCADBCCDDCCDDFEEEFFEE;1004005000000300205000000102',
+        '4x7;BBBBAABDAAADCFFDCFDDCCEECEEE;4000005000010000005001000203',
+        '4x7;EEAAFEEAFFBAFBBACCBBCCDDCDDD;0205000000030050000000051001',
+        '4x8;AAAACABBCCBBCCDBDDDDFFGGFFEEFEEE;00044000050300040200000000405010',
+        '4x8;AAAFAAFFBBBFBBCCDDCCDDCEDGEEGGEE;00003004000120400500000003510000',
+        '4x8;AAAFBAFFBACFBBCCEBCCEDDDEDDGEEGG;00010400300320000000005000002002',
+        '4x8;AAHBAAABCCCBCCBBFDDDFFDDEEEGEEGG;00000035000034100000001020500010',
+        '4x8;FFAHFFAABBAABBCCGBCCGEECDDEEDDDE;00000030000500300040000004003005',
+        '4x8;FFFABFAABAAGBBGGDBCCDECCDEECDDEE;01005032000000003000000000142020',
+        '4x8;FFFAFAAAGGACBBCCBBBCHDDCDDEEDEEE;10000000204000003000000220050302',
+        '4x9;AAACAACCBCCEBBEEDBBEDGFEDGFHDGFHDGFF;350000100400000350000300000000000004',
+        '4x9;AAACAACCBCCHBBBHDDBEDDEEFDEEFFGGFFGG;320100400000400000000040010000000303',
+        '4x9;HHAAAAABGGBBGGBBCCDDCDDFCDFFCEEFEEEF;000000104050000050020004003000005025',
+        '5x6;AABBBAADBBGADDDGCCCDFCCEEFFEEE;000400300000200050000000320050',
+        '5x6;AAFFBAAFFBACCCBGCCBBDDDEEDDEEE;402003000000000000400530000150',
+        '5x6;BAAAABFFFABBCCCBDCCGHDEEEDDDEE;400040000005005000000024004000',
+        '5x6;BGAAABBAACBBFCCDFFCCDDFEEDDEEE;000054031050003000000400510000',
+        '5x6;GABBBAABBFCAAFFCCCEFCDDEEDDDEE;000300205000000005000000350100',
+        '5x6;GBBBHGAABBAACEEACCEEDDCCFDDDFF;040000525004000005000100100000',
+        '5x7;AAABBAABBBEGGJFECCFFECCDFECDDDHHDII;02501000400000040540000000050400000',
+        '5x7;BBBAABBDAAGDDCAGDCCIEDCCFEEHFFEEHFF;00002040000300010030040002005000101',
+        '5x7;DGGABDGAABDAABBDCCCBDCCEEFFFEEFFHHE;00000000050010200000500100400250000',
+        '5x7;GAAHHGAABBGABBBECCCCECFDDEFFDDEEFFD;00301040000000000400010504000000014',
+        '5x7;HAAGGHABBGAACBBCCCDBECDDDEEFFDEEFFF;04003000000000540001000500400010102',
+        '6x5;AAAACCFFABCCFFBBECDDDBEEDDGBEE;052001000000000003000201030000',
+        '6x5;AABBBBFAACDBFFACDDFEECCDGEEECD;050054000000002025040003000000',
+        '6x5;ABBFFCAABBFCAABECCDDEEECDDDEGG;003000100002300000000000034510',
+        '6x5;FFFBBGAFBBCCAADBCCADDEECADDEEE;402000000400400000303000000040',
+        '6x5;GGBBBBAAAEEBAACEEDCCCCDDFFFFDD;000000050005000040000105010004',
+        '6x6;AAAAHBCCCABBDDCCEBDDDEEBFFEEGGFFFGGG;050000020000400030000054000100020001',
+        '6x6;BBAAAACBBBHACCCCDDEEDDDGEEFFGGEFFFGG;000003400000020500000000100500404002',
+        '6x6;BBAAGGBBAAGGBCCADDCCCFDDHEEFFDHEEEFF;000003102002005000200004040300000010',
+        '6x6;CAABBBCCAABBECADDDECHDDGEEFFGGEFFFGG;000300404050000000000400030023004000',
+        '7x4;DDDAAEEBBDAAEEBBGACFFBCCCCFF;4000500000004100005002000000',
+        '7x4;EEEAABGCEAAABFCCDDBBFCCDDDBF;0000000001005052050000000003',
+        '7x4;GAADBBBAAADDBBFCCDDEEFFCCCEE;0000502320004000000012000000',
+        '7x5;AAAFFFFAACCBBHECCCBBBEEDDDGGEEDDIGG;05000033402000000003000050000200000',
+        '7x5;BGGGGAABBBCCAAEBCCCDAEEFFFDDHEEFFDD;00300200000004000005050050000000034',
+        '7x5;GBBBBHHGAABCCCGAAEECCDDAEEEFDDDFFFF;00200020500300000000104000040010100',
+        '8x4;ABBEEECCAABBECCCADDBEFFGADDDFFFG;00000042300000300003000040200002',
+        '8x4;CAAAFFBBCCAAFFBBCCDEEEBGDDDDEEGG;05000005300010300000400004000000',
+        '8x4;FAAABBBCFFAABBCCGDDEEECCGGDDDEEH;00300000000005053020000400005000',
+        '8x4;FAAABBBGFFAABBCGFDDDEECCDDHEEECC;00502030400000000520001000003000',
+        '9x4;FAAAABBHHFGACBBBEEFGGCCDDEEFFGCCDDDE;000001000100004003000200000054003002',
+        '9x4;HHAAABBCCGAADBBBCCGGDDEEFFCGDDEEEFFF;005301000000000200000000104000500050',
       ],
       'hard': [
-        // to check
-        '8x5;AABCCCDDEEBBCCDDEEFFFGGDEHHFFGGGHHHIIIII;0000100500000200000500014030005001001000',
+        '4x7;AAGBACCBACBBACBDECDDEEFDEFFD;4000000300000000000000053000',
+        '4x7;EEAGEAAAEBBADBBBDDDFCCDFCCCH;0200000000000040200000002000',
+        '4x7;GEEEBBAEBBAHCBAACCDACDDFCDDF;0000400400000004000030400000',
+        '4x9;FFFHBAFHBAAABBACBDICGDCCGDDCGDEEGEEE;100000000003300000000000300000000050',
+        '4x9;GGGBGABBAAABACEBCCEEDCCEDHHEDDFFDFFF;010000040000400200000400000000000013',
+        '4x9;HHAAAAABCBBBCCCBEECDGEEDGGEDFFFDFFID;000000000004500000050000302000400000',
+        '4x9;HHFFAAFFGAAAGBCCGBBCDDBCDEBCDEEIDEEI;000300000020000000010000000054000050',
+        '5x6;BAAGCBAAGCBBACCDBFCEDDFEEDDFEE;005001000350000000044000000000',
+        '5x6;EAAAHEEGAAECGBBCCBBBCDDDDCDFFF;000300000020000400301000000200',
+        '5x7;FFFAAFAAAGHCBBGHCBBGECCBGEECDDEEDDD;30100000000005003000000004000100030',
+        '5x7;GGGBBGAABBAAABDCCCDDCCDDEFFHEEFFFEE;40004000020000000000000303000000202',
+        '5x7;HAAAGHAAGGFFBBCFBBCCFDBCCDDEEEDDIEE;10002000000300000000040102000000000',
+        '6x5;AAAFCGAABFCCDBBFCCDDBBEEDDEEEH;040040500000000200000000205000',
+        '6x5;AGBBCCAAABBCFADBHCFDDEECFDDEEE;000000500002000000005000000010',
+        '6x5;GGAABBAAAFBECCFFBECCDDBEHCDDDE;100000050050100000000001040000',
+        '6x6;BAAAAHBBBACHDBGGCCDDGGFCDEEEFCDEEFFF;000000400400000000100100000020400000',
+        '6x6;HHAABBHAAABBFFFCCBFDDECCDDGEECDGGGEE;000305040000000010000003030000100000',
+        '6x6;IAACCFBAAACFBBBBCFEEEGCFDEEGGHDDDDGH;050000000004400001000000500000104000',
+        '7x5;CCDAAABCDDGAABCDGGEBBCDFFEBHFFFEEEH;04000005000101000000300000004000000',
+        '8x4;CAAFFFBBCCAAFDBBGCADDDEBGCHDEEEE;04500005500000000000504000000000',
+        '9x4;AAAABBBDDAEHBBCDDDEEFFFCCCCEEFFGGGGG;030010000000000205500300000000002000',
       ],
     },
     'large': {
       'easy': [
-        // duplicate // to replace
-        '5x11;ABBCCDBBCCDDBCEDDFFEGGHEEGGHEIJGHIIJHHKIJLKKILLKMMLLMMM;0003040004000000200000030200000400000003300000400520000',
+        '5x8;BBBIIAABBCAADDCADDCCEDFFCEEEFFEGGHFGGGHH;0200250530020000000400000304300100450000',
       ],
       'medium': [
-        // to check
-        '5x11;ABBCCDBBCCDDBCEDDFFEGGHEEGGHEIJGHIIJHHKIJLKKILLKMMLLMMM;0003040004000000200000030200000400000003300000400520000',
+        '5x8;AAABBAABBDICCBDCCHHDCEHFDEEHFDEEGFFGGGGF;1005000000002003000100002000002053030000',
+        '5x8;AHHHHAAAADBBBCDBBCCDEICCDEEEFDGGEFFGGGFF;0001040004000000400000000500000004240200',
+        '5x8;BBBAABBAAHDDAHHDCCHEDCCEEDCIEEFFFGGFFGGG;0005050000020040000100004000200000010024',
+        '5x8;HABBBHAJBIHAABIGGACCGGDCCEDDDCEEDFFEEFFF;0003004000300000000002000040042000000203',
+        '5x8;IAABBAABBBADDDDCCDEECCCEEFFFFEFHHGGHHGGG;0000420030004200000503400020020000000050',
+        '5x8;IIBBBAABBDAAADDCCCDDCCFFFEEEFFHEEGGHHGGG;2000450003100040401000020000000400000305',
+        '5x9;AJBBBAABBCDAACCDDCCEDDEEEGGEFFGGHFFGIHHFIIIHH;003020050040000000000000000300000015000301040',
+        '5x9;HHHJBHABBBAABCKAACCCDDCELDDEEEDFFGEFFGGGMFGII;004001000040000000040400005050000003000402000',
+        '6x7;AABBBBAACCBJACCCEEHDDEEEHHDDDGHFFGGGIIFFFG;450040000000000102000300040020000030020000',
+        '6x7;BAAAAIBBBBAIDDEECCDDEECCDFEGCHFFGGHHFFGGHH;001050403000100000000004500000000000015050',
+        '6x8;AAJJJDAAABBDCCFBBDCCFFBDCEFFHDGEEEHHGGEHHIGGIIII;050200000003500004000000100000000200000000200430',
+        '6x8;JAAAAAJBCCDDJBBCDDBBFCCDEEFFFGEEEFGGHHIIIGHHHIIG;201000000003000000200000000300200000000243030000',
+        '6x8;JAAABDJAABBDCCBBKDCCEEDDCGEEFFGGEFFFGHHHIIGHHIII;001000200054000000500000000010305004000300500004',
+        '6x8;KKAACCAAABCCDDEBBCDDEEBBDGEEFFGGGFFFIGHHHJIIHHJJ;000001402030010000050340000000000001000002003010',
+        '7x6;AABCCCIAABBCCIADDBBHHFDDEEEHFFDEEGGJFFGGGK;000010020400001000002230500000000300004000',
+        '7x6;CCIIAAACCBBBAACFFBBDDFFEHDDDFEEHHGGEEHHGGG;200003000501200000000100000000003050000400',
+        '7x6;HHABBBJHHAABBEICFAAEEICFDDEECCFDDGGCFFDGGG;300205010030020500000000003000100010000002',
+        '8x5;HHAEBBBIHHAEBBCCDAAECCCGDDAEEFGGDDFFFFGG;0300500000004000003000000002050043000002',
+        '8x6;AAAADDDDEEBACCDJEEBBCCCJEBBIFFFJGGIIIHFFGGGHHHHK;040103000050000030000000000010001000000002500100',
+        '8x6;AACCCBBBKAACCEBBDDAFFEEIDDFFFEJIDHHGGEJIHHHGGGII;500003020005000000000000000000034002000420004000',
+        '8x6;JJAAAAABJCEEEDBBCCEEDDBBHCCFDDKKHHFFIGGGHFFIIIGG;100020000000050100000004000020000000003000032002',
       ],
       'hard': [
-        // duplicate // to replace
-        '5x11;ABBCCDBBCCDDBCEDDFFEGGHEEGGHEIJGHIIJHHKIJLKKILLKMMLLMMM;0003040004000000200000030200000400000003300000400520000',
+        '5x8;GGIIAHGGAAHHBAACBBBBCCDDDCCDDFEEJFFEEEFF;0001300000000000000005004000000002020005',
+        '5x9;BAAAABACCEBCCCEBBJJEDDDEEDDFFGIFFGGIIFGGHHHHH;050000003000000200020105003000050000000004000',
+        '5x9;BBIIJBBIAADBKAADDCCADCCEEDCEEEFFFFGFHHGGHHHGG;000000200000004000000030040001050000001050004',
+        '5x9;HAAABHHAABCHDBBCDDDBCIIDFCEIFFCEFFGEEJGGEJJGG;000101000530000001000000000004000000005200030',
+        '5x9;HCCAAHCAAAHCJBBHCJBBIIJDBIFDDDFFDEEFFEEEGGGGG;010310002000000000000000000040000000000140300',
+        '5x9;IIABBIAABBAACCBJCCCDJEEDDEEDDFEGFFFGGGFHGHHHH;010000400000004050000000020000000000000120400',
+        '5x9;JBAHHBBAHHBBACCDAACCDDKGCIDDGEIIGGEIFFGEFFFEE;000020230000000020030000000000000020000040203',
+        '6x7;BAAAAIBBCAEGBBCCEGFDCCEGFDDDEGFFDHEGFHHHHJ;210000000003000000200400000030000020005000',
+        '6x7;HAAAAIHHBBAICCBBEECCDBEEFCDDDEFFFDGGFJJGGG;102040000000500002005000000000000000000025',
+        '6x8;BBAAAAJBBBADJCCCDDKCCDDFKEEEHFEEHHHFGGGHFFGGIIIL;000503000000000500000000000000000100054004000000',
+        '7x6;AAABBBBAAIICDBFFCCCDJEFFCKDDEEFGGGDEEGGHHH;030430000000000400000000000004540001000000',
+        '7x6;HHHABBJHAAAABBIFFCCEBIDFCCEEDDFGCEEDDFGGGG;300002000000500000000000040320100000000400',
+        '8x5;DAAAAIBBDDACCCBBDDEEECCBGGGEEFFFGGHHHFFJ;0000000540000001010000000000002005100000',
+        '8x5;HAAABBCJHEEAABCCDDEEEBBCIDDFFGGCIDFFFGGG;0050000000000005050400000000000004100501',
+        '8x5;HHHBBAADCCBBBADDCCGGAADDCGGEFFFFIIIEEEEF;0200050100000404500000200000000000000500',
+        '8x5;IAHHHBDDIAABBBBDEAACCCCDEEEFFCGDEFFFGGGG;0003030205000000000000000005000001030000',
+        '8x6;AAAACJDIAEBCCJDIEEBCCJDIEBBFFDDIEBGGFFHHKGGGFHHH;002000000000000050100100000000400000005100002040',
+        '9x5;GGGGBCIIIAABBBCCCJADDBKKCHJADDEEFFHHADEEEFFFH;020001003100000050200000000050000000000400000',
+        '9x5;HHBBKCIIIHABBBCCCFHAAAACJFFDDEEEEJGFDDDEGGGGF;402000000000000003100000000300000000004000002',
+        '9x5;JJBBKAAAIDJBBBAACIDDGGGGCCIHDDEECCFFHHHEEEFFF;000005000030000000014000000000000000100000403',
       ],
     },
   };

lib/ui/pages/game.dart

@@ -29,6 +29,11 @@ class PageGame extends StatelessWidget {
               const GameBoardWidget(),
               const SizedBox(height: 8),
               const GameBottomWidget(),
+              //   StyledButton.text(
+              //     onPressed: () => SuguruSolver.checkAllTemplates(),
+              //     caption: '[debug] test all templates',
+              //     color: Colors.red,
+              //   ),
               const Expanded(child: SizedBox.shrink()),
               currentActivity.isFinished ? const GameEndWidget() : const SizedBox.shrink(),
             ],

lib/ui/widgets/game/cell.dart

-
 import 'package:flutter/material.dart';
 import 'package:flutter_custom_toolbox/flutter_toolbox.dart';
 
@@ -76,19 +75,35 @@ class CellWidget extends StatelessWidget {
     return 'assets/ui/cell_empty.png';
   }
 
+  Color getBaseColorFromBlockId(String blockId) {
+    const List<Color> paletteColors = [
+      Color.fromRGBO(0xbe, 0x7f, 0x51, 1),
+      Color.fromRGBO(0x50, 0x72, 0x8b, 1),
+      Color.fromRGBO(0xae, 0x70, 0x6f, 1),
+      Color.fromRGBO(0x91, 0x61, 0x87, 1),
+      Color.fromRGBO(0xe1, 0x8a, 0x2b, 1),
+      Color.fromRGBO(0x88, 0x77, 0x6d, 1),
+      Color.fromRGBO(0xd4, 0xbe, 0x1e, 1),
+      Color.fromRGBO(0xba, 0x96, 0x3a, 1),
+      Color.fromRGBO(0xa2, 0x9a, 0x5c, 1),
+    ];
+
+    final int blockIdValue = blockId.codeUnits.first - 'A'.codeUnits.first;
+    return paletteColors[blockIdValue % paletteColors.length].lighten(20);
+  }
+
   // Compute cell background color, from cell state
   Color getBackgroundColor(Activity activity) {
-    final Color editableCellColor = Colors.grey.shade100;
     final Color editableCellColorConflict = Colors.pink.shade100;
-    final Color fixedCellColor = Colors.grey.shade300;
+    final int fixedCellColorDarkAmount = 10;
     final Color fixedCellColorConflict = Colors.pink.shade200;
     final Color editableAnimated = Colors.green.shade200;
     final Color fixedAnimated = Colors.green.shade300;
 
-    Color backgroundColor = editableCellColor;
+    Color backgroundColor = getBaseColorFromBlockId(cell.blockId);
 
     if (cell.isFixed == true) {
-      backgroundColor = fixedCellColor;
+      backgroundColor = backgroundColor.darken(fixedCellColorDarkAmount);
     }
 
     final int conflictsCount = activity.boardConflicts[cell.location.row][cell.location.col];
@@ -118,12 +133,14 @@ class CellWidget extends StatelessWidget {
 
   // Compute cell borders, from board size and cell state
   Border getCellBorders(Activity activity) {
-    final Color cellBorderDarkColor = Colors.grey.shade800;
-    final Color cellBorderLightColor = Colors.grey.shade400;
+    final Color baseColor = getBaseColorFromBlockId(cell.blockId);
+
+    final Color cellBorderDarkColor = baseColor.darken(50);
+    final Color cellBorderLightColor = baseColor.lighten(10);
     const Color cellBorderSelectedColor = Colors.red;
 
     Color cellBorderColor = cellBorderSelectedColor;
-    final double cellBorderWidth = 4;
+    const double cellBorderWidth = 8;
 
     if (!activity.isRunning) {
       cellBorderColor = Colors.green.shade700;

pubspec.yaml

@@ -3,7 +3,7 @@ description: A suguru game application.
 
 publish_to: "none"
 
-version: 0.0.3+3
+version: 0.0.5+5
 
 environment:
   sdk: "^3.0.0"