def __init__(self, editor):
super().__init__(editor)
self.resizable(False, False)
self.title("TP3 - Backtracking")
self.vista = Vista(self, editor.mapa)
self.vista.grid()
self.ia = IA(editor.mapa)
self.bind('<Escape>', lambda e: self.destroy())
self.actualizar_vista()
self.esperar_y_avanzar()
def creer_joueurs(self):
"""
Crée les 4 joueurs (Humains et IAs et les répartit aléatoirement
"""
liste = [i+1 for i in range(self.nb_clients)] + [0]*(4-self.nb_clients)
random.shuffle(liste)
for i, p in enumerate(liste):
if p > 0:
self.envoi(self.clients[p-1], "indice,"+str(i))
self.players.append(Human(0, i, self.clients[p-1]))
else:
self.players.append(IA(0, i, self.database))
class ModoIA(tk.Toplevel):
def __init__(self, editor):
super().__init__(editor)
self.resizable(False, False)
self.title("TP3 - Backtracking")
self.vista = Vista(self, editor.mapa)
self.vista.grid()
self.ia = IA(editor.mapa)
self.bind('<Escape>', lambda e: self.destroy())
self.actualizar_vista()
self.esperar_y_avanzar()
def esperar_y_avanzar(self):
self.after(50, self.avanzar)
def avanzar(self):
self.ia.avanzar()
self.actualizar_vista()
self.esperar_y_avanzar()
def actualizar_vista(self):
coord_jugador = self.ia.coord_jugador()
visitados = set(self.ia.visitados())
camino = set(self.ia.camino())
def obtener_color_celda(mapa, coord):
return Color.backtracking(mapa, coord, coord_jugador, visitados,
camino)
self.vista.actualizar(obtener_color_celda)
def mover_peca(self, casa_destino: Casa):
"""
Move a atual peça selecionada para a casa escolhida. Considera jogadas especiais.
:param casa_destino: Casa que foi escolhida para a peça ser movida.
:return:
"""
peca_movida: PecaBase = self.casa_selecionada.peca
peca_movida.movimentos += 1
self.casa_selecionada.remover_peca()
if casa_destino.is_roque:
casa_destino.inserir_peca(peca_movida)
i = casa_destino.posicao_na_matriz[0]
if casa_destino.posicao_na_matriz[1] > 4:
torre = self.vetor_de_Controle[i][7].peca
torre.movimentos += 1
self.vetor_de_Controle[i][7].remover_peca()
self.vetor_de_Controle[i][5].inserir_peca(torre)
if casa_destino.posicao_na_matriz[1] < 4:
torre = self.vetor_de_Controle[i][0].peca
torre.movimentos += 1
self.vetor_de_Controle[i][0].remover_peca()
self.vetor_de_Controle[i][3].inserir_peca(torre)
elif casa_destino.is_en_passant:
casa_destino.inserir_peca(peca_movida)
i = casa_destino.posicao_na_matriz[0]
j = casa_destino.posicao_na_matriz[1]
if casa_destino.peca.tonalidade == 'claro':
self.vetor_de_Controle[i + 1][j].remover_peca(True)
else:
self.vetor_de_Controle[i - 1][j].remover_peca(True)
else:
casa_destino.inserir_peca(peca_movida)
self.promocao()
self.trocar_vez()
# IA:
if modoJogo == 2:
IA(self)
def main(nbLignes,
nbColonnes,
nb_coups_avance_blanc=0,
profondeur_raisonnement_noir=1,
profondeur_raisonnement_blanc=1,
alphabeta_utilisation=True):
if nbLignes <= 1 or nbColonnes <= 1:
raise ValueError(
"Le nombre de lignes et de colonnes doit être supérieur ou égale à 2"
)
if nb_coups_avance_blanc < 0:
raise ValueError("On peut pas retourner en arrière")
if profondeur_raisonnement_blanc < 1:
raise ValueError(
"Il faut que l'IA puisse réfléchir. Mettez un nombre >= 1")
if profondeur_raisonnement_noir < 1:
raise ValueError(
"Il faut que l'IA puisse réfléchir. Mettez un nombre >= 1")
historique_grille = []
grille = Grille(nbLignes, nbColonnes)
ia_blanc = IA('blanc', profondeur_raisonnement_blanc,
alphabeta_utilisation)
ia_noir = IA('noir', profondeur_raisonnement_noir, alphabeta_utilisation)
for i in range(nb_coups_avance_blanc):
mouv = ia_blanc.play(grille)
nouvelle_grille = grille.effectuerAction(mouv)
grille.grille = nouvelle_grille.grille
del nouvelle_grille
print(
f"Grille initiale (avec {nb_coups_avance_blanc} coups d'avance pour le joueur blanc):"
)
print(grille)
while not grille.estTermine() and not any(
[grille == h for h in historique_grille]):
historique_grille.append(grille)
joueur = grille.joueurActuel
if joueur == 'blanc':
mouvement = ia_blanc.play(grille)
else:
mouvement = ia_noir.play(grille)
grille = grille.effectuerAction(mouvement)
return grille, ia_blanc, ia_noir
def main():
print "#### Iitialisation ####"
game = Party("Ghost")
game.createRoom()
chars = [
Character("Nass"),
Character("Mad"),
Character("JD"),
Character("Tony"),
Character("Nassim"),
Character("Imad"),
Character("Jean-David"),
Character("Anthony")
]
game.characters = chars
for i, c in enumerate(chars):
c.moveToRoom(game.rooms[i])
print "#### Start ####"
taro = chars[4:]
result = IA.computeTaros(taro, game.rooms, IA.GHOST)
print "\tMOVE::", result["perso"].name, " from ", result[
"perso"].room.name, " to ", result["move"].name
def main():
args = parse()
ia1 = IA(host=args.ip, port=args.port, name=args.name, verbose=True)
ia1.run()
def __init__(self):
IA.__init__(self)
def __init__(self):
random.seed(1)
IA.__init__(self)
))
#info sur la partie
jeu = Save(board)
jeu.fill_headers([
str(input("Event : ")),
str(input("Site : ")),
datetime.datetime.now(),
str(input("Round : ")),
str(input("White : ")),
str(input("Black : ")), None
])
#IA
if a == 1:
game = IA(board)
print(game.play())
#Player VS Player
elif a == 2:
game = PvP(board)
print(game.playPvP())
#Player VS IA
elif a == 3:
game = PvE(board)
print(game.playPvE())
else:
print("Choose an other game mode")
def __call__(self):
"""Boucle 'for' principale du simulateur."""
for i in range(self.nombre_parties):
if self.fenetre:
jeu = Othello(self.joueurs, self.fenetre)
else:
jeu = Othello(self.joueurs)
jeu()
if not jeu.fenetre.open:
break
self.gagnants.append(jeu.gagnant)
if self.display: print(self)
def __repr__(self):
"""Renvoie une représentation des victoires de chaque joueur avec l'historice des victoires du simulateur."""
message = "Resultats de " + str(len(self.gagnants)) + " parties:\n"
for numeror in range(len(self.joueurs)):
message += "- Joueur " + str(numero) + " a gagne " + str(
self.gagnants.count(numero)) + " fois.\n"
return message
if __name__ == "__main__":
fenetre = Window(taille=[800, 800], fullscreen=False)
joueurs = [IA(), BruteForce(3)]
nombre_parties = 50
affichage = True
simulation = Simulateur(fenetre, joueurs, nombre_parties)
simulation()
print(simulation)