def Min_Value_Alpha_Beta(state,joueur,opposant,alpha,beta,prof_act,prof_max,nb_jetons):
if(Fonctions_de_base.Terminal_Test(state,nb_jetons) or prof_act==prof_max) : return Fonctions_de_base.Utility_Vincent_Remi(state,joueur,opposant)
prof_act+=1
nb_jetons+=1
#valeur infiniment haute
v = 10000000000
#Ici ce sont les actions de l'opposant qu'on prend car c'est son tour
#! Diminution de l'amplitude de l'arbre
liste_value=[]
liste_action = []
for a in Fonctions_de_base.Action(state):
value = Fonctions_de_base.Utility_Vincent_Remi(Fonctions_de_base.Result(state,a,opposant), joueur, opposant)
liste_value.append(value)
liste_action.append(a)
# * ON PEUT MODIFIER LE POURCENTAGE
# * ON PREND LES % PIRES PLAYS CAR C'EST L'ADVERSAIRE QUI JOUE
# * ON GAGNE AINSI DU TEMPS ET ON NE REGARDE PAS LES PLAYS ININTERESSANTS
liste_action_conservees = []
for i in range(int(len(liste_value)*pourcentage_amplitude)):
index_value_min = liste_value.index(min(liste_value))
liste_action_conservees.append(liste_action[index_value_min])
del liste_value[index_value_min]
del liste_action[index_value_min]
#! FIN Diminution de l'amplitude de l'arbre
for a in liste_action_conservees:
v = min(v,Max_Value_Alpha_Beta(Fonctions_de_base.Result(state,a,opposant),joueur,opposant,alpha,beta,prof_act,prof_max,nb_jetons))
if (v <= alpha) : return v
beta = min(beta,v)
return v
def Min_Value(state, joueur, opposant):
if (Fonctions_de_base.Terminal_Test(state)):
return Fonctions_de_base.Utility(state, joueur)
#valeur infiniment haute
v = 2
#Ici ce sont les actions de l'opposant qu'on prend car c'est son tour
for a in Fonctions_de_base.Action(state, opposant):
v = min(
v, Max_Value(Fonctions_de_base.Result(state, a), joueur, opposant))
return v
def Max_Value_Alpha_Beta(state,
joueur,
opposant,
alpha,
beta,
renvoyer_action=False):
if (Fonctions_de_base.Terminal_Test(state)):
return Fonctions_de_base.Utility(state, joueur)
#valeur infiniment haute
v = -2
if (renvoyer_action):
sauvegarde_action = []
#Ici ce sont les actions du joueur qu'on prend car c'est son tour
for a in Fonctions_de_base.Action(state, joueur):
ancien_v = v
v = max(
v,
Min_Value_Alpha_Beta(Fonctions_de_base.Result(state, a),
joueur, opposant, alpha, beta))
if (ancien_v != v): sauvegarde_action = a
if (v >= beta): return [v, sauvegarde_action]
alpha = max(alpha, v)
return [v, sauvegarde_action]
#Ici ce sont les actions de l'opposant qu'on prend car c'est son tour
for a in Fonctions_de_base.Action(state, joueur):
v = max(
v,
Min_Value_Alpha_Beta(Fonctions_de_base.Result(state, a), joueur,
opposant, alpha, beta))
if (v >= beta): return v
alpha = max(alpha, v)
return v
def Max_Value(state, joueur, opposant, renvoyer_action=False):
if (Fonctions_de_base.Terminal_Test(state)):
return Fonctions_de_base.Utility(state, joueur)
#valeur infiniment basse
v = -2
if (renvoyer_action):
sauvegarde_action = []
#Ici ce sont les actions du joueur qu'on prend car c'est son tour
for a in Fonctions_de_base.Action(state, joueur):
ancien_v = v
v = max(
v,
Min_Value(Fonctions_de_base.Result(state, a), joueur,
opposant))
if (ancien_v != v): sauvegarde_action = a
return [v, sauvegarde_action]
#Ici ce sont les actions du joueur qu'on prend car c'est son tour
for a in Fonctions_de_base.Action(state, joueur):
v = max(
v, Min_Value(Fonctions_de_base.Result(state, a), joueur, opposant))
return v
#Choix commencement
while True: #*on répète jusqu'à ce qu'un des deux symbole soit choisi
first = input('Choisir qui commence (X/O) \n')
if (first == 'X'): break
if (first == 'O'): break
clear()
plateau = Initialisation.Plateau()
nb_jetons = 0
check_partie_fini = False
while (not check_partie_fini):
if (first == humain): #Si l'humain joue en premier
print(plateau)
list_Actions = Fonctions_de_base.Action(
plateau) #On recupere toutes les actions possibles
for i in range(len(list_Actions)):
list_Actions[i] += 1
print("Action(s) possible(s) : ", list_Actions)
# print("\n" + Reaction())#Pour rendre le jeu plus vivant
action = ""
action_Autorise = False #Verification que ce coup est autorise
while (action_Autorise == False):
action = Selection_colonne(
'\nHumain, indique la colonne dans laquelle tu veux placer ton pion (1-12) \n'
)
if (action in list_Actions):
action_Autorise = True
plateau = Fonctions_de_base.Result(
plateau, action - 1, humain
) #action-1 car si on rentre 1 alors c'est l'index 0 de la colonne
def testAction(self):
liste = Fonctions_de_base.Action([['X','',''],['O','X',''],['','O','O']], 'X')
self.assertEqual(liste,[['X', 0, 1], ['X', 0, 2], ['X', 1, 2], ['X', 2, 0]])
def testUtility0(self):
liste = [['O','X','O'],['O','X','O'],['X','O','X']]
result = Fonctions_de_base.Utility(liste,'X')
self.assertEqual(result, 0)
def testTerminalDiagonal(self):
state = [['X','X','O'],['O','X',''],['','O','X']]
self.assertTrue(Fonctions_de_base.Terminal_Test(state,3))
def testTerminalPasFini(self):
state = [['X','O','X'],['','',''],['','O','O']]
self.assertFalse(Fonctions_de_base.Terminal_Test(state,3))
def testResult(self):
liste = [['X','',''],['O','X',''],['','O','O']]
liste = Fonctions_de_base.Result(liste,['X', 0, 1])
self.assertEqual(liste, [['X','X',''],['O','X',''],['','O','O']])
def Max_Value_Alpha_Beta(state, joueur, opposant, alpha, beta, prof_act,
prof_max, pourcentage_amplitude, nb_jetons):
if (Fonctions_de_base.Terminal_Test(state, nb_jetons)
or prof_act == prof_max):
return Fonctions_de_base.Utility_Vincent_Remi(state, joueur, opposant)
prof_act += 1
nb_jetons += 1
#valeur infiniment basse
v = -1000000000000
if (prof_act == 1):
sauvegarde_action = []
#Ici ce sont les actions du joueur qu'on prend car c'est son tour
#! Diminution de l'amplitude de l'arbre
liste_value = []
liste_action = []
for a in Fonctions_de_base.Action(state):
value = Fonctions_de_base.Utility_Vincent_Remi(
Fonctions_de_base.Result(state, a, joueur), joueur, opposant)
liste_value.append(value)
liste_action.append(a)
# * ON PEUT MODIFIER LE POURCENTAGE
# * ON PREND LES % MEILLEURS PLAYS CAR C'EST L'IA QUI JOUE
# * ON GAGNE AINSI DU TEMPS ET ON NE REGARDE PAS LES PLAYS ININTERESSANTS
liste_action_conservees = []
for i in range(int(len(liste_value) * pourcentage_amplitude)):
index_value_min = liste_value.index(max(liste_value))
liste_action_conservees.append(liste_action[index_value_min])
del liste_value[index_value_min]
del liste_action[index_value_min]
#! FIN Diminution de l'amplitude de l'arbre
for a in liste_action_conservees:
ancien_v = v
v = max(
v,
Min_Value_Alpha_Beta(
Fonctions_de_base.Result(state, a, joueur), joueur,
opposant, alpha, beta, prof_act, prof_max,
pourcentage_amplitude, nb_jetons))
if (ancien_v < v): sauvegarde_action = a
if (v >= beta): return [v, sauvegarde_action]
alpha = max(alpha, v)
return [v, sauvegarde_action]
#Ici ce sont les actions de l'opposant qu'on prend car c'est son tour
#! Diminution de l'amplitude de l'arbre
liste_value = []
liste_action = []
for a in Fonctions_de_base.Action(state):
value = Fonctions_de_base.Utility_Vincent_Remi(
Fonctions_de_base.Result(state, a, joueur), joueur, opposant)
liste_value.append(value)
liste_action.append(a)
# * ON PEUT MODIFIER LE POURCENTAGE
# * ON PREND LES % MEILLEURS PLAYS CAR C'EST L'IA QUI JOUE
# * ON GAGNE AINSI DU TEMPS ET ON NE REGARDE PAS LES PLAYS ININTERESSANTS
liste_action_conservees = []
for i in range(int(len(liste_value) * pourcentage_amplitude)):
index_value_min = liste_value.index(max(liste_value))
liste_action_conservees.append(liste_action[index_value_min])
del liste_value[index_value_min]
del liste_action[index_value_min]
#! FIN Diminution de l'amplitude de l'arbre
for a in liste_action_conservees:
v = max(
v,
Min_Value_Alpha_Beta(Fonctions_de_base.Result(state, a, joueur),
joueur, opposant, alpha, beta, prof_act,
prof_max, pourcentage_amplitude, nb_jetons))
if (v >= beta): return v
alpha = max(alpha, v)
return v
check_partie_fini = False
while (not check_partie_fini):
if (first == humain): #Si l'humain joue en premier
montemps = time.time(
) #Temps de reference pr le chronometre en seconde
#number of seconds passed since epoch (January 1, 1970, 00:00:00 at UTC = the point where time begins)
action = Alpha_Beta(plateau, humain, humain_prof_max,
humain_pourcentage, nb_jetons)
nv_Temps = time.time()
if (nv_Temps - montemps >= temps_Max_Calcul):
discalifie = humain
break
plateau = Fonctions_de_base.Result(plateau, action[1], humain)
nb_jetons += 1
#!Si la partie est finie, l'IA ne joue pas
check_partie_fini = Fonctions_de_base.Terminal_Test(
plateau, nb_jetons)
if (check_partie_fini): break
#! L'IA détermine son play ici
montemps = time.time()
action = Alpha_Beta(plateau, ia, ia_prof_max, ia_pourcentage,
nb_jetons)
nv_Temps = time.time()
if (nv_Temps - montemps >= temps_Max_Calcul):
discalifie = ia
break