Discussion :

[MrGalactique]

Voici la version opérationelle du jeu :

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
from random import randint
from PIL import Image, ImageTk
from Tkinter import Canvas, Tk, NW
 
# Constantes
ROW = 5
COLUMN = 5
INIT = -1
score = 1
 
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):
 
    #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 ou 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 carre
    #begin -> valeur de x ou commence la ligne
    #y_begin -> valeur de y ou commence la ligne
    #case -> tableau de situation des objets
    #picture -> instance de PhotoImage
 
    DISTANCE = 5 # distance entre chaque carre
    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 construct_value(can, size, begin, y_begin, case):
 
    DISTANCE = 5 # distance entre chaque carre
    y = y_begin
    for line in case:
        y += (size + DISTANCE)
        x = begin
        for n in line:
            canvas.create_text(x, y, text=n)
            x += (size + DISTANCE)           
 
def click(event):
    global score
    item = canvas.find_closest(event.x, event.y) # recherche l'item en fonction des coordonnees du click
    canvas.delete(item) # suppression de l'item
    item = canvas.find_closest(event.x, event.y) # on recupere la valeur en dessous de la case rouge
    val = int(canvas.itemcget(item, 'text')) # on la transforme en entier
    score *= val
    if score == 0:
        canvas.create_text(400, 300, text="Vous avez perdu !")
    if score == 72:
        canvas.create_text(400, 300, text="Vous avez gagnez !")
    canvas.itemconfig(c, text="score : {}".format(score))
 
if score == 0:
	canvas.create_text(400, 300, text="Vous avez perdu")
 
if score == 72:
	canvas.create_text(400, 300, text="Vous avez gagnez")
 
def calculate(case):
    "Calcul du score maxi"
    score_max = 1
    for line in case:
        for n in line:
            if n > 0:
                score_max *= n
    return score_max
 
# creation d'un tableau a 2 dimensions compose de -1
cases = create(ROW, COLUMN, INIT)
 
 
# Ajout du nombre 0, 1, 2, 3 (value), 6, 14, 3, 2 fois (nbr), k vaut -1 par defaut 
cases = add(0, 6, cases)
cases = add(1, 14, cases)
cases = add(2, 3, cases)
cases = add(3, 2, cases)  
 
root = Tk()
root.title('Le Jeu')
 
canvas = Canvas(root, width = 640, height = 480) # Creation du canvas
canvas.pack()
 
construct_value(canvas, 50, 20, 0, cases)
carre = draw("Carre_rouge_save.jpg") # retourne l'instance photoimage
construct(canvas, 50, 20, 0, cases, carre) # construction des carres
 
x, y = 300, 45 # sur chaque somme, on revient a x = 300
for line in cases:
    somme = reckon(line)
    canvas.create_text(x, y, text="{}".format(somme))
    y += 55 # on descend de 55 pour la ligne suivante
 
x, y = 300, 65 
for line in cases:
    Nb_Mines = reckon(line, 0)
    canvas.create_text(x, y, text="{}".format(Nb_Mines))
    y += 55 # on descend de 55 pour la ligne suivante
 
x, y = 20, 320 # sur chaque somme, on revient a y = 320
for i in range(COLUMN):
    line = []
    for j in range(ROW):
        line.append(cases[j][i])	
    somme = reckon(line)
    canvas.create_text(x, y, text="{}".format(somme))
    x += 55 # on decale de 55 pour la colonne suivante
 
x, y = 20, 340 
for i in range(COLUMN):
    line = []
    for j in range(ROW):
        line.append(cases[j][i])	
    Nb_Mines = reckon(line, 0)
    canvas.create_text(x, y, text="{}".format(Nb_Mines))
    x += 55 # on decale de 55 pour la colonne suivante
 
c = canvas.create_text(400, 20, text="score : {}".format(score))
canvas.create_text(400, 40, text="score maximum : {}".format(calculate(cases)))
 
canvas.bind("<Button-1>", click) # Execution de la fonction click lors de l'appui sur le bouton gauche
 
root.mainloop()

A part si vous souhaitez réctifier une ligne ou deux, ce topic peut être considéré comme étant "RESOLU".
Merci une fois de plus pour m'avoir aidé à la concrétisation de ce jeu.

[fred1599]

Certes on peut toujours améliorer, cependant avoir une partie de votre réflexion présente dans le code n'est pas plus mal et a du mérite.

Bonne continuation.

P.S Si c'est résolu n'oubliez pas de le préciser...

[MrGalactique]

Certes on peut toujours améliorer

C'est vrai, on peut toujours améliorer en créant par exemple une nouvelle fonction qui permet de mettre fin à la fonction click lorsque le joueur a gagné ou a perdu.
Si vous pouviez me donner uniquement le nom de la fonction, ce serait parfait. J'essayerai ainsi de définir la fonction moi-même et y mettre mes conditions.

[fred1599]

Tu vas interpréter un score, pourquoi pas render, avec comme paramètre score, non?

Code :

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

1
2
3
4
5
6
def render(can, score):
    '''
    can -> canvas
    score -> un entier représentant le score
    '''
    # suite