def test_initialiser_partie_raise_runtime_error():
"""Test de soulèvement de l'erreur de la fonction initialiser_partie
Test que la fonction soulève l'erreur RuntimeError lorsqu'on lui
passe un paramètre invalide.
Nous importons le module a l'intérieur de la fonction pour assurer
que le test soit indépendant.
"""
idul_invalide = "j"
with pytest.raises(RuntimeError):
api.initialiser_partie(idul_invalide)
def game():
"""Jouer en console"""
analyser = analyser_commande()
partie_id = initialiser_partie(analyser.idul)
print('\n')
if analyser.lister:
print(lister_parties(analyser.idul), '\n')
print(afficher_damier_ascii(partie_id[1]))
while 1:
try:
position = list(
map(
int,
input('Entrez les coordonnees du coup x, y: ').strip().
split(',')))
mouvement = input('Entrez le type de coup MH, MV ou D: ')
except ValueError:
print('La valeur entree est incorrect')
position = list(
map(
int,
input('Entrez les coordonnees du coup x, y: ').strip().
split(',')))
mouvement = input('Entrez le type de coup MH, MV ou D: ')
else:
print(
afficher_damier_ascii(
jouer_coup(partie_id[0], mouvement, position)))
def main():
"""Fonction principale du jeu quoridor"""
parsed_args = analyser_commande()
game_idul = initialiser_partie(parsed_args.idul)
game_state = game_idul['état']
lister_parties(parsed_args.idul)
game_completed = False
while not game_completed:
afficher_damier_ascii(game_state)
print(
'Types de coups disponibles: \n'
' - D: Deplacement \n - MH: Mur Horizontal \n - MV: Mur Vertical \n\n'
)
type_coup = input('Choisissez votre type de coup (D, MH ou MV)')
print('Vous avez effectué le coup ' + type_coup)
ligne = input("Definissez la ligne de votre coup")
print('Vous avez entré la ligne ' + ligne)
colonne = input('Definissez la colonne de votre coup')
print('Vous avez entré la colonne ' + colonne)
position = [colonne, ligne]
id_partie = game_idul['id']
game_state = jouer_coup(id_partie, type_coup, position)
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 test_initialiser_partie_return_tuple():
"""Test du type de retour de la fonction initialiser_partie
Test que la fonction retourne un tuple composé d'une string et d'un dictionnaire.
Nous importons le module a l'intérieur de la fonction pour assurer
que le test soit indépendant.
"""
idul_valide = "josmi42"
partie = api.initialiser_partie(idul_valide)
assert isinstance(partie, tuple)
assert isinstance(partie[0], str)
assert isinstance(partie[1], dict)
def mode_automatique(idul):
"""mode automatique"""
[identifiant, état] = initialiser_partie(idul)
print(afficher_damier_ascii(état))
joueur = [état['joueurs'][0]['nom'], état['joueurs'][1]['nom']]
jeu = Quoridor(joueur)
état = jeu.état_partie()
while 1:
(coup, pos) = jeu.jouer_coup(1)
print(jeu)
état = jouer_coup(identifiant, coup, tuple(pos))
afficher_damier_ascii(état)
joueur1 = état['joueurs']
murs_j1 = état['murs']
jeu = Quoridor(joueur1, murs_j1)
def mode_manuel(idul):
"""mode manuel"""
etat_jeu = initialiser_partie(idul)
print(afficher_damier_ascii(etat_jeu[1]))
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()
etat_jeu_2 = jouer_coup(etat_jeu[0], coup, position)
print(afficher_damier_ascii(etat_jeu_2))
while 1:
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()
etat_jeu_2 = jouer_coup(etat_jeu[0], coup, position)
print(afficher_damier_ascii(etat_jeu_2))
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)
parser.add_argument('-a',
'--automatique',
action='store_true',
dest='automatique',
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)
if type_coup not in ["D", "MH", "MV"]:
return ask_type()
return type_coup
def ask_coords():
try:
return literal_eval(input("coords (x,y) : "))
except ValueError as _:
return ask_coords()
if __name__ == "__main__":
args = analyser_commande()
if args.lister is not None:
print(api.lister_parties(args.idul)[:20])
id_game, board = api.initialiser_partie(args.idul)
while True:
try:
afficher_damier_ascii(board)
type_coup = ask_type()
coords = ask_coords()
board = api.jouer_coup(id_game, type_coup, coords)
except StopIteration as e:
print(e)
break
except RuntimeError as e:
print(e)
parser.add_argument('-a',
'--automatique',
dest='automatique',
action='store_true',
help='Activer le mode automatique.')
parser.add_argument('-x',
'--graphique',
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: "
)
import quoridor
import api
#Liaison entre les différents modules
if __name__ == "__main__":
REP = vars(quoridor.analyser_commande())
idul = REP['idul']
x = api.initialiser_partie(idul)
y = x[1]
id_partie = x[0]
print(id_partie)
QUITTER = False
while QUITTER != True:
quoridor.afficher_damier_ascii(y)
type_coup = quoridor.demander_typecoup()
if type_coup == 'Q':
QUITTER = True
print('Au revoir')
break
position = quoridor.demander_position()
y = api.jouer_coup(id_partie, type_coup, position)
help='Lister les identifiants de vos 20 dernières parties.',
action='store_true')
parser.add_argument('-a',
'--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"])
parser = argparse.ArgumentParser(formatter_class = argparse.RawTextHelpFormatter,
description='Jeu Quoridor - phase 3')
parser.add_argument('idul', metavar='idul',
help='IDUL du joueur')
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']) !=
if __name__ == "__main__":
###Analyse les arguments de la CLI
#Retourne l'idul du joueur
idul = analyser_commande().idul
#Retourne True si -a présent, sinon False
mode_auto = analyser_commande().automatique
#Retourne True si -x présent, sinon False
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()
