-
Notifications
You must be signed in to change notification settings - Fork 0
/
game_funcs.py
128 lines (115 loc) · 4.56 KB
/
game_funcs.py
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
from color import Color
from random import choice
from tkinter import messagebox
possible_combinations = []
def computer_solve(palette: list[Color], combination: list[Color], combination_nb_elements: int, number_of_turns: int) -> None | int:
"""
This function automatically finds the correct combination, concurring with the user.
:param palette:
:param combination:
:param combination_nb_elements:
:param number_of_turns:
:return:
"""
possible_combinations.clear()
combination_loop(0, combination_nb_elements, palette, [])
previous_guesses = []
for i in range(number_of_turns):
guess = []
if len(previous_guesses) == 0:
guess = possible_combinations[0]
else:
for possible_combination in possible_combinations:
valid_guess = True
guess = possible_combination
for previous_guess in previous_guesses:
correct_placements_with_previous = number_of_correct_placements(previous_guess["guess"], possible_combination)
correct_colors_with_previous = number_of_correct_colors(previous_guess["guess"], possible_combination)
if correct_placements_with_previous != previous_guess["correct_placements"] or correct_colors_with_previous != previous_guess["correct_colors"]:
valid_guess = False
break
if valid_guess:
break
correct_placements = number_of_correct_placements(combination, guess)
if correct_placements == combination_nb_elements:
return i + 1
correct_colors = number_of_correct_colors(combination, guess)
previous_guesses.append({
"guess": guess,
"correct_placements": correct_placements,
"correct_colors": correct_colors
})
return None
def combination_loop(iteration: int, combination_nb_elements: int, palette: list[Color], colors: list[Color]) -> None:
"""
This recursive function loops through all possible combinations.
:param iteration:
:param combination_nb_elements:
:param palette:
:param colors:
:return:
"""
if iteration < combination_nb_elements:
for color in palette:
colors_rec = colors[:]
colors_rec.append(color)
combination_loop(iteration + 1, combination_nb_elements, palette, colors_rec)
else:
possible_combinations.append(colors)
def generate_combination(palette: list[Color], combination_nb_elements: int) -> list[Color]:
"""
This function randomly generates a combination.
:param palette:
:param combination_nb_elements:
:return:
"""
combination = []
for _ in range(combination_nb_elements):
combination.append(choice(palette))
return combination
def number_of_correct_colors(combination: list[Color], guess: list[Color]) -> int: # White pawns
"""
This function calculates the number of pawns of right colors, but placed wrongly.
:param combination:
:param guess:
:return:
"""
current_combination = combination[:]
for k, color_guess in enumerate(guess):
if current_combination[k] == color_guess:
current_combination[k] = ''
number = 0
for k, color_guess in enumerate(guess):
if color_guess == combination[k]:
continue
if (color_guess in current_combination) and (current_combination[k] != color_guess):
for i, combination_color in enumerate(current_combination):
if combination_color == color_guess:
current_combination[i] = ''
break
number += 1
return number
def number_of_correct_placements(combination: list[Color], guess: list[Color]) -> int: # Red pawns
"""
This function calculates the number of pawns of the right color, placed correctly.
:param combination:
:param guess:
:return:
"""
number = 0
for k, element in enumerate(guess):
if combination[k] == element:
number += 1
return number
def show_score(score, nb_parti):
"""
This function shows the current saved score using a Tkinter message box.
:param score:
:param nb_parti:
:return:
"""
ratio_text = ""
if nb_parti != 0:
ratio = score / nb_parti
ratio_text = f"Score moyen : {str(round(ratio, 2)).replace('.', ',')}" # French way of writing floating point numbers.
messagebox.showinfo("Statistiques", f"Nombre de parties : {nb_parti}\nScore total : {score}\n{ratio_text}")