Author: Ilana R.

Projets

Un Sudoku sur ta NumWorks!

Le jeu de Sudoku est un jeu de logique joué sur une grille de 9 * 9 cases, divisée en 9 blocs de 3 * 3 cases. Le but est de remplir chaque case avec un chiffre de 1 à 9, en respectant certaines règles : chaque chiffre ne doit apparaître qu’une seule fois par ligne, colonne et bloc. Le jeu est terminé lorsque toutes les cases sont remplies ou lorsque toutes les vies ont été utilisées.

Logique du jeu

J’ai commencé par coder la couche logique du Sudoku. Pour stocker les informations, la grille est représentée par une matrice de 9 listes, contenant chacune 9 zéros.

board = reset()
def reset():
  return [[0 for i in range(9)] for j in range(9)]

Comme précédemment indiqué, le Sudoku doit respecter trois règles : chaque chiffre ne doit apparaître qu’une seule fois par ligne, colonne et bloc (un bloc étant un regroupement de 3 * 3 case). J’ai donc créé trois fonctions qui renvoient les éléments dans la ligne, la colonne et le bloc. Ensuite, j’ai créé une fonction qui appelle les trois précédentes et qui renvoie les nombres qui respectent les règles. Jusque-là, rien de bien compliqué.

def ligne(x):
  return [i for i in range(1,10) if i in board[x]]

def colonne(y):
  return [board[i][y] for i in range(9) if board[i][y] != 0]

def bloc(x, y):
  nums = []
  for i in range(x//3*3, x//3*3+3):
    for j in range(y//3*3, y//3*3+3):
      if board[i][j] != 0:
        nums.append(board[i][j])
  return nums

def possible(x, y):
  return [i for i in range(1,10) if i not in ligne(x)+colonne(y)+bloc(x,y)]

Il faut maintenant s’attaquer au plus complexe : créer la grille de Sudoku.

J’avais commencé par concevoir une grosse fonction qui créait bel et bien une grille valable de Sudoku, mais cette fonction était récursive (dans mon cas, elle s’appelait elle-même tant que la grille n’était pas valable). Et si sur ordinateur le jeu pouvait tourner (via un environnement de développement comme Thonny), ce n’était pas le cas sur Numworks où le nombre d’itération est très limitée.

Pour régler ce problème, j’avais modifié cette fonction qui faisait alors apparaître des nombres aléatoires présents dans la liste générée par possible(x, y). Par exemple, je générais un premier nombre, la grille étant vide tous les nombres étaient valides, puis un autre… jusqu’à une cinquantaine de nombres.

Mais je suis alors arrivé à un problème majeur : même si tous les nombres générés étaient valides, certains cases vides n’étaient pas solvables, c’est-à-dire que l’on ne pouvait placer aucun nombre car les seuls nombres pouvant être théoriquement placé étaient déjà présents dans la ligne/colonne/bloc par rapport à la case non solvable.

Je me suis retrouvé dans une impasse et c’est à ce moment-là que M. Robert m’a proposé un code qui parcourt la matrice à l’aide de deux boucles while. Pour chaque emplacement, le code vérifie si au moins un nombre peut être placé. Si c’est le cas, un nombre aléatoire est choisi dans le résultat de possible(x,y). Si aucun nombre n’est valide, la boucle recommence à la ligne précédente. Si le nombre d’essais dépasse 42, la fonction se bloque et recommence depuis le début.

def genere_board():
  global board
  board = reset()
  x = y = essai = 0
  while x!=9:
    essai += 1
    if essai ==42: 
      x = essai =0
      board = reset()
    y = 0
    while y!=9:
      if possible(x,y)==[]:
        board[x] = [0 for i in range(9)]
        y = 8
        x = x-1
      else:
        board[x][y] = choice(possible(x,y))
      y +=1
    x +=1
  return board

Maintenant que ma fonction principale est prête, je peux commencer à supprimer des nombres pour que la grille puisse être résolue. Cette fonction va donc prendre une case au hasard, et si elle est remplie, elle supprime le nombre.

def suppr():
  for i in range(40):
    x, y = randint(0,8), randint(0,8)
    while board[x][y] == 0:
      x, y = randint(0,8), randint(0,8)
    board[x][y] = 0

Gestion graphique (affichage)

Tout d’abord, j’ai généré une grille de 9 * 9, mais pour chaque bloc (groupe de 3 * 3 cases), la couleur change. Voici donc les deux fonctions qui s’en occupent :

def couleur(x,y,p=0):
  if (x//3 + y//3) %2 == 1:
    return (180-42*p,140-35*p,225)
  else:
    return (255,200-30*p,125-85*p)
    
def grille():
   for x in range(9):
    for y in range(9):
      rect(2+x*(22), 2+y*(22), 20, 20, couleur(x,y,0))

La fonction grille() ne dessine donc que la grille, mais elle utilise la fonction couleur(x, y, p) pour attribuer une couleur à chaque bloc. Grâce à l’opérateur modulo, on peut savoir dans bloc la case que l’on souhaite dessiner se trouve, et donc lui assigner la bonne couleur (en jaune ou en violet).

Résultat:

Ensuite, je me suis occupée du déplacement sur la grille. J’ai donc utilisé un exemple fourni par les professeurs que j’ai adapté :

def wait(buttons=(0,1,2,3,4,52)): 
  while True:
    for i in buttons:
      if keydown(i):
        while keydown(i): True 
        return i
 
while True:
  key_pressed = wait()
  pos_old = list(pos) 
  if key_pressed == 1:  # flèche haut
    pos[1] = (pos[1]-1) % pmax[1]
  elif key_pressed == 2: # flèche bas
    pos[1] = (pos[1]+1) % pmax[1]
  elif key_pressed == 3: # flèche droite
     pos[0] = (pos[0]+1) % pmax[0]
  elif key_pressed == 0: # flèche gauche
    pos[0] = (pos[0]-1) % pmax[0]
  if key_pressed not in (42, 43, 44, 36, 37, 38, 30, 31, 32):
    deplacement()

La fonction wait() attend qu’une touche soit pressée, et grâce au module ion, elle retourne la clé (valeur numérique identifiant la touche) de celle-ci qui est enregistrée dans key_pressed. Ensuite, en fonction de la touche pressée, la position via la variable pos change. L’opérateur modulo permet d’éviter de dépasser les limites de la grille. Il permet de retourner au début d’une ligne ou colonne lorsqu’on a atteint la fin de celle-ci.

Afin de repérer la case sur laquelle on se situe, j’ai ajouté la fonction surbrillance(), appelée par la fonction deplacement():

def surbrillance(x, y, mode):
  for i in range(9):
    rect(2+i*(22), 2+y*(22), 20, 20, couleur(i, y, mode))
    rect(2+x*(22), 2+i*(22), 20, 20, couleur(x, i, mode))
    if board[i][y] != 0:
      dessine_nb(i, y, board[i][y], mode)
    if board[x][i] != 0:
      dessine_nb(x, i, board[x][i], mode)
  for i in range(x//3*3, x//3*3+3):
    for j in range(y//3*3, y//3*3+3):
      rect(2+i*(22), 2+j*(22), 20, 20, couleur(i, j, mode))
      if board[i][j] != 0:
        dessine_nb(i, j, board[i][j], mode)
        
def deplacement():
  x, y = pos_old
  surbrillance(x,y,0)
  x, y = pos 
  surbrillance(x,y,1)
  rect(2+x*(20+2), 2+y*(20+2), 20, 20,couleur(x,y,2))
  if board[x][y]!=0:
    dessine_nb(x,y,board[x][y],2)

surbrillance() va redessiner les cases de la ligne, la colonne et le bloc associés à la case, en utilisant la couleur, fournit par couleur(x, y, mode).

La fonction deplacement() va donc à chaque fois qu’elle sera exécutée :

  • Appeler surbrillance() en utilisant en paramètre les coordonnées de l’ancienne position et mode=0 ce qui va donc effacer la surbrillance précédente,
  • Rappeler la fonction avec les nouvelles positions, et mode=1 ce qui va dessiner la nouvelle surbrillance.

Résulat:

J’ai ensuite rajouté la détections des touches du pavé numérique de la calculatrice. Pour faire cela, j’ai précisé dans la fonction wait() pour le paramètre buttons les clés 42, 43, 44, 36, 37, 38, 30, 31 et 32 qui correspondent respectivement aux touches 1, 2, 3, 4, 5, 6, 7, 8 et 9.

Une fois cela fait, j’ai indiqué dans le while vu précédemment – celui qui gère changements de la variables pos (… Mais si, je parle du while qui s’occupe des déplacements) – pour chaque nombre l’exécution de la fonction is_valid() en prenant comme en paramètre la position de la case (x et y) et le nombre qui veut être rajouté, dépendant donc de la touche que l’on presse.

elif  key_pressed == 42: #1
    is_valid(pos[0],pos[1],1)

Ici, si la touche 1 est pressée (qui correspond a la clé 42), la fonction is_valid() est appelée avec comme paramètre nb qui vaut 1.

def is_valid(x,y,nb):
  if board[x][y]==0:
    if nb == solution[x][y]:
      dessine_nb(x,y,nb,1)
      board[x][y]=nb

def dessine_nb(x,y,nb,mode):
  txt(str(nb),x*22+7,y*22+3,"black",couleur(x,y,mode))

La fonction is_valid() vérifie donc que le nombre indiqué en paramètre peut être placé, et si c’est le cas, il sera ajouté dans la matrice et dessiné dans la case sélectionnée (celle dont les positions sont indiqués en paramètre).

Autres fonctionnalités

Maintenant que la base du jeu est prête, on peut rajouter d’autres fonctionnalités. On va rajouter un système de difficulté et un système d’aide, que l’on pourra paramétrer via un menu. On va également rajouter un système de vie, pour que le jeu soit plus intéressant.

Je montrerai uniquement le principe pour la gestion des niveaux de difficulté, mais l’idée est la même pour le paramétrage de l’aide :

def draw_level(s=0):
  txt("Find", 237,35,(42+106*s,42+71*s,42+180*s))
  txt("< "*s+ "  "*(s==0) + str(lvl)+ " >"*s + "  "*(s==0), 225, 50,(42,)*3)
  
draw_level(1)
options = [32, 42, 52, 62]
diff = None
pos = 0

def select_diff():
  txt(str(options[pos]), 246, 50,(42,)*3)
  
while diff is None:
  key_pressed= wait()
  if key_pressed == 3: # fleche droite
    pos = (pos + 1) % len(options)
    select_diff()
  elif key_pressed == 0: # fleche gauche
    pos = (pos - 1) % len(options)
    select_diff()
  elif key_pressed in (4,52): # OK
    lvl= options[pos]
    break

Premièrement draw_level() permet de dessiner l’affichage du menu, si s=1 alors Find est en violet et les flèches apparaissent, sinon Find est en noir et les flèches ne s’affichent pas. Cette fonction va être appelée plusieurs fois afin de changer l’apparence de la sélection.

Dans la liste options est stockée les 4 difficultés. L’utilisateur peut alterner entre les 4 valeurs de la liste via les flèches gauche et droite grâce à la boucle et la condition while diff is None. Lorsque le joueur appuiera sur la touche OK, il confirmera sa sélection et quittera la boucle, afin de continuer la suite des instructions du programme. C’est en effet le même principe que la boucle pour gérer les déplacements.

Par la suite, la fonction suppr(lvl) est appelée (expliqué précedamment). Ainsi, le nombre de chiffre retiré de la matrice (la grille en somme) dépend du choix du joueur parmi les 4 proposés.

Comme je l’ai dit, l’idée est la même pour le choix de l’aide, sauf qu’au lieu d’avoir 4 choix, il n’y en a que deux : « On » ou « Off ».

Si « On » est sélectionnée, « Valid Number » apparait en bas à droite, et pour chaque déplacement dans la grille, aide() est appelée :

def aide(x,y):
  rect(200,155 ,200,20,(255,)*3)
  nbs = possible(x, y)  
  if board[x][y]==0:
    for i in range(len(nbs)):
      txt(str(nbs[i]), 265 + i * 20- len(nbs) *10, 155,(42,)*3)
      if nbs[i]!=nbs[-1]:
        txt(",", 275+ i * 20 - len(nbs) *10, 155,(42,)*3)
  else:
    txt("Full", 240,155)

Si la case sélectionnée est pleine, elle affiche « Full », sinon elle affiche tous les nombres qui pourrait être valables dans une case, générés par possible(x, y) vu précédemment.

On a presque mis en place toutes les fonctionnalités supplémentaires mais il manque encore une gameover quand le jeu se termine et le système de vie :

def check():
  c=0
  for i in range (9):
    for j in range (9):
      if board[i][j]!=0:
        c+=1
  return c==81

def coeur():
  rect(x+3,y+0,3,3, col)
  rect(x+15,y+0,3,3,col)
  rect(x+0,y+3,9,3,col)
  rect(x+12,y+3,9,3,col)
  rect(x+0,y+6,21,3,col)
  rect(x+3,y+9,15,3,col)
  rect(x+6,y+12,9,3,col)
  rect(x+9,y+15,3,3,col)
  
def perdre_vie():
    rect(272 - vie *25, 5, 21, 21, (255,) * 3)

La fonction perdre_vie() est appelée dans is_valid(). Si le nombre n’est pas juste, on retire une vie en décrémentant la variable vie de 1 et la fonction perdre_vie() est appelée. Elle dessine un carré blanc, afin d’effacer un des trois cœurs, dessiné au lancement du jeu avec coeur(222,5), coeur(247,5) et coeur(272,5).

La fonction check() regarde si la grille est remplie entièrement. Cette fonction est appelée à chaque déplacement dans la boucle principale while True :

while True:
  if vie==0:
    txt("Perdu!",230,5,(42,)*3,(255,)*3)
    break
  if check()==True :
    txt("  Gagné!  ",210,5,(42,)*3,(255,)*3)
    break

Ainsi si check() == True, le texte  » Gagné!  » apparait et la partie se termine grâce au break. Si le jeu se termine parce que l’utilisateur n’a plus de vie, c’est plutôt le texte « Perdu! » qui apparait.

Captures d’écran finale

Conclusion

Le jeu est donc fini ! La conception m’a pris relativement beaucoup de temps, mais ca m’a permit d’apprendre plein de chose ainsi que de m’améliorer en Python !

Si vous souhaitez le télécharger, voici le lien vers le script avec en supplément un lien vers la page de présentation du jeu :

NumApps

Sudoku en python, NumWorks

Le sudoku est un jeu de logique qui se joue sur une grille de 9×9 cases, divisée en 9 blocs de 3×3 cases. Le but est de remplir chaque case avec un chiffre de 1 à 9, en respectant certaines règles : chaque chiffre ne doit apparaître qu’une seule fois par ligne, colonne et bloc. Le jeu est terminé lorsque toutes les cases sont remplies ou lorsque toutes les vies ont été usées.

Fonctionnalités

  • 4 difficultés
  • Système de vies
  • Génération aléatoire des grilles à chaque nouvelle partie
  • Menu d’aide

Captures d’écran

Commandes

◁ △ ▷ et ▽OKPavé numérique
Se déplacer / ParamétrerValiderPlacer un nombre

En savoir plus

Si vous souhaitez en apprendre plus sur ce projet, cet article pourrait vous intéresser.

Télécharger

Voici le lien pour récupérer le code du jeu et le télécharger sur votre calculatrice.

Tutoriels

Gagnez du temps grâce aux raccourcis clavier et aux…

Vous souhaitez gagner du temps et de l’efficacité dans votre utilisation de Word ? Les raccourcis clavier et les corrections automatiques sont des outils indispensables pour y parvenir. Dans ce tutoriel, vous découvrirez les raccourcis clavier les plus utiles ainsi que les techniques pour créer et personnaliser vos propres raccourcis. Vous verrez également comment utiliser les corrections automatiques pour éviter les erreurs de frappe et gagner du temps.

Les raccourcis avec CTRL

Premièrement, afin d’avoir une prise de note efficace, il faut maitriser les raccourcis les plus utiles. Un raccourci permet de remplacer une action faite normalement au pad ou à la souris (changer des paramètres, etc.) en une action faite au clavier.

La plupart des raccourcis se construisent avec la touche CTRL (en bas à gauche et à droite de votre clavier) et par une ou plusieurs lettres (souvent la première du mot en français ou en anglais de l’action associé).

Il existe aussi des raccourcis construite avec la touche ALT (en bas à gauche), mais nous les verrons plus tard.

Voici donc une liste exhaustives des raccourcis les plus utiles

  • CTRL + A : tout sélectionner
  • CTRL + C : copier
  • CTRL + V : coller
  • CTRL + X : supprime un élément qui va dans le presse papier
  • CTRL + Z : retour en arrière
  • CTRL + Y : annuler un CTRL+Z ou répéter une action (par exemple réécrit une phrase ou un mot)
  • CTRL + N : Nouveau document
  • CTRL + O : ouvrir un document
  • CTRL + W : Ferme le document
  • CTRL + P : imprime le document
  • CTRL + F : cherche un mot dans le document
  • CTRL + H : Rechercher et remplacer un mot
  • CTRL + I : met en italique le texte
  • CTRL + U : souligne le texte
  • CTRL + G : met en gras un texte
  • CTRL + J : Justifie le texte
  • CTRL + E : centre un texte
  • CTRL + > : Augmente la taille de la police
  • CTRL + < : diminue la taille de la police
  • CTRL + MAJ + + : met en exposant
  • CTRL + = : met en indice
  • CTRL + Saut à la ligne : fait un saut de page (grâce à cela, si vous rajouter des éléments avant votre saut de page, ça ne vous décale pas tout votre document, cela permet donc de faire des documents plus propre et facile à modifier)

Les raccourcis avec ALT

Comme mentionné précédemment, certains raccourcis sont construits avec ALT.

Les raccourcis avec ALT permettent d’accéder à la barre d’outils. Étant donné que l’on peut ajouter et supprimer des éléments de la barre d’outils, les raccourcis varient pour chaque utilisateur. Il suffit donc d’appuyer sur ALT et vous verrez les raccourcis disponibles en fonction de votre barre d’outils. (Pour ajouter un élément dans la barre d’outils, il suffit de faire un clic droit et de sélectionner « Ajouter à la barre d’outils d’accès rapide »).

Voici par exemple ce que j’obtiens :

Donc si j’effectue ALT + 1 par exemple, cela enregistre le fichier, ALT + 7 ouvre une fenêtre avec les symboles mathématiques disponible, etc.

Ajout et modification des raccourcis

Maintenant vous maitrisez les raccourcis, mais si un des raccourci ne vous convient pas, ou que vous voulez en rajouter un, et bien c’est possible.

Premièrement allez dans le menu et appuyer sur « autre » puis « options »

Choisir dans le menu « personnalisez le ruban », puis en bas à gauche de la page, appuyer sur « Raccourcis clavier : Personnaliser »

Maintenant une (longue) liste de commande va apparaitre. Je vous conseille de choisir dans « catégorie » :« toutes les commande », si vous ne savait pas dans quelle catégorie se trouve la commande que vous voulez ajoutez/modifier.

Une liste classée par ordre alphabétique vas apparaitre à droite.

Il suffit de cliquer sur la commande que vous voulez, puis cliquer sur « nouvelles touches de raccourcis » et appuyer sur les touches que vous voulez utiliser pour définir ce raccourci.

Par exemple il n’existe pas de raccourcis pour la commande « barrer », si vous voulez en rajouter un il faut donc trouver dans la liste la commande et la sélectionner, puis dans « nouvelles touches de raccourcis » appuyer sur CTRL + B + A par exemple (vous choisissez le raccourcis que vous souhaitez)

Il existe aussi d’autre catégorie que les commandes, comme les polices et les symboles. On peut donc rajouter des raccourcis qui formatent le texte sélectionné dans la police choisie etc…

Ajouter des correction automatique

Il est aussi possible de rajouter des corrections automatiques, c’est un dire que si vous tapez un texte défini, il sera automatique remplacé par une autre. Cela peut être pratique pour la prise de note (par exemple « auj » sera automatique remplacer par « aujourd’hui », « qqch » par « quelque chose » etc…)

Pour cela il faut retourner dans le menu, puis encore une fois aller dans « autres » puis « options »

Choisir « vérification »

Puis « options de correction automatique » (en haut à droite)

Il suffit maintenant de choisir en haut du tableau dans la colonne « Remplacer: » le texte que vous voulez remplacer (ex: qqch), et dans la colonne « Par: » ce par quoi vous voulez le remplacer (ex: quelque chose) Information utile: On peut insérer jusqu’à 250 caractères dans la colonne « Remplacer », et dans la colonne « Par ».

Cette technique est pratique pour remplacer les abréviations mais aussi pour les mots difficiles à orthographier.

Elle peut être aussi utilisée pour insérer des symboles. Par exemple il n’existe pas sur le clavier la touche « × », on peut donc rajouter un raccourci avec par exemple « *. » qui donne « × » .

Cependant pour les symboles mathématiques, beaucoup de correction existe déjà. Pour voir la liste et/ou la modifier, il faut aller dans l’onglet « AutoMaths » .

Il y a alors une liste des corrections déjà existante, avec tous les ensembles de définitions, les opérateurs, et certain symbole mathématique. Vous pouvez donc en rajouter, mais aussi les modifier.

A noter: toutes les captures d’écran on était faite à partir de la version de 2020 de Microsoft Word. Pour autant toutes ces techniques sont applicables a des versions plus ancienne. Cependant l’interface est légèrement différente. (J’ai tester jusqu’à la version de 2007).

Art

Jardins : Forêt enneigée

Ce script génère une image aléatoire de forêt enneigée en utilisant deux fractales très connues : l’Arbre de Pythagore et le Flocon de Koch.

Les fractales

Le Flocon de Koch

Le Flocon de Koch utilise une courbe fractale. Une courbe fractale est un dessin composé de segment dont la forme de base va être reproduite à l’infini.

Dans le cas de la courbe de Koch, sur chaque segment, un triangle va être dessiné, et pour chaque niveau, on va rajouter un triangle sur les nouveaux segments.

Pour créer cette courbe, on va utilisé le principe de récursivité, c’est à dire qu’on va appeler dans une fonction python la fonction elle-même.

def cote(longueur,niveau):
    if niveau==0:
        forward(longueur)
    else:
        cote(longueur/3,niveau-1)
        left(60)
        cote(longueur/3,niveau-1)
        right(120)
        cote(longueur/3,niveau-1)
        left(60)
        cote(longueur/3,niveau-1)

On exécute la fonction cotée en définissant la longueur et le niveau de répétition souhaité. Ligne 2, on vérifie que le niveau est égal à 0. S’il ne l’est pas, ligne 5, on rappelle la fonction et cette fois-ci la longueur est divisée par 3 et on enlève 1 au niveau. Ainsi, on répète tant que le niveau n’est pas égal à 0, et quand le niveau est égale à 0, on avance de « longueur ».

En répétant cela plusieurs fois, on obtient la courbe de Koch.

Pour obtenir un flocon, on répète cette courbe trois fois.

def flocon(longueur,niveau,x,y):
    width(1)
    penup()
    goto(x,y)
    pendown()
    for i in range(3):
        cote(longueur,niveau)
        right(120)

Ce code provient de https://www.numworks.com/fr/professeurs/activites-pedagogiques/premiere/flocon/

L’arbre de Pythagore

L’arbre de Pythagore fonctionne de la même manière : la fonction s’appelle elle-même.

def arbre(n,longueur,w,r1,g1,b1,r2,g2,b2):
  if n==0 :
    pencolor(r1,g1,b1)
    forward(longueur)
    backward(longueur)
    pencolor(r2,g2,b2)
  else:
    width(w) 
    forward(longueur/3)
    left(50) 
    arbre(n-1,longueur*2/3,w/1.2,r1,g1,b1,r2,g2,b2)
    right(2*50)
    arbre(n-1,longueur*2/3,w/1.2,r1,g1,b1,r2,g2,b2)
    left(50)
    backward(longueur/3)

Cette fonction prend plusieurs paramètres :

  • le niveau n de répétition
  • la longueur du tronc
  • la largeur w : afin que les arbres éloignés soient plus fins que les arbres au premier plan, on définit la largeur. Plutôt que d’utiliser w-1 (sinon après un certain niveau de répétition la valeur deviendrait négative), on utilise w/1.2 ce qui permet de réduire la valeur sans changer son signe.
  • r1,g1,b1 : qui définissent en RGB la couleur des feuilles.
  • r2,g2,b2 : qui définissent en RGB la couleur du tronc.

Ce code provient de https://my.numworks.com/python/cent20/arbre

Le fond

L’exécution du fond et des montagnes

A chaque exécution le fond va être d’une couleur aléatoire.

color(randint(10,250),255,255)
begin_fill()
goto(-640,700)
pendown()
goto(640,700)
goto(640,-700)
goto(-640,-700)
end_fill()

A chaque fois que nous exécutons le script, le résultat est unique, les montagnes ayant une forme définie auront une couleur aléatoire.

Script d’une des montagnes :

for i in range (10):
    for i in range (5):
        forward(20)
        right(2)
    for i in range (5):
        forward(10)
        left(2)

Cette boucle crée des fragments de cercles collés, qui forment une ondulation.

Les trois montagnes donnent cette image, avec des couleurs uniques à chaque fois.

L’exécution des arbres

On dessine 7 arbres en tout : 2 sur la montagne du fond, 2 sur la montagne du milieu et trois sur la montagne du devant. Chaque arbre a un secteur donné sur sa montagne et il est dessiné dans ce secteur, de façon unique à chaque fois.

Les arbres sur la montagne la plus éloignée sont plus petits, plus fins et plus sombres, cependant chaque arbre est d’une couleur, d’une taille et d’une largeur différentes à chaque exécution.

Voici par exemple l’exécution d’un arbre sur la montagne du fond

penup()
goto(randint(-550,-450),randint(120,160))
pendown()
setheading(90)
color(75,randint(40,50),randint(0,20))
arbre(9,randint(50,90),randint(4,7),randint(130,180),randint(160,180),180,75,randint(40,50),randint(0,20))

L’exécution des flocons

Ensuite on exécute les flocons:

for i in range (randint(30,45)):
    setheading(randint(0,360))
    color(randint(0, 220),randint(110, 240),255)
    begin_fill()
    flocon(randint(20,50),randint(3,5),randint(-639,639),randint(-310,310))
    end_fill()

A chaque exécution, le nombre de flocons est différent. Chaque flocon est orienté différemment , à une couleur, une taille, un niveau de répétition, et un emplacement différent.

L’image finale

Télécharger le .py

Si vous voulez l’essayer, vous trouverez le script ci-dessous, cependant faites attention, chaque arbre prend relativement longtemps à s’exécuter, ajouté aux flocons, le script prend environ 1h30 à s’exécuter.