Compare revisions

  - update

  - build-debug

  - build-release

  - release

  - deploy

update:

  stage: update

  except:

    - tags

  script:

    - flutter packages get

    - flutter packages upgrade

android:build-debug:

  stage: build-debug

  except:

    - tags

  script:

    # Flutter local configuration

    - echo flutter.sdk=$FLUTTER_PATH > android/local.properties

  stage: build-release

  only:

    - master

  except:

    - tags

  dependencies:

    - android:build-debug

  script:

    - echo keyAlias=$ANDROID_KEY_ALIAS >> android/key.properties

    - echo keyPassword=$ANDROID_KEY_PASSWORD >> android/key.properties

    # build flutter app

    - flutter packages get

    - flutter clean

    - flutter build apk --release

    - VERSION_FILE="$(find . -name 'gradle.properties' | head -n1)"

    - VERSION_NAME="$(grep '^app.versionName=' "${VERSION_FILE}" | cut -d'=' -f2)"

    - VERSION_CODE="$(grep '^app.versionCode=' "${VERSION_FILE}" | cut -d'=' -f2)"

    - TAG_NAME="Release_${VERSION_NAME}_${VERSION_CODE}"

    - echo "${TAG_NAME}"

    - >

      if [ $(git tag -l "${TAG_NAME}") ]; then

        echo "Tag ${TAG_NAME} already exists. Skipping build release."

      else

        flutter packages get

        flutter clean

        flutter build apk --release

      fi

    # prepare artifact

    - find . -name "*.apk" # where is my apk?

  artifacts:

    expire_in: 1 week

  interruptible: true

android:deploy:

  stage: deploy

application:release:

  stage: release

  image:

    name: alpine/git

    entrypoint: [""]

  only:

    - master

  except:

    - tags

  dependencies:

    - android:build-release

  script:

    - wget ${REPOSITORY_UPDATE_WEBHOOK}?token=${REPOSITORY_TOKEN}

    - apk --no-cache add curl

    - git config user.email "${GITLAB_USER_EMAIL}"

    - git config user.name "${GITLAB_USER_NAME}"

    - git remote set-url origin https://oauth2:${GITLAB_ACCESS_TOKEN}@${CI_SERVER_HOST}/${CI_PROJECT_PATH}

    - VERSION_FILE="$(find . -name 'gradle.properties' | head -n1)"

    - VERSION_NAME="$(grep '^app.versionName=' "${VERSION_FILE}" | cut -d'=' -f2)"

    - VERSION_CODE="$(grep '^app.versionCode=' "${VERSION_FILE}" | cut -d'=' -f2)"

    - TAG_NAME="Release_${VERSION_NAME}_${VERSION_CODE}"

    - echo "${TAG_NAME}"

    - >

      if [ $(git tag -l "${TAG_NAME}") ]; then

        echo "Tag ${TAG_NAME} already exists. Skipping release and tag creation."

      else

        git tag -a "${TAG_NAME}" -m "Release ${VERSION_NAME} (${VERSION_CODE})"

        git push origin "${TAG_NAME}"

        curl --silent -d "{\"token\": \"${JABBER_NOTIFICATION_TOKEN}\", \"message\": \"New tag for ${CI_PROJECT_PATH}: ${TAG_NAME}\"}" -H "Content-Type: application/json" -X POST ${JABBER_NOTIFICATION_URL}

      fi

android:deploy:

  stage: deploy

  only:

    - tags

  dependencies:

    - application:release

  script:

    - curl "${REPOSITORY_UPDATE_WEBHOOK}?token=${REPOSITORY_TOKEN}"

org.gradle.jvmargs=-Xmx1536M

android.useAndroidX=true

android.enableJetifier=true

app.versionName=0.0.13

app.versionCode=13

app.versionName=0.0.24

app.versionCode=24

        "0410200010000200"

      ]

    },

    "3x2": {

      "easy": [

        "000142214003050361006500503006000405",

        "420000000000241030356410602040014603",

        "540010030050120405003162360521210643",

        "014300023160005423342516406230230005",

        "200061004530000206006015045120302050",

        "651400230600460201020004500103000006",

        "010602206051160305523004640013001000",

        "500004042060010032024650460320003046",

        "060123102500340050605341006005450610",

        "560034004002000041105263600400050306"

      ],

      "medium": [

        "005000600400300005200004020000010060",

        "000060020051306040000005000000040020",

        "023010100060500300030100000602005001",

        "000306500002400000230000600030010640",

        "000030006405030650002300000000160020",

        "050100460000030020120603045000000305",

        "063010410003000460645000030000100000",

        "000000205004100000023010060001530040",

        "620304000000500063400010003100040036",

        "000120510600300000050301060010005000"

      ],

      "hard": [

        "015000000400200000000014000000156300",

        "003160000050006004300015040200231000",

        "060000002000000002000300004010100650",

        "002501500400605200000060000000020600",

        "030100002600000420021000053000000030",

        "103204205100006005000003500000600002",

        "000200060300500002012004000003040100",

        "052400000001000050005006040032020000",

        "200160060023000600000002050430004000",

        "400000060000010400006002000205050046"

      ]

    },

    "3x3": {

      "easy": [

        "004210007090083010000500200007050831910600740400000000006100000801007450050300000",

Initial commit

Add minimal empty application

Improve randomness when generating board from template

Fix rotate/flip board (fix cells borders issue)

Fix "fixed cells state" when randomize board

Mark conflicts in board

Clean code, refactor classes, improve conception

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

Improve CI/CD, create tag on new release step

Improve CI/CD, fix release, skip jobs

Fix set grid size on first game

Remove game icon from title bar

Add minimal home page, settings and gameplay

Highlight cells with same value as currently selected one

Add jabber notification on create tag

Improve graphics

Add fastlane metadata

Force portrait orientation

Add "nature" skin

Add generate initial board feature

Check if soduku is solved

Add transparency to skin images, fix background color

Forbid change on initial cells

Add grid generator, upgrade grids templates

Add "food" skin, improve skins

Simple Sudoku Game:

This simple sudoku game is aimed for kids (but not only).

You can play and have fun even if you can't read!

With a deliberately limited game options, everyone can understand how to play

and how to adapt this game to his needs.

You can choose:

-   difficulty: easy, medium, hard

-   size: 2x2 (very easy, for kids), 3x2 (easy), 3x3 (standard)

-   tiles theme: digits (standard), pictures (for kids)

Simple Sudoku Game. Easy to play, easy to enjoy.

Icon based interface, ready to use, with deliberately limited options (difficulty, grid size, theme).

Simple Sudoku Game

Premier commit

Ajout d'une application minimale vide

Amélioration du mélange à la génération d'un tableau de jeu à partir d'un modèle

Correction sur le mélange initial à la création du plateau (problème de bordure de cellule)

Correction sur l'état "non modifiable" des cellules pendant le mélange initial du tableau

Mise en évidence des conflits sur le tableau de jeu

Nettoyage et réecriture de code, amélioration de la conception

Possibilité d'avoir des blocs non carrés, ajout du mode de jeu "3x2"

Amélioration sur la chaîne CI/CD, création d'un tag/version à l'étape de release

Amélioration de la chaine CI/CD, correction sur création de version

Correction sur la définition de la taille de la grille en début de partie

Suppression de l'icône de l'application dans la barre de titre

Ajout minimal de la page d'accueil, paramétrage et jeu

Mise en évidence des cellules ayant la même valeur que celle sélectionnée

Ajout d'une notification jabber à la création d'une version

Amélioration des graphismes

Ajout des informations pour fastlane

Force l'orientation en mode portrait

Ajout du thème "nature"

Ajout de la fonctionnalité de génération du tableau de jeu

Vérification si la grille est résolue

Ajout de la transparence sur les images, correction sur la couleur de fond

Interdiction de modification d'une cellule du tableau de jeu de départ

Ajout d'un générateur de tableau de jeu, mise à jour des modèles

Ajout du thème "nourriture", amélioration des images

Jeu de Sudoku simple :

Ce jeu de sudoku simple est à destination des enfants (mais pas seulement).

Il est possible d'y jouer et de s'amuser même sans savoir lire.

Avec un choix volontairement limité dans les options, chacun peut découvrir et apprendre comment jouer et comment adapter le jeu à ses envies.

Il est possible de choisir :

-   la difficulté du jeu : facile, moyen, difficile (nombre de cases vides au début de la partie)

-   le taille de la grille: 2x2 (très facile, pour grands débutants), 3x2 (facile), 3x3 (classique)

-   le style: chiffres (classique), dessins (pour enfants)

Jeu de Sudoku simple, facile à jouer, facile à apprécier.

Interface à base d'icônes, facile à prendre en main et volontairement peu de choix dans les options (difficulté, taille de la grille et thème du jeu).

Jeu de Sudoku simple

CURRENT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"

ALLOWED_SIZE_VALUES="2 3"

ALLOWED_BLOCK_SIZE_VALUES="2x2 3x2 3x3"

ALLOWED_DIFFICULTY_VALUES="easy medium hard"

GRIDS_COUNT=10

for SIZE in ${ALLOWED_SIZE_VALUES}; do

  echo "Size: ${SIZE}x${SIZE}"

for BLOCK_SIZE in ${ALLOWED_BLOCK_SIZE_VALUES}; do

  echo "Block size: ${BLOCK_SIZE}"

  for DIFFICULTY in ${ALLOWED_DIFFICULTY_VALUES}; do

    echo "Difficulty: ${DIFFICULTY}"

    for i in $(seq ${GRIDS_COUNT}); do

      python ${CURRENT_DIR}/generate.py ${SIZE} ${DIFFICULTY} | tail -n 1

      python ${CURRENT_DIR}/generate.py ${BLOCK_SIZE} ${DIFFICULTY} | tail -n 1

    done

  done

done

#!/usr/bin/python

# -*- coding: iso-8859-15 -*-

import sys

import math

from random import randint, shuffle

if (len(sys.argv) != 3):

  print('Usage: generate.py size difficulty')

  print('size: [2|3]')

  print('Usage: generate.py block-size difficulty')

  print('block-size: [2x2|3x2|3x3]')

  print('difficulty: [easy|medium|hard]')

  exit()

size, difficulty = sys.argv[1], sys.argv[2]

size = int(size)

blocksize, difficulty = sys.argv[1], sys.argv[2]

if not size in [2, 3]:

if not blocksize in ['2x2', '3x2', '3x3']:

  print('wrong size given')

  exit()

splitted_blocksize = blocksize.split('x')

size_horizontal = int(splitted_blocksize[0])

size_vertical = int(splitted_blocksize[1])

boardSize = size_horizontal * size_vertical

if not difficulty in ['easy', 'medium', 'hard']:

  print('wrong difficulty given')

  exit()

# draw grid (array style)

def drawGrid(grid):

  for row in range(len(grid)):

    for col in range(len(grid[row])):

  gridVerticalSize = len(grid)

  gridHorizontalSize = len(grid[0])

  horizontalLineLength = ((size_horizontal + 1) * size_vertical) + 1

  for row in range(gridHorizontalSize):

    if ((row % size_vertical) == 0):

      sys.stdout.write(('═' * horizontalLineLength) + '\n')

    for col in range(gridVerticalSize):

      if ((col % size_horizontal) == 0):

        sys.stdout.write('║')

      if grid[row][col] != 0:

        sys.stdout.write(str(grid[row][col]))

      else:

        sys.stdout.write(' ')

    sys.stdout.write('\n')

    sys.stdout.write('║\n')

  sys.stdout.write(('═' * horizontalLineLength) + '\n')

  sys.stdout.write('\n')

# draw grid (inline style)

  sys.stdout.write('\n')

#initialise empty grid

def generateEmptyGrid(size):

def generateEmptyGrid(boardSize):