def autograph(idul):
"""Section autograph"""
identifiant, etat = débuter_partie(idul)
partie = QuoridorX(etat["joueurs"], etat['murs'])
partie.afficher()
while not partie.partie_terminée():
before = copy.deepcopy(partie.état_partie())
partie.jouer_coup(1)
after = copy.deepcopy(partie.état_partie())
partie.afficher()
if before["joueurs"][0]["pos"] != after["joueurs"][0]["pos"]:
etat = jouer_coup(identifiant, "D", after["joueurs"][0]["pos"])
elif len(after["murs"]["horizontaux"]) != len(
before["murs"]["horizontaux"]):
etat = jouer_coup(
identifiant, "MH",
after["murs"]["horizontaux"][len(after["murs"]["horizontaux"])
- 1])
elif len(after["murs"]["verticaux"]) != len(
before["murs"]["verticaux"]):
etat = jouer_coup(
identifiant, "MV",
after["murs"]["verticaux"][len(after["murs"]["verticaux"]) -
1])
partie = QuoridorX(etat["joueurs"], etat['murs'])
def mode_automatique_graphique(idul):
"""mode atomatique graphique"""
[identifiant, état] = initialiser_partie(idul)
joueur = [état['joueurs'][0]['nom'], état['joueurs'][1]['nom']]
jeu = QuoridorX(joueur)
while 1:
(coup, pos) = jeu.jouer_coup(1)
jeu.afficher()
état = jouer_coup(identifiant, coup, tuple(pos))
joueur1 = état['joueurs']
murs_j1 = état['murs']
jeu = QuoridorX(joueur1, murs_j1)
def main():
"""Boucle principale."""
args = analyser_commande()
if args.lister:
for partie in api.lister_parties(args.idul):
print(partie["id"])
return
id_partie, partie = api.débuter_partie(args.idul)
gagnant = False
q = None
while not gagnant:
if args.mode_graphique:
q = QuoridorX(partie["joueurs"], partie["murs"])
else:
q = Quoridor(partie["joueurs"], partie["murs"])
gagnant = q.partie_terminée()
if gagnant:
break
if args.mode_auto:
time.sleep(0.25)
q.jouer_coup(1)
if args.mode_graphique:
q.afficher()
else:
print("", q, sep="\n")
partie = jouer_coup(args, q, id_partie)
if args.mode_graphique:
turtle.mainloop() # pause sur damier
else:
print("", q, "", f'{gagnant} a gagné la partie!', "", sep="\n")
class Partie:
def __init__(self, idul, auto, fenetre, api = api):
self.idul = idul
self.auto = auto
self.fenetre = fenetre
self.api = api
if not auto:
print("Utilisation: <Coup> <position x> <position y>\n" +
"Types de coups:\nD: Déplacer le pion\nMV: Mur vertical\n" +
"MH: Mur horizontal", sep=""
)
self.jouer_partie()
# Initialise une partie
def jouer_partie(self):
self.id, self.etat = api.débuter_partie(self.idul)
self.partie = QuoridorX(["auto", "serveur"])
self.jouer_tours()
def jouer_tours(self):
"""[Effectue des tours de la partie de jeu]
Returns:
[None] -- []
"""
# Fonction qui analyse les entrées de la ligne de commande
def parse_move():
string = input("Entrez votre coup ")
if string in ("q", "Q"):
return "q"
if string in ("a", "A"):
print("Utilisation: <Coup> <position x> <position y>\n" +
"Types de coups:\nD: Déplacer le pion\nMV: Mur vertical\n" +
"MH: Mur horizontal", sep=""
)
return parse_move()
try:
string = string.split(" ")
if string[0] not in ("D", "MH", "MV"):
raise ValueError
return string[0], [int(string[1]), int(string[2])]
except:
print("Mauvaise entrée. Réessayez")
return parse_move()
while(True):
# Afficher l'état de jeu (graphique ou ASCII, selon self.fenetre)
self.afficher_partie()
# Si mode pas automatique: Analyser les entrées de la ligne de commande
if not self.auto:
if not self.fenetre:
arg_coup = parse_move()
else:
arg_coup = self.partie.coup
if arg_coup == "q":
return None
# Si mode automatique: caller jouer_coup pour le joueur 1
else:
arg_coup = self.partie.jouer_coup(1)
# Update l'état de jeu pour rester synchronisé avec l'état de jeu du serveur
try:
self.partie.etat = self.api.jouer_coup(self.id, arg_coup[0], arg_coup[1])
# Le serveur renvoie les positions des personnages en listes et non tuples -> conversion en tuple
for i in range(2):
self.partie.etat["joueurs"][i]["pos"] = tuple(self.partie.etat["joueurs"][i]["pos"])
# Exception si joueur est gagnant
except StopIteration as stop_iter:
print("Joueur gagnant: {}".format(stop_iter))
return None
# Exception si ça plante
except RuntimeError as run_time_error:
print("Erreur: {}".format(run_time_error))
def afficher_partie(self):
if self.fenetre:
self.coup = self.partie.afficher()
else:
print(self.partie)
return parser.parse_args()
if __name__ == "__main__":
ARGS = analyser_commande()
PARTIE = initialiser_partie(ARGS.idul)
ID_PARTIE = PARTIE[0]
if ARGS.graphique:
#objet classe QuoridorX
q = QuoridorX(PARTIE[1]['joueurs'], PARTIE[1]['murs'])
if ARGS.automatique:
#automatique graphique
print('automatique et graphique')
while True:
try:
TYPE_COUP, POSITION = q.jouer_coup(1)
DAMIER = jouer_coup(ID_PARTIE, TYPE_COUP, POSITION)
q.window.clearscreen()
q = QuoridorX(DAMIER['joueurs'], DAMIER['murs'])
except RuntimeError as err:
print(err)
CHOIX = input(
"Voulez-vous continuer à jouer, oui ou non? ")
if CHOIX.lower() == 'non':
break
except StopIteration as err:
q.window.clearscreen()
q = QuoridorX(DAMIER['joueurs'], DAMIER['murs'])
print(f'Le grand gagnant est le joueur {err} !\n')
break
else:
else:
QUORIDOR = QuoridorX(JOUEURS, MURS)
else:
QUORIDOR = Quoridor(JOUEURS, MURS)
ERROR = False
except RuntimeError as err:
print(err)
else:
PLAYING = True
# Jouer
while PLAYING:
if not ERROR and not GRAPHIQUE:
print(QUORIDOR)
ERROR = False
if AUTOMATIQUE:
COUP = QUORIDOR.jouer_coup(1)
else:
_TYPE = input("Entrer le mouvement (D, MH ou MV): ").upper()
POS_X = input('Entrer la position en X de votre mouvement: ')
POS_Y = input('Entrer la position en Y de votre mouvement: ')
COUP = (_TYPE, (POS_X, POS_Y))
if GRAPHIQUE:
QUORIDOR.afficher()
try:
STATE = api.jouer_coup(_ID, *COUP)
QUORIDOR.partie = STATE
if GRAPHIQUE:
QUORIDOR.afficher()
except StopIteration as err:
PLAYING = False
if GRAPHIQUE:
help='Activer le mode graphique.')
return parser.parse_args()
if __name__ == "__main__":
parsed = analyser_commande()
game_info = initialiser_partie(parsed.idul)
if parsed.automatique and parsed.graphique:
# Mode auto graphique
game = QuoridorX(game_info[1]['joueurs'])
try:
while not game.partie_terminée():
coup = game.jouer_coup(1)
game.afficher()
etat = jouer_coup(game_info[0], coup[0], tuple(coup[1]))[1]
# Type coup robot | Deplacement
if game.état_partie()['joueurs'][1]['pos'] != tuple(etat['joueurs'][1]['pos']):
newpos = tuple(etat['joueurs'][1]['pos'])
game.déplacer_jeton(2, newpos)
# Type coup robot | Mur horizontal
elif (len(game.état_partie()['murs']['horizontaux']) !=
len(etat['murs']['horizontaux'])):
wallpos = tuple(etat['murs']['horizontaux'][-1])
game.placer_mur(2, wallpos, 'horizontal')
# Type coup robot | Mur vertical
elif (len(game.état_partie()['murs']['verticaux']) !=
len(etat['murs']['verticaux'])):
wallpos = tuple(etat['murs']['verticaux'][-1])