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_graphique:
q.afficher()
else:
print("", q, sep="\n")
partie = jouer_coup(args, q, id_partie)
if args.mode_graphique:
turtle.mainloop()
else:
print("", q, "", f'{gagnant} a gagné la partie!', "", sep="\n")
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 mode_manuel_graphique(idul):
"""mode manuel graphique"""
[identifiant, état] = initialiser_partie(idul)
joueur = état['joueurs']
murs = état['murs']
QuoridorX(joueur, murs)
print('Quel coup désirer vous jouer ?')
print("Deplacement pion: D , Mur Horizontal : MH, Mur Vertical : MV ")
coup = input()
print('Quel position sur le plateau désirer vous placer votre pièce?')
print('(x,y)')
position = input()
état_2 = jouer_coup(identifiant, coup, position)
while 1:
joueur = état_2['joueurs']
murs = état_2['murs']
QuoridorX(joueur, murs)
print('Quel coup désirer vous jouer ?')
print("Deplacement pion: D , Mur Horizontal: MH, Mur Vertical: MV ")
coup = input().upper()
print('Quel position sur le plateau désirer vous placer votre pièce?')
print('(x,y)')
position = input()
état_2 = jouer_coup(identifiant, coup, position)
jeu.partie_terminée()
time.sleep(0.6)
reponse = jouer_coup(ID, 'D', jeu.pos1)
jeu.pos2 = reponse['joueurs'][1]['pos']
jeu.hori = reponse['murs']['horizontaux']
jeu.ver = reponse['murs']['verticaux']
jeu.partie_terminée()
jeu.état_partie()
print(jeu)
time.sleep(0.6)
#Mode automatique graphique
if c.ax and not (c.x or c.a):
jeu = QuoridorX((c.idul, 'robot'))
ID, etat = debuter_partie(c.idul)
while True:
jeu.jouer_coup(1)
jeu.afficher()
jeu.partie_terminée()
time.sleep(0.3)
reponse = jouer_coup(ID, 'D', jeu.pos1)
jeu.pos2 = reponse['joueurs'][1]['pos']
jeu.hori = reponse['murs']['horizontaux']
jeu.ver = reponse['murs']['verticaux']
jeu.partie_terminée()
jeu.état_partie()
before["murs"]["verticaux"]):
etat = jouer_coup(
identifiant, "MV",
after["murs"]["verticaux"][len(after["murs"]["verticaux"]) -
1])
partie = QuoridorX(etat["joueurs"], etat['murs'])
if __name__ == "__main__":
__args__ = analyser_commande()
if __args__.auto and not __args__.graph:
automatique(__args__.idul)
elif __args__.graph and not __args__.auto:
__infojeutupple__ = débuter_partie(__args__.idul)
__infojeu1__ = __infojeutupple__[1]
partie = QuoridorX(__infojeu1__["joueurs"], __infojeu1__['murs'])
partie.afficher()
while True:
try:
__coup_type__ = input("Choisir un coup: 'D', 'MH' ou 'MV'")
__position_coup__ = input(
"veuillez inscrire la position du coup sous format '(x, y)'"
)
__infojeu1__ = jouer_coup(__infojeutupple__[0], __coup_type__, \
__position_coup__)
partie = QuoridorX(__infojeu1__["joueurs"],
__infojeu1__['murs'])
partie.afficher()
except RuntimeError as err:
print(err)
except StopIteration as err:
def jouer_partie(self):
self.id, self.etat = api.débuter_partie(self.idul)
self.partie = QuoridorX(["auto", "serveur"])
self.jouer_tours()
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)
help='Activer le mode automatique.')
parser.add_argument('-x',
'--graphique',
action='store_true',
dest='graphique',
help='Activer le mode graphique.')
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
IDUL = ARGS.idul
AUTOMATIQUE = ARGS.automatique
GRAPHIQUE = ARGS.graphique
PLAYING = False
WINS = []
# Débuter partie
try:
PARTIE = api.débuter_partie(IDUL)
_ID = PARTIE[0]
STATE = PARTIE[1]
JOUEURS = STATE['joueurs']
MURS = STATE['murs']
if GRAPHIQUE:
if AUTOMATIQUE:
QUORIDOR = QuoridorX(JOUEURS, MURS, auto=True)
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:
'--automatique',
help='Activer le mode automatique.',
action='store_true')
parser.add_argument('-x',
'--graphique',
help='Activer le mode graphique.',
action='store_true')
return parser.parse_args()
if __name__ == '__main__':
PARSER = analyser_commande()
IDF, ETAT = initialiser_partie(PARSER.idul)
if PARSER.automatique and not PARSER.graphique:
MATCH = Quoridor(ETAT["joueurs"])
while 1:
MATCH.jouer_auto_console(IDF)
elif PARSER.graphique and not PARSER.automatique:
MATCH = QuoridorX(ETAT["joueurs"])
while 1:
COORD = tuple(
map(int,
input('Coordonnees du coup x, y: ').strip().split(',')))
DEPL = input('Type de coup MH, MV ou D: ')
MATCH.jouer_manuel_graph(IDF, DEPL, COORD)
else:
print("grpahique et auto")
MATCH = QuoridorX(ETAT["joueurs"])
while 1:
MATCH.jouer_auto_graph(IDF)
parser.add_argument('-a', '--automatique', action = ('store_true'),
help='Activer le mode automatique.')
parser.add_argument('-x', '--graphique', action = ('store_true'),
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