def jouer_jeu(joueur1, robot):
partie = quoridor.Quoridor((f'{joueur1}', f'{robot}'))
partie.__str__()
i = True
while i:
type_coup = input('Quel est ton type de coup?')
if type_coup == 'D':
position = tuple(input('Vers quelle position veux-tu aller?'))
pos = ((int(position[1]), int(position[4])))
partie.déplacer_jeton(1, pos)
partie.jouer_coup(2)
print(f'La partie est terminée: {partie.partie_terminée()}')
elif type_coup == 'MH':
position = tuple(input('À quelle position veux-tu placer un mur horizontal?'))
pos = ((int(position[1]), int(position[4])))
partie.placer_mur(1, pos, 'horizontal')
partie.jouer_coup(2)
print(f'La partie est terminée: {partie.partie_terminée()}')
elif type_coup == 'MV':
position = tuple(input('À quelle position veux-tu placer un mur vertical?'))
pos = ((int(position[1]), int(position[4])))
partie.placer_mur(1, pos, 'vertical')
partie.jouer_coup(2)
print(f'La partie est terminée: {partie.partie_terminée()}')
partie.__str__()
def manuel(idul):
"""
Fonction qui permet de jouer en mode manuel.
"""
partie = api.débuter_partie(ARGUMENTS.idul.lower())
jeu = qr.Quoridor([idul.lower(), "automate"])
jeu.état = partie[1]
print(jeu)
print("La méthode de jeu manuelle n'a pas encore été implémentée.")
def __init__(self, moves):
self.current_analyzed_game_moves = moves
self.moves_index = None
moves_as_string = " ".join(moves)
self.current_analyzed_game = quoridor.Quoridor({
"player_1": "A",
"player_2": "B",
"game": moves_as_string
})
def quoridor():
time.sleep(1)
q = tttp.Quoridor({
"player_1":
"Joos",
"player_2":
"Lode",
"game":
"n s n s n s n 6e 4d 4g e5 6c a6 b6 4b 5a 3a c3 1c 2b 1a 2d 1e 2f 1g 3h h1 sw"
})
board_string = q.board_as_html()
return board_string
def display(self, specific_moves_index=None):
'''If specific_moves = None: load all moves
'''
moves_as_string = self.moves_as_string(specific_moves_index)
self.current_analyzed_game = quoridor.Quoridor({
"player_1": "A",
"player_2": "B",
"game": moves_as_string
})
print(self.current_analyzed_game.board_as_string())
print(self.current_analyzed_game.execute_command("history_nice"))
def __init__(self,
player_1_name=None,
player_2_name=None,
moves=None,
loop=False,
logger=None):
# loop for automatic restart after game end.
# name will be asked when player names None
# for computer player: auto_1 --> 1 level deep brute force
# for computer player: auto_2 --> 2 level deep brute force
# for computer player: auto_3 --> 3 level deep brute force
# moves: list or array with sequence of verbose moves as game starting point.
self.logger = logger or logging.getLogger(__name__)
self.player_names = [player_1_name, player_2_name]
for i, name in enumerate(self.player_names):
if name is None:
name = input(
"---INPUT PLAYERS--- \nType auto_1, auto_2 or auto_3 for computer player (1 is easy, 3 is hard).\nName for player {} going {}. [player{}]:"
.format(i + 1, ["north", "south"][i],
i + 1)) or "player{}".format(i + 1)
self.player_names[i] = name
# loop is mainly used to let computers fight each other.
self.loop = loop
if self.loop:
self.pause_enabled = False
else:
self.pause_enabled = True
self.init_dict = {
"player_1": self.player_names[0],
"player_2": self.player_names[1],
"game": moves
}
# self.pause()
output_encoding = sys.stdout.encoding # check for command line encoding. utf-8 is desired.
self.q = quoridor.Quoridor(self.init_dict, output_encoding,
self.logger)
self.game_loop()
def check_task(jeu, task, automode=False):
"""vérification du async task handling de la classe QuoridorX
Arguments:
jeu {QuoridorX} -- Instance du jeu courant
task {list} -- dernière task connue
Keyword Arguments:
automode {bool} -- Si la tache doit être obtenue du AI (default: {False})
Returns:
[list] -- la nouvelle task si nouvelle task. False sinon
"""
if not automode:
# Vérifier si une nouvelle tâche a été entrée
if task != jeu.task:
return jeu.task
return False
murs = {'horizontaux': jeu.murh, 'verticaux': jeu.murv}
qjeu = quoridor.Quoridor(jeu.joueurs, murs)
return autocommande(qjeu)
def calculate_next_moves(self, level=1):
# will not execute moves of course, as this is an analysis tool, but shows the possibilities...
# will give the possible moves, calculated by computer
moves_as_string = self.moves_as_string(self.moves_index)
game_for_suggesting_moves = quoridor.Quoridor({
"player_1": "A",
"player_2": "B",
"game": moves_as_string
})
if level == 3:
print(
game_for_suggesting_moves.auto_level_3(simulate=True,
verbose=False))
else:
print("please provide valild level.")
def listing(idul):
'''def listing(idul)
Description:
une fonction qui affiche les 20 dernières parties
Input:
idul (str)
le idul du joueur
Return:
une liste contenant les réponses du joueur
'''
gamelist = api.lister_parties(idul)
print("voici la liste de vos 20 dernières parties jouées")
# itérer sur chaque parties à afficher
for gamenumber, game in enumerate(gamelist):
print("partie NO.", gamenumber)
print("game ID:", game['id'])
jeu = quoridor.Quoridor(game['état']['joueurs'], game['état']['murs'])
print(jeu)
def jeu_console_serveur(idul, automode=False):
"""mode de jeu permettant de jouer en mode manuel contre le serveur
- Les commandes sont entrées via le terminal
- L'affichage s'effectue via le terminal en art ascii
Arguments:
idul {str} -- L'identifiant du joueur
"""
# débuter le jeu
nouveaujeu = api.débuter_partie(idul)
jeu = quoridor.Quoridor(nouveaujeu[1]['joueurs'])
jeu.gameid = nouveaujeu[0]
# afficher le jeu
print(jeu)
# boucler
while True:
# jouer manuellement ou demander au AI de le coup a joue
if automode:
coup = autocommande(jeu)
else:
coup = prompt_player()
# jouer le coup
try:
if not verifier_validite(jeu, coup):
print("coup invalide!")
print(jeu)
continue
nouveaujeu = api.jouer_coup(jeu.gameid, coup[0],
(coup[1], coup[2]))
jeu.joueurs = nouveaujeu['joueurs']
jeu.murh = nouveaujeu['murs']['horizontaux']
jeu.murv = nouveaujeu['murs']['verticaux']
print(jeu)
except StopIteration as s:
# prévenir le joueur que la partie est terminée
print('\n' + '~' * 39)
print("LA PARTIE EST TERMINÉE!")
print("LE JOUEUR {} À GAGNÉ!".format(s))
print('~' * 39 + '\n')
return
def autonome(idul):
"""
Fonction qui permet de jouer en mode automatique contre le serveur.
"""
partie = api.débuter_partie(ARGUMENTS.idul.lower())
idp = partie[0]
jeu = qr.Quoridor([idul.lower(), "automate"])
jeu.état = partie[1]
print(jeu)
while True:
try:
jeu.jouer_coup(1)
print(jeu)
jeu.état = api.jouer_coup(idp, jeu.type_coup, jeu.pos_coup)
jeu.posj2 = (jeu.état['joueurs'][1]['pos'][0],
jeu.état['joueurs'][1]['pos'][1])
for i in jeu.état['murs']["horizontaux"]:
jeu.murs['horizontaux'].append(i)
for i in jeu.état['murs']["verticaux"]:
jeu.murs['verticaux'].append(i)
print(jeu)
except StopIteration as err:
print(f"La partie est terminée, {err} est vainqueur!")
break
"pos": [5, 7]
}],
"murs": {
"horizontaux": [[4, 4], [2, 6], [3, 8], [5, 8], [7, 8]],
"verticaux": [[6, 2], [4, 4], [2, 5], [7, 5], [7, 7]]
}
}
#swag lines
print('\n' + '~' * 39)
print("BIENVENU DANS QUORIDOR!")
print('~' * 39 + '\n')
# offrir de jouer une nouvelle partie ou reprendre une partie existante
print(
"souhaitez vous commencer une nouvelle partie ou continuer une partie existante?"
)
print("1 = nouvelle partie | 2 = partie existante")
CHOIX = int(input("choix: "))
if CHOIX == 1:
# obtenir le nom des deux joueurs
print("veuillez entrer le nom des joueurs:")
JOUEUR1 = input("nom du joueur1: ")
JOUEUR2 = input("nom du joueur2: ")
# demarrer une nouvelle partie
JEU = quoridor.Quoridor([JOUEUR1, JOUEUR2])
loop([JOUEUR1, JOUEUR2], JEU)
elif CHOIX == 2:
JEU = quoridor.Quoridor(ETAT_JEU['joueurs'], ETAT_JEU['murs'])
loop(["joueur1", "joueur2"], JEU)
else:
print("choix invalide!")
JOUER = api.jouer_coup(ID_PARTIE, COUP[0], COUP[1])
JEU.liste_joueurs = JOUER['joueurs']
JEU.liste_murs = JOUER['murs']
JEU.afficher()
except StopIteration as err:
GAGNANT = False
print(f'Le gagnant est: {err}')
except RuntimeError as err:
print(err)
# Mode automatique (commande : python main.py -a idul)
elif COMMANDE.automatique:
DEBUTER = api.débuter_partie(COMMANDE.idul)
JEU = quoridor.Quoridor(DEBUTER[1]['joueurs'], DEBUTER[1]['murs'])
ID_PARTIE = DEBUTER[0]
print(JEU)
GAGNANT = True
while GAGNANT:
try:
COUP = JEU.jouer_coup(1)
JOUER = api.jouer_coup(ID_PARTIE, COUP[0], COUP[1])
JEU.liste_joueurs = JOUER['joueurs']
JEU.liste_murs = JOUER['murs']
print(JEU)
dest='graphique',
action='store_true',
help='Activer le mode graphique.')
return parser.parse_args()
if __name__ == "__main__":
ARGS = analyser_commande()
ID_PARTIE = initialiser_partie(ARGS.idul)[0]
GRILLE = initialiser_partie(ARGS.idul)[1]
if ARGS.graphique:
PARTIE = quoridorx.QuoridorX(GRILLE['joueurs'], GRILLE['murs'])
PARTIE.automatique = ARGS.automatique
PARTIE.id = ID_PARTIE
else:
PARTIE = quoridor.Quoridor(GRILLE['joueurs'], GRILLE['murs'])
WIN = False
while not WIN:
PARTIE.afficher()
if not ARGS.automatique:
TYPE_COUP = input(
"\nQuel type de coup voulez vous effectuer ?\n'D' pour déplacer le jeton,\
\n'MH' pour placer un mur horizontal,\n'MV' pour placer un mur vertical.\nType: "
)
TYPE_COUP = TYPE_COUP.upper()
if TYPE_COUP == '':
TYPE_COUP = 'D'
ISINT = False
while not ISINT:
try:
POS_X = int(input("Coordonnée en 'x'? "))
mode_graph = analyser_commande().graphique
###Initialise la partie
#Envoyer un POST pour initialer la partie
ID, partie_initial = initialiser_partie(idul)
##Crée l'objet de jeu avec la classe demandée
#Si le mode graphique est actif, utiliser la classe quoridorx
if mode_graph:
partie = quoridorx.QuoridorX(partie_initial['joueurs'],
partie_initial['murs'])
#Si le mode graphique est inactif, utiliser la classe Quoridor
else:
partie = quoridor.Quoridor(partie_initial['joueurs'], None)
#Afficher le damier selon la classe
if mode_graph:
partie.afficher()
else:
print(partie)
###Exécuter ce code tant qu'il n'y a pas de gagnant
while not partie.partie_terminée():
##Le joueur 1 choisi son coup selon le mode spécifié
#Si le mode automatique est activé, choisir automatique le coup
if mode_auto:
(type_coup, position) = partie.jouer_coup(1)
#Si le mode manuel est activé, l'utilisateur choisi le coup à jouer
def analyser_commande():
'''Cette fonction permet de traiter la ligne de commande'''
parser = argparse.ArgumentParser(description='Jeu Quoridor - phase 3')
group = parser.add_mutually_exclusive_group()
parser.add_argument(metavar='idul', dest='idul',
help='IDUL du joueur.')
group.add_argument('-a', '--automatique', action='store_true', default=False, help='Activer le mode automatique.')
group.add_argument('-x', '--graphique', action='store_true', default=False, help='Activer le mode graphique.')
group.add_argument('-ax', '--graphique_automatique', action='store_true', default=False, help='Activer le mode automatique et graphique.')
args = parser.parse_args()
if args.automatique:
idul = analyser_commande().idul
dico = api.débuter_partie(idul)
Id = dico['id']
jeu = quoridor.Quoridor(dico)
while quoridor.QuoridorError is False:
jeu.jouer_coup(1)
dico = api.jouer_coup(Id, type_de_coup, position)
print(jeu)
elif args.graphique:
idul = analyser_commande().idul
dico = api.débuter_partie(idul)
jeu = quoridorx.QuoridorX(dico)
Id = dico['id']
i = True
while i:
coup = input("Choisir un coup (déplacement = D, mur horizontal = MH, mur vertical = MV) et presser la touche ⏎: ")
if coup == 'D':
position = input("Préciser la position (x, y) et presser la touche ⏎: ")
dico = api.jouer_coup(Id, coup, position)
elif coup == 'MH':
position = input("Préciser la position (x, y) et presser la touche ⏎: ")
dico = api.jouer_coup(Id, coup, position)
elif coup == 'MV':
position = input("Préciser la position (x, y) et presser la touche ⏎: ")
dico = api.jouer_coup(Id, coup, position)
jeu.afficher()
elif args.graphique_automatique:
idul = analyser_commande().idul
dico = api.débuter_partie(idul)
Id = dico['id']
jeu = quoridorx.QuoridorX(dico)
while quoridor.QuoridorError is False:
jeu.jouer_coup(1)
dico = api.jouer_coup(Id, type_de_coup, position)
jeu.afficher()
else:
jeu = quoridor.Quoridor(dico)
idul = analyser_commande().idul
dico = api.débuter_partie(idul)
Id = dico['id']
i = True
while i:
coup = input("Choisir un coup (déplacement = D, mur horizontal = MH, mur vertical = MV) et presser la touche ⏎: ")
if coup == 'D':
position = input("Préciser la position (x, y) et presser la touche ⏎: ")
dico = api.jouer_coup(Id, coup, position)
elif coup == 'MH':
position = input("Préciser la position (x, y) et presser la touche ⏎: ")
dico = api.jouer_coup(Id, coup, position)
elif coup == 'MV':
position = input("Préciser la position (x, y) et presser la touche ⏎: ")
dico = api.jouer_coup(Id, coup, position)
print(jeu)
return args.idul
def game_loop(self):
# ask user for move if not provided.
playing = True
while playing:
# display the board
# self.pause()
self.logger.info("print board (games state: {}):".format(
self.q.get_state(), ))
self.print_board()
self.check_state()
if self.q.get_state() == quoridor.GAME_STATE_PLAYING:
start_millis = int(round(time.time() * 1000))
# get user input move
if "auto" in self.q.players[self.q.playerAtMoveIndex].name:
self.auto_turn()
else:
self.human_turn()
calc_time = int(round(time.time() * 1000)) - start_millis
print("calc time = {} millis".format(calc_time))
# self.print_message("___end of turn____")
elif self.q.get_state() == quoridor.GAME_STATE_NOT_STARTED:
pass
# # get user input move
# if auto in self.q.players[self.q.playerAtMoveIndex].name:
# self.q.auto_turn(depth=1)
# else:
# self.human_turn()
elif self.q.get_state() == quoridor.GAME_STATE_FINISHED:
self.logger.info("game finished... (will restart?:{})".format(
self.loop, ))
if not self.loop:
# self.command("moves")
self.command("stats")
self.command("save_stats")
command = input(
"game finished. Please enter u for undoing, r for restart or enter for exit"
) or "exit"
if command in ["u", "undo"]:
self.q.set_state(quoridor.GAME_STATE_PLAYING)
# hack: we have to pretend like it was the next players' turn to play. So, the undo will properly revert.
self.q.playerAtMoveIndex = self.q.get_previous_player_index(
)
self.q.execute_command("undo")
self.q.execute_command("undo")
elif command in ["r", "restart"]:
self.q = quoridor.Quoridor(self.init_dict)
else:
exit()
# test = self.command(command)
else:
# restart game.
self.command("save_stats")
self.q = quoridor.Quoridor(self.init_dict)
else:
self.logger.error("wrong game state: {}".format(
self.q.get_state()))
feedback_message = self.q.get_status_message()
if feedback_message != "":
self.print_message(feedback_message)