from Cartes.Map_Ligne13 import MapLigne13
class AlgoAleatoireInterne(JoueurInterne):
"""
Joueur avec la fonction de décision aléatoire de Charles
"""
class AlgoMinMax(JoueurInterne):
"""
Une réécriture de la classe JoueurInterne
"""
def next_moves(self, show_map=True):
depth_max = 3
if show_map: self.map.print_map()
racine = SommetOutcome_MinMax(depth=depth_max, game_map=deepcopy(self.map), is_vamp=self.is_vamp, init_map=True)
return racine.next_move()
@classmethod
def nb_vertices_created(cls):
return SommetOutcome_MinMax.nb_vertices_created() + SommetChance_MinMax.nb_vertices_created()
if __name__ == "__main__":
Joueur1 = AlgoAleatoireInterne
Joueur2 = AlgoMinMax
carte = Map
Serveur = ServeurInterne(carte, Joueur1, Joueur2, name1="ALEA", name2="MINIMAX", print_map=True, debug_mode=False)
Serveur.start()
Serveur.join()
print(AlgoMinMax.nb_vertices_created())
queue_master_slave.put(0)
next_move = next(
self.map.i_next_relevant_moves(self.is_vamp, nb_group_max=2))
print("TimeOut !")
else:
next_move = queue_slave_master.get_nowait()
print("MPOO:", next_move)
return next_move
@classmethod
def nb_vertices_created(cls):
return SommetDuJeu_Negascout.nb_vertices_created()
if __name__ == "__main__":
Joueur1 = AlgoNegascout
Joueur2 = AlgoNegMax_MPOO
carte = Map8
Serveur = ServeurInterne(carte,
Joueur1,
Joueur2,
name1="Joueur1",
name2="Joueur2",
print_map=True,
debug_mode=False)
Serveur.start()
#Joueur_1=AlgoNegMax_MPOO()
#Joueur_1.start()
#Joueur_1.join()
if max_child == robust_child:
return max_child.previous_moves
else:
n_threshold = max_child.n_games / 4
selected_children = filter(
lambda child: child.n_games > n_threshold, racine.children)
return max(selected_children,
key=lambda child: child.n_wins / child.n_games
if child.n_games != 0 else 0).previous_moves
@classmethod
def nb_vertices_created(cls):
return SommetMonteCarlo.nb_vertices_created()
if __name__ == "__main__":
Joueur1 = AlgoNaive
Joueur2 = AlgoMCTSMPOO
Carte = MapLigne13
Serveur = ServeurInterne(Carte,
Joueur1,
Joueur2,
name1="Aléatoire",
name2="MonteCarlo",
print_map=True,
debug_mode=True)
Serveur.start()
Serveur.join()
print(AlgoMCTSMPOO.nb_vertices_created())
from Joueur import Joueur
from Joueur_Interne import JoueurInterne
from Serveur_Interne import ServeurInterne
from Map import Map
class AlgoAleatoire(JoueurInterne):
"""
Joueur avec la fonction de décision aléatoire de Charles
"""
class AlgoAleatoireInterne(JoueurInterne):
"""
Joueur avec la fonction de décision aléatoire de Charles
"""
@classmethod
def nb_vertices_created(cls):
return 0
if __name__=="__main__":
# Joueur Interne
Joueur1=AlgoAleatoireInterne
Joueur2 =AlgoAleatoireInterne
Serveur=ServeurInterne(Map,Joueur1,Joueur2)
Serveur.start()
# Joueur Réel
#Joueur_1=AlgoAleatoire()
#Joueur_1.start()
#Joueur_1.join()
def tournoi(pool, population_dic, nb_survivors=10):
"""
A partir des cartes définies plus haut, on effectue tous les duels possibles, et on les joue N_GAME fois et on renvoie les N_SURVIVORS
:return: ranking des N_SURVIVORS
"""
# Dictionnaire de scores
# de la forme result[1er_joueur][2eme_joueur][carte]=[nombre partie gagnée attaquant, nombre partie gagné défenseur]
result = {}
# Dictionnaire des statistiques, enregistre le temps maximal d'un tour, le nombre de tours joués, le nombre de partie jouée
# la durée totale de jeu, le nombre de victoires et de défaites
stats = {}
# Parcours de toutes les paires possibles de joueurs
MAPS = { # "Dust2": MapDust2,
#"Map8": Map8,
# "TheTrap":MapTheTrap,
"CarteAléatoire": MapRandom
}
# Dictionnaires des algorithmes de décision : nom de l'algo --> algo (classe)
for (individual_1, individual_2) in combinations(pool, 2):
individual_1_name = individual_1[0]
individual_1_properties = individual_1[1]
individual_2_name = individual_2[0]
individual_2_properties = individual_2[1]
if individual_1_name not in result:
result[individual_1_name] = {individual_2_name: {}}
else:
result[individual_1_name][individual_2_name] = {}
if individual_1_name not in stats:
stats[individual_1_name] = {
"total_play_duration": 0,
"max_play_duration": 0,
"nb_play": 0,
"nb_victories": 0,
"nb_defeats": 0,
"nb_vertices": 0
}
if individual_2_name not in stats:
stats[individual_2_name] = {
"total_play_duration": 0,
"max_play_duration": 0,
"nb_play": 0,
"nb_victories": 0,
"nb_defeats": 0,
"nb_vertices": 0
}
# Parcours de toutes les cartes du tournois
for game_map_name, game_map in MAPS.items():
result[individual_1_name][individual_2_name][game_map_name] = [
0, 0
]
# On joue les N_GAME parties
for _ in range(0, N_GAME):
# On créé les algo à partir des caractéristiques individuelles
class algo_individual_1(AlgoNegMax_MPOO):
def __init__(self,
q_p_s,
q_s_p,
name=None,
debug_mode=False):
""" On ajoute des hyper paramètres qui permettent de différencier différents individus parmi ces algos
"""
super().__init__(q_p_s,
q_s_p,
name=None,
debug_mode=False)
self.depth_max = individual_1_properties['depth_max']
self.nb_group_max = individual_1_properties[
'nb_group_max']
self.nb_cases = individual_1_properties['nb_cases']
class algo_individual_2(AlgoNegMax_MPOO):
def __init__(self,
q_p_s,
q_s_p,
name=None,
debug_mode=False):
""" On ajoute des hyper paramètres qui permettent de différencier différents individus parmi ces algos
"""
super().__init__(q_p_s,
q_s_p,
name=None,
debug_mode=False)
self.depth_max = individual_2_properties['depth_max']
self.nb_group_max = individual_2_properties[
'nb_group_max']
self.nb_cases = individual_2_properties['nb_cases']
server_game = ServeurInterne(game_map,
algo_individual_1,
algo_individual_2,
name1=individual_1_name,
name2=individual_2_name,
print_map=False)
server_game.start()
server_game.join()
# Enregistrement des scores et des statistiques de la partie
if server_game.winner: # Si le joueur attaquant en premier gagne
result[individual_1_name][individual_2_name][
game_map_name][0] += 1
stats[individual_1_name]["nb_victories"] += 1
stats[individual_2_name]["nb_defeats"] += 1
else: # Si le joueur défendant en premier gagne
result[individual_1_name][individual_2_name][
game_map_name][1] += 1
stats[individual_1_name]["nb_defeats"] += 1
stats[individual_2_name]["nb_victories"] += 1
stats[individual_1_name][
"total_play_duration"] += server_game.total_play_duration_1
stats[individual_2_name][
"total_play_duration"] += server_game.total_play_duration_2
stats[individual_1_name]["max_play_duration"] = max(
stats[individual_1_name]["max_play_duration"],
server_game.max_play_duration_1)
stats[individual_2_name]["max_play_duration"] = max(
stats[individual_2_name]["max_play_duration"],
server_game.max_play_duration_2)
stats[individual_1_name]["nb_play"] += server_game.nb_play_1
stats[individual_2_name]["nb_play"] += server_game.nb_play_2
stats[individual_1_name][
"nb_vertices"] += algo_individual_1.nb_vertices_created()
stats[individual_2_name][
"nb_vertices"] += algo_individual_2.nb_vertices_created()
# Affichage des résultats du tournoi
print()
for algo_1_name in result:
for algo_2_name in result[algo_1_name]:
for game_map_name in MAPS:
score = result[algo_1_name][algo_2_name][game_map_name]
print(
f"Match sur {game_map_name} {algo_1_name} {score[0]}:{score[1]} {algo_2_name}"
)
# Classement
print()
ranking = sorted((algo_name for algo_name in stats),
key=lambda algo: stats[algo]["nb_victories"] /
(stats[algo]["nb_victories"] + stats[algo]["nb_defeats"]),
reverse=True)
for i, algo_name in enumerate(ranking):
n_game = stats[algo_name]['nb_victories'] + stats[algo_name][
'nb_defeats']
win_rate = stats[algo_name]['nb_victories'] / n_game
average_play_duration = stats[algo_name][
'total_play_duration'] / stats[algo_name]['nb_play']
max_play_duration = stats[algo_name]['max_play_duration']
vertices_created_per_round = stats[algo_name]['nb_vertices'] / stats[
algo_name]['nb_play']
print(f"{i+1}. {algo_name} : win ratio {win_rate:.2%}")
print(f"\tDictionnaire de caractéristiques individuelles :")
print(population_dic[algo_name])
print(
f"\tAverage play duration : \t\t\t\t{average_play_duration:.2f}s")
print(f"\tMaximum duration of a play : \t\t\t{max_play_duration:.2f}s")
print(
f"\tNumber of vertices created per play : \t{vertices_created_per_round:.0f} vertices"
)
return ranking[:nb_survivors]
def main():
"""
A partir des cartes définies plus haut, on effectue tous les duels possibles, et on les joue N_GAME fois
:return: dictionnaire des scores
"""
# Dictionnaire de scores
# de la forme result[1er_joueur][2eme_joueur][carte]=[nombre partie gagnée attaquant, nombre partie gagné défenseur]
result = {}
# Dictionnaire des statistiques, enregistre le temps maximal d'un tour, le nombre de tours joués, le nombre de partie jouée
# la durée totale de jeu, le nombre de victoires et de défaites
stats = {}
# Parcours de toutes les paires possibles de joueurs
for (algo_1_name, algo_1), (algo_2_name,
algo_2) in combinations(ALGOS.items(), 2):
if algo_1_name not in result:
result[algo_1_name] = {algo_2_name: {}}
else:
result[algo_1_name][algo_2_name] = {}
if algo_1_name not in stats:
stats[algo_1_name] = {
"total_play_duration": 0,
"max_play_duration": 0,
"nb_play": 0,
"nb_victories": 0,
"nb_defeats": 0,
"nb_vertices": 0
}
if algo_2_name not in stats:
stats[algo_2_name] = {
"total_play_duration": 0,
"max_play_duration": 0,
"nb_play": 0,
"nb_victories": 0,
"nb_defeats": 0,
"nb_vertices": 0
}
# Parcours de toutes les cartes du tournois
for game_map_name, game_map in MAPS.items():
result[algo_1_name][algo_2_name][game_map_name] = [0, 0]
# On joue les N_GAME /2 parties
for _ in range(N_GAME - (N_GAME // 2)):
server_game = ServeurInterne(game_map,
algo_1,
algo_2,
name1=algo_1_name,
name2=algo_2_name,
print_map=False)
server_game.start()
server_game.join()
# Enregistrement des scores et des statistiques de la partie
if server_game.winner: # Si le joueur attaquant en premier gagne
result[algo_1_name][algo_2_name][game_map_name][0] += 1
stats[algo_1_name]["nb_victories"] += 1
stats[algo_2_name]["nb_defeats"] += 1
else: # Si le joueur défendant en premier gagne
result[algo_1_name][algo_2_name][game_map_name][1] += 1
stats[algo_1_name]["nb_defeats"] += 1
stats[algo_2_name]["nb_victories"] += 1
stats[algo_1_name][
"total_play_duration"] += server_game.total_play_duration_1
stats[algo_2_name][
"total_play_duration"] += server_game.total_play_duration_2
stats[algo_1_name]["max_play_duration"] = max(
stats[algo_1_name]["max_play_duration"],
server_game.max_play_duration_1)
stats[algo_2_name]["max_play_duration"] = max(
stats[algo_2_name]["max_play_duration"],
server_game.max_play_duration_2)
stats[algo_1_name]["nb_play"] += server_game.nb_play_1
stats[algo_2_name]["nb_play"] += server_game.nb_play_2
# On joue les N_GAME /2 parties en inversant l'ordre des joueurs
for _ in range(N_GAME // 2):
server_game = ServeurInterne(game_map,
algo_2,
algo_1,
name1=algo_2_name,
name2=algo_1_name,
print_map=False)
server_game.start()
server_game.join()
# Enregistrement des scores
if server_game.winner: # Si le joueur attaquant en premier gagne
result[algo_1_name][algo_2_name][game_map_name][1] += 1
stats[algo_1_name]["nb_defeats"] += 1
stats[algo_2_name]["nb_victories"] += 1
else: # Si le joueur défendant en premier gagne
result[algo_1_name][algo_2_name][game_map_name][0] += 1
stats[algo_1_name]["nb_victories"] += 1
stats[algo_2_name]["nb_defeats"] += 1
stats[algo_1_name][
"total_play_duration"] += server_game.total_play_duration_2
stats[algo_2_name][
"total_play_duration"] += server_game.total_play_duration_1
stats[algo_1_name]["max_play_duration"] = max(
stats[algo_1_name]["max_play_duration"],
server_game.max_play_duration_2)
stats[algo_2_name]["max_play_duration"] = max(
stats[algo_2_name]["max_play_duration"],
server_game.max_play_duration_1)
stats[algo_1_name]["nb_play"] += server_game.nb_play_2
stats[algo_2_name]["nb_play"] += server_game.nb_play_1
for algo_name, algo_class in ALGOS.items():
stats[algo_name]["nb_vertices"] = algo_class.nb_vertices_created()
# Affichage des résultats du tournoi
print()
for algo_1_name in result:
for algo_2_name in result[algo_1_name]:
for game_map_name in MAPS:
score = result[algo_1_name][algo_2_name][game_map_name]
print(
f"Match sur {game_map_name} {algo_1_name} {score[0]}:{score[1]} {algo_2_name}"
)
# Classement
print()
ranking = sorted((algo_name for algo_name in stats),
key=lambda algo: stats[algo]["nb_victories"] /
(stats[algo]["nb_victories"] + stats[algo]["nb_defeats"]),
reverse=True)
for i, algo_name in enumerate(ranking):
n_game = stats[algo_name]['nb_victories'] + stats[algo_name][
'nb_defeats']
win_rate = stats[algo_name]['nb_victories'] / n_game
average_play_duration = stats[algo_name][
'total_play_duration'] / stats[algo_name]['nb_play']
max_play_duration = stats[algo_name]['max_play_duration']
vertices_created_per_round = stats[algo_name]['nb_vertices'] / stats[
algo_name]['nb_play']
print(f"{i+1}. {algo_name} : win ratio {win_rate:.2%}")
print(
f"\tAverage play duration : \t\t\t\t{average_play_duration:.2f}s")
print(f"\tMaximum duration of a play : \t\t\t{max_play_duration:.2f}s")
print(
f"\tNumber of vertices created per play : \t{vertices_created_per_round:.0f} vertices"
)
class AlgoAleatoireInterne(JoueurInterne):
"""
Joueur avec la fonction de décision aléatoire de Charles
"""
class AlgoNegMaxOriente(JoueurInterne):
"""
Une réécriture de la classe JoueurInterne
"""
def next_moves(self, show_map=True):
depth_max = 3
if show_map: self.map.print_map()
racine = SommetDuJeu_NegaMax_Oriente(depth=depth_max, game_map=deepcopy(self.map), is_vamp=self.is_vamp, init_map=True)
return racine.next_move()
@classmethod
def nb_vertices_created(cls):
return SommetDuJeu_NegaMax_Oriente.nb_vertices_created()+ SommetChance_NegaMax_Oriente.nb_vertices_created()
if __name__ == "__main__":
Joueur1 = AlgoAleatoireInterne
Joueur2 = AlgoNegMaxOriente
carte=MapTheTrap
Serveur = ServeurInterne(carte, Joueur1, Joueur2, name1="ALEA", name2="NegaMax_Orienté")
Serveur.start()
while time() < start_time + 2:
racine.temporal_difference_0()
if racine.is_vamp:
return max(racine.children,
key=lambda child: child.value).previous_moves
else:
return min(racine.children,
key=lambda child: child.value).previous_moves
@classmethod
def nb_vertices_created(cls):
return SommetOutcome_TemporalDifference.nb_vertices_created(
) + SommetChance_TemporalDifference.nb_vertices_created()
if __name__ == "__main__":
Joueur1 = AlgoAleatoireInterne
Joueur2 = AlgoTemporalDifference0
MapDust2 = MapDust2
Serveur = ServeurInterne(MapDust2,
Joueur1,
Joueur2,
name1="Aléatoire",
name2="TD0",
print_map=True,
debug_mode=False)
Serveur.start()
Serveur.join()
print(AlgoTemporalDifference0.nb_vertices_created())
# return moves
if better_moves is None:
better_moves = moves
better_evaluation = self.evaluate_moves(moves)
elif better_evaluation > self.evaluate_moves(moves):
better_moves = moves
better_evaluation = self.evaluate_moves(moves)
else:
# On ne trouve pas de mouvement améliorant la situation du joueur,
# On renvoie le moins pire des mouvements trouvés
return better_moves
@classmethod
def nb_vertices_created(cls):
return 0
if __name__ == '__main__':
Joueur1 = AlgoCustomizedEvaluation
Joueur2 = AlgoAleatoireInterne
MapDust2 = MapTheTrap
Serveur = ServeurInterne(MapDust2,
Joueur1,
Joueur2,
name1="Evaluation",
name2="Aléatoire",
print_map=True)
Serveur.start()