Création du jeu Voltorb Flip sous Python

**MrGalactique** · 17/05/2013, 20h53

Bonjour, dans le cadre de mes études, je me suis donné pour projet de réaliser le jeu Voltorb Flip en language Python.
Peut-être ne connaissez-vous pas ce jeu, aussi, si les curieux souhaite y jeter un oeil, sachez que je l'ai trouvé en Javascript sur ce lien ci-dessous :
http://www.mwyann.com/voltorbflip.html

Avant de vous copier/coller ce que j'ai commencé comme programme, j'aimerais vous expliquer très rapidement les règles du jeu afin de vous dire ce qu'il me reste à faire (et également ce que je n'arrive pas à faire).

Nous avons un tableau 5x5 dont chaque case renferme une valeur contenue dans un intervalle fermé de 0 à 3. Si le joueur retourne une case contenant un 0, il perd la partie. Le but du jeu est de retourner toutes les cases contenant des 2 et des 3. Pour que la réussite de la partie ne s'applique pas par pur hasard, des indices servent à aider le joueur quant aux probables positions des 0, 1, 2 et 3. Ces indices sont caractérisés par des chiffres se trouvant à droite et en bas du tableau du jeu. Il existe deux types d'indices pour ce jeu :
_ un chiffre donnant la somme des chiffres présentes sur une ligne/colonne.
_ un chiffre donnant le nombre de 0 présents sur une ligne/colonne.

Voici maintenant mon début de programme :

from Tkinter import *
import random
from operator import add

# création de la fenetre principale sous TKinter

Fenetre = Tk()
Fenetre.title('LeJeu')

nombre_de_mine = 6
nombre_de_un = 14
nombre_de_deux = 3
nombre_de_trois = 2
k = -1
r = random.randint(0,24)
n = 0
s = 0

cases = [k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k , k]

compteur = 0
while compteur < nombre_de_mine:
r = random.randint(0,24)
if cases[r] == -1:
cases[r] = 0
compteur = compteur + 1

compteur = 0
while compteur < nombre_de_deux:
r = random.randint(0,24)
if cases[r] == -1:
cases[r] = 2
compteur = compteur + 1

compteur = 0
while compteur < nombre_de_trois:
r = random.randint(0,24)
if cases[r] == -1:
cases[r] = 3
compteur = compteur + 1

for r in range (25):
if cases [r] == -1:
cases[r] = 1

print cases

for i in range(5):
for j in range(5):

l = Label(text= cases[n], relief=RIDGE)
l.grid(row=i, column=j, sticky=NSEW)
n = n + 1
reduce(add, cases[:4])
print s

Fenetre.mainloop()

Avec ceci, j'arrive à créer mon tableau 5x5 sur Tkinter. J'ai également fais en sorte que les valeurs allant de 0 à 3 soient placés de manière aléatoire sur celui-ci.
Sauf que j'ai fais le plus facile (du moins je pense) et il me reste à faire ceci :
_ créer les indices i et j avec : i qui donne la somme des valeurs présentes sur chaque ligne et colonne; j qui donne le nombre de 0 présents sur chaque ligne et colonne
_ créer un booléen (je pense que c'est ça) qui me permet de faire en sorte que chaque case soit au début du jeu face cachée et créer une fonction qui me permettra de retourner les cases en cliquant dessus
_ définir les conditions d'arrêt du jeu.

Je ne suis pas très doué en language Python (ni dans les autres languages d'ailleurs) et j'ai cherché sur internet à créer mon booléen. Je me suis rendu sur des sites où je pouvais télécharger des Démineur écrit en Python, mais même avec ça je n'ai pas su trouver les lignes de programmation qui m'intéressais.
Quant à la création des indices i et j, je suppose qu'il me faut créer ces variables, les définir et mettre dans mon programme des conditions (même si mes essais ont été des échecs, j'imagine que ma piste est tout de même une bonne piste)

Je serai infiniment reconnaissant si une âme charitable pouvait m'aider dans les trois différentes tâches qui me reste à faire.
En vous remerciant d'avance pour vos réponses,
MrGalactique

**Julien N** · 18/05/2013, 00h34

Salut,

Si j'étais toi j'écrirais la grille sous forme matricielle au lieu d'une simple liste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
import numpy as np
 
# Crée une matrice 5*5 vide
cases = np.zeros((5,5))

Dans ce cas tu peux aisément accéder à la case souhaité comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cases[i][j]

Pour compter la somme des nombre d'une ligne tu peux faire des boucles:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
# Somme des nombres de la première ligne:
s = 0
for k in range(5):
    s += cases[0][k]

Et ainsi de suite...

**fred1599** · 18/05/2013, 11h34

Bonjour,

@Julien N
Numpy n'est semble-t-il pas forcément utile pour faire ce genre de chose, on peut travailler avec la lib standard, c'est amplement suffisant et aussi simple.

@MrGalactique
Avant Tkinter résoudre ton problème (algorithme) est plus logique.
La partie graphique est juste une couche supplémentaire et simple lorsqu'on a déjà bien travaillé sur le problème.

Je te conseille donc de refaire le code propre et sans Tkinter.

Tu pourrais travailler avec les fonctions pour découper et retrouver chaque étape de résolution.

exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
>>> def create(row, column, k):
...     return [[k for i in range(column)] for j in range(row)]
... 
>>> create(5, 5, -1)
[[-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1]]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
>>> cases = create(5, 5, -1)
>>> for line in cases:
...     print(line)
... 
[-1, -1, -1, -1, -1]
[-1, -1, -1, -1, -1]
[-1, -1, -1, -1, -1]
[-1, -1, -1, -1, -1]
[-1, -1, -1, -1, -1]

Ça demande donc peut-être une réflexion sur papier...

**MrGalactique** · 18/05/2013, 14h57

J'ai suivi les procédures mais avant cela je tiens à signaler un autre problème.

Jusqu'à maintenant, je travaillais sur Geany sur un poste de mon lycée.
J'ai téléchargé Geany ainsi que Python 2.7.5 sur mon ordinateur puis ai commencé mon programme.

Message d'erreur sur cmd.exe :
'python' n'est pas reconnu en tant que commande interne ou externe, un programme exécutable ou un fichier de commandes.

Est-il nécessaire pour moi de me diriger vers un autre topic où puis-je rester sur celui-ci ?

**fred1599** · 18/05/2013, 16h19

Bonne lecture

**MrGalactique** · 18/05/2013, 18h07

J'arrive désormais à faire marcher Geany convenablement.

Pour appliquer la somme des valeurs inscrits sur chaque ligne et chaque colonne, je comprend qu'il soit normale de modifier la manière de créer mon tableau. J'ai donc inscrit ce code sur le programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
>>> def create(row, column, k):
...     return [[k for i in range(column)] for j in range(row)]
>>> create(5, 5, -1)
 
cases = create(5, 5, -1)
 
>>> for line in cases:
...     print(line)

Cela fait en effet plus propre mais en procédant ainsi je ne vois pas comment je peux remplacer les -1 par les valeurs souhaitées.
Je tente de conserver le système avec le compteur, pour cela, il me semble que je dois conserver mon r = random.randint (0 , 24), seulement, mes conditions ne marcheront plus de la même manière. En effet, je ne peux pas écrire "if cases[r] == -1" étant donné que "cases" a été défini de la manière suivante : "cases = create(5, 5, -1)"
Le problème est donc là : comment, pour créer mes conditions, puis-je sélectionné une case aléatoirement (grâce à la valeur r) et répéter l'opération jusqu'à ce que toutes mes valeurs aient été prise en compte (en utilisant mes boucles while).

**fred1599** · 18/05/2013, 18h30

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from random import randint
 
def create(row, column, k):
    return [[k for i in range(column)] for j in range(row)]
 
def add(value, nbr, case, k=-1):
    counter = 0
    while counter < nbr:
        row, column = randint(0, 4), randint(0, 4)
        if case[row][column] == k:
            case[row][column] = value
            counter += 1
    return case
 
# création d'un tableau à 2 dimensions composé de -1
cases = create(5, 5, -1)
 
# Ajout du nombre 2 (value), 3 fois (nbr), k vaut -1 par défaut
cases = add(2, 3, cases)
print(cases)
# [[-1, -1, -1, -1, -1], [-1, -1, -1, 2, 2], [-1, -1, -1, -1, 2], [-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1]]
 
# Ajout du nombre 0 (value), 6 fois (nbr), k vaut -1 par défaut
cases = add(0, 6, cases)
print(cases)
# [[-1, -1, 0, -1, -1], [-1, -1, 0, 2, 2], [-1, -1, 0, -1, 2], [0, -1, -1, -1, 0], [-1, -1, -1, -1, 0]]

?

**MrGalactique** · 18/05/2013, 18h50

Dingue à quel point il est facile de paniquer devant une page vide de codage alors qu'en fait les réponses apportées pour nous aider sont ultra logique.

Je vais rédiger sur un papier (ou du moins essayer de rédiger) un algorithme que je vous présenterai ce soir (ou demain matin) et qui aura pour but la création des indices, à savoir :
_ le nombre de 0 contenu dans une ligne
_ le nombre de 0 contenu dans une colonne
_ la somme des valeurs contenus dans une ligne
_ la somme des valeurs contenus dans une colonne

**MrGalactique** · 18/05/2013, 22h12

Bonsoir et désolé pour le double-post.
Voici le codage très simple, voir trop simlple, que j'ai élaboré :

EDIT :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
somme = 0
somme = cases[0][0] + cases[0][1] + cases[0][2] + cases[0][3] + cases[0][4]
print somme

Le but étant, dans un premier temps, d'afficher un chiffre qui soit la somme des valeurs de ma première ligne.

Je suis conscient que ce code est bizarre et qu'il y a bien mieux à faire. Mais ça fonctionne.

Par contre pour compter le nombre de 0, j'ai un peu plus de mal.
Je définis ma variable, mettons "a".
Si cases[row][column] == 0:
a = a + 1
print a

Sauf qu'il faut que je compte le nombre de 0 sur chaque ligne et colonne.
Prenons alors par exemple la première ligne.
La première ligne va de "cases[0][0]" jusqu'à "cases[0][4]".
Comment dois-je m'y prendre pour sélectionner cette partie afin d'y affecter mon compteur "a"? N'y a t-il pas là une histoire de longueur (len) ?
Avec "column = len(0, 4)" ou un truc dans le genre ?

**fred1599** · 18/05/2013, 23h54

Ok mais là c'est pour une seule ligne, après tu dois utiliser une boucle, tu vas pas te taper toutes les lignes en dur.

Voilà une solution, j'ai commenté

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
def reckon(line, val=None):
    '''
    Exemple d'utilisation
    reckon(line, 0) -> compte le nombre de 0 dans une ligne
    reckon(line) -> calcule la somme d'une ligne
    '''
    if val is None: # Si on ne recherche pas un nombre en particulier
        counter = sum(line) # on calcule la somme des valeurs de la ligne
    else:
        counter = line.count(val)
    return counter # Dans tous les cas on retourne la variable counter

Ce qui donne pour le code actuellement avec les tests

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
from random import randint
 
# Constantes
ROW = 5
COLUMN = 5
INIT = -1
MINE = 0
 
def create(row, column, k):
    return [[k for i in range(column)] for j in range(row)]
 
def add(value, nbr, case, k=-1):
    counter = 0
    while counter < nbr:
        row, column = randint(0, 4), randint(0, 4)
        if case[row][column] == k:
            case[row][column] = value
            counter += 1
    return case
 
def reckon(line, val=None):
    '''
    Exemple d'utilisation
    reckon(line, 0) -> compte le nombre de 0 dans une ligne
    reckon(line) -> calcule la somme d'une ligne
    '''
    if val is None: # Si on ne recherche pas un nombre en particulier
        counter = sum(line) # on calcule la somme des valeurs de la ligne
    else:
        counter = line.count(val)
    return counter # Dans tous les cas on retourne la variable counter
 
 
# création d'un tableau à 2 dimensions composé de -1
cases = create(ROW, COLUMN, INIT)
 
# Ajout du nombre 2 (value), 3 fois (nbr), k vaut -1 par défaut
cases = add(2, 3, cases)
 
# Ajout du nombre 0 (value), 6 fois (nbr), k vaut -1 par défaut
cases = add(MINE, 6, cases)
 
# Affichage de la somme des valeurs de chaque ligne, exemple -2, -2, 0, -4, -1
for line in cases:
    print(reckon(line))
 
# Affichage du nombre de mines dans chaque ligne, exemple 2, 1, 1, 1, 1
for line in cases:
    print(reckon(line, MINE))

Bonne continuation...

EDIT:

Pour calculer la somme des valeurs d'une colonne, on utilise la fonction reckon qui a besoin d'une ligne en argument

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
# Affichage de la somme des valeurs de chaque colonne
for i in range(COLUMN):
    line = []
    for j in range(ROW):
        line.append(cases[j][i])
    print(reckon(line))

EDIT1:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
# Affichage du nombre de mines dans chaque colonne
for i in range(COLUMN):
    line = []
    for j in range(ROW):
        line.append(cases[j][i])
    print(reckon(line, MINE))

EDIT2:

Simplification de la fonction reckon

**MrGalactique** · 19/05/2013, 15h04

Ok, donc la fonction qui permet de compter les éléments d'une liste s'appelle "reckon" comme pour "compter" en anglais.
C'est bien pratique concernant les lignes, mais concernant les colonnes, il n'y avait pas juste à remplacer "line" par "column" ?

A la limite, en ce qui concerne les colonnes, je peux juste reprendre le codage que j'ai utilisé auparavant :

somme = 0
somme = cases[0][0] + cases[0][1] + cases[0][2] + cases[0][3] + cases[0][4]
print somme

Sauf que cette fois-ci il faudra que je commence de cette manière :
somme = 0
somme = cases[0][0] + cases[1][0] + cases[2][0] + cases[3][0] + cases[4][0]
print somme

Puis je fais une boucle pour répéter l'opération pour les colonnes numéros 1, 2, 3 et 4.

Mais y a t-il un moyen de répéter l'opération avec "reckon" pour les colonnes et non pour les lignes ?

EDIT : Ok, je vois que vous avez anticipé mon message. Oubliez donc le paragraphe du dessus.

Je me suis également penché sur l'autre problème qui m'attend et qui est celui du booléen. Je me suis renseigné sur le net et ai trouvé des exemples d'utilisation du booléen pour des jeux tel que le démineur.
Le démineur commence à créer des constantes :
INCONNU : -2
PERDU : -3

Avec INCONNU qui représente une case non découverte et PERDU qui représente une case avec une mine sur laquelle le joueur a cliqué.
Sauf que là, dans mon cas, si une case ne renferme pas un 0 mais un entier positif, il faut qu'il me l'affiche si je clique dessus et non qu'il me retourne une case vide. Et là je suis bien embêté car je n'y connais absolument rien en booléen.

Encore une fois, il faudrait apparemment créer des conditions :
If cases[row][column]==0:
cases[row][column]["etat"] = PERDU
#print 'Vous avez perdu."
return False
else
return True

Sauf que c'est bien plus complexe que ça. Il fallait que je réapprenne les fondamentaux, aussi j'ai visité ce lien :
http://python.developpez.com/cours/
Sauf que je ne vois pas comment mettre FALSE et TRUE en relation avec le jeu Voltorb Flip. Je n'ai quasiment aucun indice.
J'ai aussi visité le code source du jeu Voltorb Flip en Javascript, j'ai repéré les lignes qui m'intéressait mais je n'arrive pas à les comprendre, du coup, impossible de traduire ces quelques lignes en python.
Auriez-vous des indices à me donner pour clarifier mes idées ? Un chemin à suivre ? Mon manque de connaissance m'empêche de faire des tests sur Geany, je ne peux qu'essayer de me renseigner sur le net.

Quelque part, je suis un peu gêné par le fait que vous êtes en train de faire pratiquement tout le jeu à ma place (d'autre part j'en suis aussi reconnaissant) aussi j'aimerais savoir si je peux proposer un codage qui tient la route sur cette étape là du jeu.

**fred1599** · 19/05/2013, 15h59

On voit dans ta formulation, que c'est pas clair dans ta tête, si j'aiguille, je pourrais te demander de faire le boulot de cette façon.

Si tu crées une fonction

1) Quel est son intérêt?
2) Comme s'appellera-t-elle?
3) Que retournera-t-elle? Un booléen (True et False en python)
4) Quels sont les paramètres dont on a besoin?

Si tu commences par répondre à ces questions, on y verra tous les 2 plus clairs sur ce que tu veux

Sauf que je ne vois pas comment mettre FALSE et TRUE en relation avec le jeu Voltorb Flip. Je n'ai quasiment aucun indice.

Il faut être clair, la conception du jeu c'est toi qui l'a fait, je ne fais que traduire ton algorithme.

Je ne connais pas le jeu, j'aime pas les jeux, et je n'essaierais pas de comprendre le jeu, donc à toi d'avoir une réflexion quand à la résolution de tes problèmes

Ça peut prendre du temps, mais souvent on se débloque avec un papier et un crayon, à toi de voir...

**MrGalactique** · 19/05/2013, 21h18

1) Quel est son intérêt?

L'intérêt de la fonction que je souhaite exploiter est de cacher le contenu de mes cases.
Je veux une autre fonction qui me permet de découvrir le contenu d'une case en cliquant dessus avec la souris.

2) Comme s'appellera-t-elle?

Je n'en ai aucune idée. Je n'ai même pas su découvrir si il existait une fonction sur python qui nécessite l'activation d'un click sur la souris.

3) Que retournera-t-elle? Un booléen (True et False en python)

Apparemment, False serait associé au retournement d'un 0.

4) Quels sont les paramètres dont on a besoin?

Je ne suis pas certain de ma réponse, il me semble que les fonctions que je souhaite exploiter nécessite des variables et qu'il faut écrire des conditions.

Sur papier, le peu d'information (flou) que je possède ne me permet pas d'écrire un algorithme. Je ne sais toujours pas par où commencer. Cette étape du jeu est sans doute celle qui me bloque le plus, car dès fois, même si je ne connais pas le nom de la fonction à exploiter, il m'arrive de pondre un début d'algorithme sur feuille.

Peut-être que ce que je demande nécessite au préalable de faire apparaître mon tableau sur TKinter ?

**fred1599** · 19/05/2013, 21h35

L'intérêt de la fonction que je souhaite exploiter est de cacher le contenu de mes cases.

Mais elles ne sont pas encore créées, est-ce que je me trompe?

Il faudrait déjà une fonction permettant de placer tes mines, et tes autres objets, d'ailleurs comment s'appellent-ils?

la fonction

Intérêt : Dessiner les cases représentant les différents objets du jeu
Nom : draw
Type de retour : Aucun (c'est un affichage)
paramètres : liste des emplacements

On pourrait créer une fonction, qui permet de dessiner chaque objet dans une case (mais à quoi ressemble-t-il?), n'as-tu pas des images?

EDIT:

Voilà ce que ça peut donner, je met pas le code, faut que je fignole un peu, mais on place nos images, puis on ajoute sur ces images nos cases vides où l'on va cliquer et qui seront supprimés lors du clic.

**MrGalactique** · 19/05/2013, 22h29

Non, il n'y pas besoin d'objets.
Chaque case du tableau possède une valeur, celle-ci peut être 0, 1, 2 ou 3.
Tous les 0 correspondent à une bombe et si jamais le joueur clique sur une case qui contient un 0, il perd la partie. Je n'ai pas prévu de remplacer les 0 par une image de bombe, ni par quoi que se soit d'autre. Il en va de même pour les autres entiers. Du coup, mon tableau est déjà remplie.

Et c'est pourquoi je pense que c'est à partir de maintenant que je dois représenter mon tableau sur TKinter. Ça avant de créer une fonction qui permet de retourner les cases. Car il me parait logique que pour retourner des cases dont les valeurs renfermées sont cachées, il faut d'abord créer ces cases.

**fred1599** · 19/05/2013, 22h38

Non, il n'y pas besoin d'objets.
Chaque case du tableau possède une valeur, celle-ci peut être 0, 1, 2 ou 3.

Alors que représente le 1, 2 et 3?

**MrGalactique** · 19/05/2013, 22h53

Juste des points qu'il faut accumuler.

Voici les conditions d'arrêt du jeu :

Pour gagner, il faut retourner toutes les cases contenant des 2 et des 3.
Si le joueur retourne un 0, game-over.

EDIT :
Le système de score fonctionne de la manière suivante :
Le score est à chaque fois multiplié par la valeur que l'on vient de découvrir en cliquant sur une case.
Par exemple, imaginons que je retourne un 2, mon score sera donc de 2 points.
A présent, je décoche une case contenant un 3, mon score sera donc de 2x3 = 6 points.
Comme dans mon tableau, il y a exactement trois fois le numéro 2 et deux fois le numéro 3, il faut donc un score de 72 points pour gagner.
A noter que si le joueur retourne une case contenant un 1, cela n'a aucune conséquence sur le déroulement du jeu, en effet, si mon score est multiplié par 1, cela ne changera pas mon score. En revanche, tomber sur un 0 fait tomber mon score à 0 et cela signe la fin de la partie.

Je m'occuperai des conditions d'arrêt du jeu plus tard, ce sera plus facile que de faire le booléen.

**fred1599** · 20/05/2013, 11h55

Ok, créons nos cases

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def draw(path):
    "path est l'endroit où se trouve ton dessin"
    image = Image.open(path)
    photo = ImageTk.PhotoImage(image)
    return photo
 
def construct(can, size, begin, y_begin, case, picture):
    '''
    can -> le canvas
    size -> taille du carré
    begin -> valeur de x où commence la ligne
    y_begin -> valeur de y où commence la ligne
    case -> tableau de situation des objets
    picture -> instance de PhotoImage
    '''
    DISTANCE = 5 # distance entre chaque carré
    y = y_begin
    for line in case:
        y += (size + DISTANCE)
        x = begin
        for n in line:
            canvas.create_image(x, y, image=picture)
            x += (size + DISTANCE)

L'image que j'utilise en pièce jointe...

Maintenant il y a peut-être mieux mais c'est plus cher, temps d'investissemnt limité.

J'ai un peu pensé aussi la gestion du click gauche

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def click(event):
    item = canvas.find_closest(event.x, event.y) # recherche l'item en fonction des coordonnées du click
    canvas.delete(item) # suppression de l'item, mais c'est un exemple sur ce que l'on peut faire

Du coup ça donne ce code au final

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
from random import randint
from PIL import Image, ImageTk
from tkinter import Canvas, Tk, NW
 
 
 
# Constantes
ROW = 5
COLUMN = 5
INIT = -1
MINE = 0
 
def create(row, column, k):
    return [[k for i in range(column)] for j in range(row)]
 
def add(value, nbr, case, k=-1):
    counter = 0
    while counter < nbr:
        row, column = randint(0, 4), randint(0, 4)
        if case[row][column] == k:
            case[row][column] = value
            counter += 1
    return case
 
def reckon(line, val=None):
    '''
    Exemple d'utilisation
    reckon(line, 0) -> compte le nombre de 0 dans une ligne
    reckon(line) -> calcule la somme d'une ligne
    '''
    if val is None: # Si on ne recherche pas un nombre en particulier
        counter = sum(line) # on calcule la somme des valeurs de la ligne
    else:
        counter = line.count(val)
    return counter # Dans tous les cas on retourne la variable counter
 
def draw(path):
    "path est l'endroit où se trouve ton dessin"
    image = Image.open(path)
    photo = ImageTk.PhotoImage(image)
    return photo
 
def construct(can, size, begin, y_begin, case, picture):
    '''
    can -> le canvas
    size -> taille du carré
    begin -> valeur de x où commence la ligne
    y_begin -> valeur de y où commence la ligne
    case -> tableau de situation des objets
    picture -> instance de PhotoImage
    '''
    DISTANCE = 5 # distance entre chaque carré
    y = y_begin
    for line in case:
        y += (size + DISTANCE)
        x = begin
        for n in line:
            canvas.create_image(x, y, image=picture)
            x += (size + DISTANCE)
 
def click(event):
    item = canvas.find_closest(event.x, event.y) # recherche l'item en fonction des coordonnées du click
    canvas.delete(item) # suppression de l'item
 
 
 
# création d'un tableau à 2 dimensions composé de -1
cases = create(ROW, COLUMN, INIT)
 
# Ajout du nombre 2 (value), 3 fois (nbr), k vaut -1 par défaut
cases = add(2, 3, cases)
 
# Ajout du nombre 0 (value), 6 fois (nbr), k vaut -1 par défaut
cases = add(MINE, 6, cases)
 
root = Tk()
 
canvas = Canvas(root, width = 640, height = 480) # Création du canvas
canvas.pack()
 
carre = draw("Carre_rouge.save.jpg") # retourne l'instance photoimage
construct(canvas, 50, 20, 0, cases, carre) # construction des carrés
 
canvas.bind("<Button-1>", click) # Exécution de la fonction click lors de l'appui sur le bouton gauche
 
root.mainloop()

Je pense que tu as à peu près tout ce qu'il te faut pour continuer jusqu'au bout le projet.

**MrGalactique** · 20/05/2013, 12h50

Merci pour votre aide, malheureusement, plusieurs messages d'erreur me sont envoyés.

"from PIL import image" ne marche pas, "PIL" n'est pas reconnu. J'ai alors changé cette ligne par "import Image", mais cela ne marche toujours pas.

Ensuite, tout au long du programme, et, d'une manière plus générale, a chaque fois qu'il y a inscrit "Image" ils me disent que Image n'est pas défini.

Pour finir, j'ai téléchargé votre image de carré rouge, mais êtes-vous sûr que "path" est bien censé me le retrouver sur mon disque dur ?