def Cluedo(ficJoueurs, ficCartes, ficPlateau):
"""
Construit un nouveau jeu de cluedo à partir de trois fichiers: les joueurs, les cartes et le plateau
paramètres: ficJoueurs le nom du fichier des joueurs
ficCartes le nom du fichier contenant la description des cartes
ficPlateau le nom du fichier contenant l'état du plateau
Cette fonction retourne un nouveau jeu de cluedo (une nouvelle partie), elle va donc initialiser les joueurs,
le plateau le jeu de carte, tirer au hasard une énigme et distribuer les cartes au joueurs.
Les fiches indices de chaque joueur seront initialisées et les pions des joueurs seront placés sur leur départ
Le joueur principal (celui dont on voit la fiche indice) est soit le joueur humain s'il y en a un, le premier joueur sinon
"""
jeuCarte = jeucarte.lireJeuCarte(ficCartes)
jeucarte.melangerJeu(jeuCarte)
listeJoueurs = joueur.lireJoueurs(ficJoueurs)
myst = jeucarte.definirMystere(jeuCarte)
distribuerCartes(jeuCarte, listeJoueurs)
plato = plateau.lirePlateau(ficPlateau)
liste_num_joueur = []
for joueurs in listeJoueurs:
liste_num_joueur.append(joueur.getNum(joueurs))
fiche_joueur = ficheIndices.FicheIndices(listeJoueurs, jeuCarte)
ficheIndices.initFicheIndices(fiche_joueur, joueur.getNum(joueurs),
joueur.getCartes(joueurs))
joueurs[5] = fiche_joueur
plateau.poserPionCaseDepart(plato, liste_num_joueur)
return [
listeJoueurs, plato, jeuCarte, myst,
joueurPrincipal(listeJoueurs), 1
]
def traiterCocher(clu, arguments):
"""
permet au joueur humain de completer sa fiche en plus de ce que l'ordinateur aura automatique mis à jour
"""
commande = arguments.split()
if len(commande) < 4:
return -1, "La commande cocher doit contenir la categorie et le numéro de la carte, le numéro du joueur et le type d'info\nPar exemple: 1 4 2 + pour indiquer que l'on pense que le joueur 2 possède la carte 4 de la catégorie PERSONNE"
if commande[3] not in '+-':
return -1, "L'indication doit être + (possède) ou - (ne possède pas)"
if commande[0] not in str(carte.PROFESSEUR) + str(carte.MATIERE) + str(
carte.SALLE):
return -1, "la catégorie de carte doit être " + str(
carte.PROFESSEUR) + " " + str(carte.MATIERE) + " " + str(
carte.SALLE)
if not commande[1].isdigit() or int(
commande[1]) not in jeucarte.getListeNumCarteCategorie(
cluedo.getJeuCartes(cluedo)):
return -1, "les numéros de carte possibles pour cette catégorie sont " + str(
jeucarte.getListeNumCarteCategorie(cluedo.getJeuCartes(cluedo)))
if not commande[1].isdigit() or int(commande[1]) not in range(
1,
getNbJoueurs(cluedo) + 1):
return -1, "les numéros de joueur possibles sont les chiffres entre 1 et " + str(
getNbJoueurs(cluedo) + 1)
ficheIndices.connaissance(joueur.getFiche(cluedo.getJoueurCourant(cluedo)),joueur.getNum(cluedo.getJoueurCourant(cluedo)),\
int(commande[1]),int(commande[0]),commande[3])
return 0, "Indication prise en compte"
def FicheIndices(_listeJoueurs, _jeuCartes):
"""
retourne une fiche indices
paramètres: _listeJoueurs: la liste des joueurs participant à la partie
_jeuCartes: le jeu de cartes qui sera distribué aux joueurs
exemple = {
prof1 : {1:'?', 2:'?',3:'?',4:'?'},
prof2 : {1:'?', 2:'?',3:'?',4:'?'},
prof3 : {1:'?', 2:'?',3:'?',4:'?'},
salle1 : {1:'?', 2:'?',3:'?',4:'?'},
salle2 : {1:'?', 2:'?',3:'?',4:'?'},
matiere1 : {1:'?', 2:'?',3:'?',4:'?'},
matiere2 : {1:'?', 2:'?',3:'?',4:'?'},
matiere3 : {1:'?', 2:'?',3:'?',4:'?'},
matiere4 : {1:'?', 2:'?',3:'?',4:'?'}
}
"""
listeNumJoueurs = []
for joueurs in _listeJoueurs:
numJoueur = joueur.getNum(joueurs)
listeNumJoueurs.append(numJoueur)
ficheIndices = {}
for cartes in _jeuCartes:
if carte.getNum(cartes) != cluedo.getNumPieceHypothese(1):
ficheIndices[cartes] = creerIndications(listeNumJoueurs)
return ficheIndices
def deplacerJoueurCourant(cluedo, lig, col):
"""
cette fonction modifie le plateau du cluedo en enlevant le pion du joueur courant de son emplacement actuel
et le positionnant sur la case destination. Elle retourne de plus la catégorie de la case destination
paramètres: cluedo : le jeu de cluedo
lig: le numéro de la ligne destination
col: le numéro de la colonng destination
resultat: catégorie de la case destination (numero de la pièce ou couloir)
"""
plato = getPlateau(cluedo)
joueurs = getJoueurCourant(cluedo)
(pos_x_joueur, pos_y_joueur) = plateau.posJoueur(plato,
joueur.getNum(joueurs))
plateau.enleverPion(plato, pos_x_joueur, pos_y_joueur)
plateau.mettrePion(plato, lig, col, joueur.getNum(joueurs))
categorie = case.getCategorie(plateau.getCase(plato, lig, col))
return categorie
def choixProfMatOrdinateur(cluedo, numPiece):
"""
retourne sous la forme d'un couple numProf,numMat le choix du joueur courant géré par un ordinateur
cette fonction se sert la fonction creerUneHypothese de la structure ficheIndices
paramètres: cluedo le jeu de cluedo
numPiece le numéro de la pièce où se trouve le joueur courant
résultat un couple numProf,numMat
"""
joueur_courant = getJoueurCourant(cluedo)
choix = ficheIndices.creerUneHypothese(joueur.getFiche(joueur_courant),
joueur.getNum(joueur_courant),
numPiece)
return choix[0], choix[1]
def afficherCluedo(cluedo, information):
"""
affiche la vue du cluedo c'est-à-dire le plateau ainsi que la fiche indice du joueur principal et le message d'information
paramètres: cluedo le jeu de cluedo
information le message à afficher avec le jeu
"""
print()
joueurCourant = getJoueurCourant(cluedo)
debutInformation="--------- Tours numéro "+str(getNumTour(cluedo))+"\n"+\
" c'est au joueur "+str(joueur.getNum(joueurCourant))+" appelé "+joueur.getNom(joueurCourant)+ " de jouer\n"
plateau.afficherPlateau(getPlateau(cluedo),
(debutInformation + information).split('\n'))
print(ficheIndices.string(joueur.getFiche(getJoueurPrincipal(cluedo))))
def passageSecretJoueurCourant(cluedo):
"""
retourne soit None si le joueur courant ne se trouve pas dans une pièce où il y a un passage secret
soit un triplet numPieceDest,lig,col indiquant le numéro de la pièce destination du passage
la postion du passage dans la pièce où se trouve le joueur courant
paramètre: cluedo le jeu de cluedo
"""
plato = getPlateau(cluedo)
(pos_x, pos_y) = plateau.posJoueur(plato,
joueur.getNum(getJoueurCourant(cluedo)))
liste_pieces = plateau.getPieces(plato)
num_piece = case.getCategorie(plateau.getCase(plato, pos_x, pos_y))
for num_piece_actuel, une_piece in liste_pieces.items():
if num_piece_actuel == num_piece:
if piece.getPassage(une_piece) != None:
return (piece.getPassage(une_piece), pos_x, pos_y)
def jouerDe(cluedo):
"""
lance les dés (c-à-d choisit aléatoirement un entier compris entre 2 et 12) puis calcule pour chaque pièce
la distance à laquelle le joueur courant peut s'approcher en fonction des points obtenus sur les dés
paramètres: cluedo : le jeu de cluedo
résultat: un dictionnaire dont les clés sont les numéros de pièce et les valeurs la
distance à laquelle le joueur peut s'approcher
de la pièce grâce aux points obtenus aux dés (voir fonction distancePieces)
"""
des1 = random.randint(1, 6)
des2 = random.randint(1, 6)
des = des1 + des2
plato = getPlateau(cluedo)
numJoueur = joueur.getNum(getJoueurCourant(cluedo))
(pos_x_joueur, pos_y_joueur) = plateau.posJoueur(plato, numJoueur)
liste_case_accessibles = plateau.accessiblesJoueur(plato, numJoueur, des)
listePieces = plateau.getPieces(plato)
dico_dist_piece = distancePieces(cluedo, listePieces,
liste_case_accessibles)
return des, dico_dist_piece
def phaseHypothese(clu, numP):
joueurCourant = cluedo.getJoueurCourant(clu)
numJoueurCourant = joueur.getNum(joueurCourant)
jeu = cluedo.getJeuCartes(clu)
courantPrincipal = joueurCourant == cluedo.getJoueurPrincipal(clu)
courantHumain = joueur.estHumain(joueurCourant)
information = ""
messageErreur = ""
if courantPrincipal:
debutInformation="Vous êtes dans la pièce "+jeucarte.getNomCarteParNum(jeu,carte.SALLE,numP)+'\n'+\
'Entrez votre hypothèse sous la forme p,m\n'
information = jeucarte.stringCat(
jeu, carte.PROFESSEUR) + '\n' + jeucarte.stringCat(
jeu, carte.MATIERE) + '\n'
else:
debutInformation = "Le joueur " + str(
numJoueurCourant
) + " est dans la pièce " + jeucarte.getNomCarteParNum(
jeu, carte.SALLE, numP) + '\n'
# Interaction pour faire une hypothèse
fini = False
while not fini:
cluedo.afficherCluedo(clu,
debutInformation + messageErreur + information)
hp = getHypothese(clu, numP, courantPrincipal and courantHumain)
fini = hp != None
messageErreur = "ATTENTION! vous n'avez pas formulé votre hypothèse correctement\n"
if courantPrincipal:
information = "Vous pensez que\n"
else:
information = "Il pense que\n"
information+=jeucarte.getNomCarteParNum(jeu,1,hp[1]) +" donnera un cours de "+\
jeucarte.getNomCarteParNum(jeu,2,hp[2])+" dans la pièce "+jeucarte.getNomCarteParNum(jeu,3,hp[3])+"\n"
cluedo.afficherCluedo(clu, debutInformation + information)
input()
# interrogation des joueurs sur cette hypothèse
information += interrogerJoueurs(clu, hp)
cluedo.afficherCluedo(clu, debutInformation + information)
input()
def phaseDeplacement(clu):
joueurCourant = cluedo.getJoueurCourant(clu)
numJoueur = joueur.getNum(joueurCourant)
courantPrincipal = joueurCourant == cluedo.getJoueurPrincipal(clu)
courantHumain = joueur.estHumain(joueurCourant)
passageSecret = cluedo.passageSecretJoueurCourant(clu)
if passageSecret != None:
numP, lig, col = passageSecret
rep = getReponsePassage(clu, numP, courantHumain and courantPrincipal)
if rep == "O":
if courantPrincipal:
information = "Vous avez choisi de prendre le passage secret vers la salle " + str(
numP) + '\n'
else:
information = "Le joueur " + str(
numJoueur
) + " a choisi de prendre le passage secret vers la salle " + str(
numP) + '\n'
cluedo.deplacerJoueurCourant(clu, lig, col)
cluedo.afficherCluedo(clu, information)
return numP
de, distances = cluedo.jouerDe(clu)
information = ""
messageErreur = ""
if courantPrincipal:
information += "Les dés valent " + str(de) + "\n" + infoDistance(
distances) + "\nVeuillez choisir votre pièce destination\n"
# Interaction pour choisir une destination
fini1 = False
while not fini1:
cluedo.afficherCluedo(clu, messageErreur + information)
lig, col = getDestination(clu, distances, courantHumain
and courantPrincipal)
fini1 = lig != -1
messageErreur = "ATTENTION! Cette pièce n'existe pas\n"
numP = cluedo.deplacerJoueurCourant(clu, lig, col)
return numP
def phaseSolution(clu):
joueurCourant = cluedo.getJoueurCourant(clu)
numJoueurCourant = joueur.getNum(joueurCourant)
jeu = cluedo.getJeuCartes(clu)
courantPrincipal = joueurCourant == cluedo.getJoueurPrincipal(clu)
courantHumain = joueur.estHumain(joueurCourant)
messageErreur = ""
information = ""
if courantPrincipal:
debutInformation="Vous êtes dans la pièce "+jeucarte.getNomCarteParNum(jeu,carte.SALLE,cluedo.getNumPieceHypothese(clu))+\
'\nVeuillez formuler votre réponse sous la forme numProf,numMat,numSalle\n'
else:
debutInformation="Le joueur "+ str(numJoueurCourant)+" est dans la pièce "+\
jeucarte.getNomCarteParNum(jeu,carte.SALLE,cluedo.getNumPieceHypothese(clu))+'\n'
# Interaction pour faire donner une solution
fini = False
while not fini:
cluedo.afficherCluedo(clu,
debutInformation + messageErreur + information)
hp = getLaSolution(clu, courantPrincipal and courantHumain)
fini = hp != None
messageErreur = "ATTENTION! vous n'avez pas formulé votre solution correctement\n"
if courantPrincipal:
information = "Vous pensez que\n"
else:
information = "Il pense que\n"
information+=jeucarte.getNomCarteParNum(jeu,1,hp[0]) +" donnera un cours de "+\
jeucarte.getNomCarteParNum(jeu,2,hp[1])+" dans la pièce "+jeucarte.getNomCarteParNum(jeu,3,hp[2])+"\n"
fini = hp == cluedo.getSolution(clu)
if fini:
information += " et c'est la bonne réponse !"
showinfo('CLUEDO', "BRAVO C'EST GAGNE")
else:
information += " et ce n'est pas la bonne réponse !!"
cluedo.elimineJoueurCourant(clu)
cluedo.afficherCluedo(clu, debutInformation + information)
return fini
def interrogerJoueurs(clu, hypothese):
joueurCourant = cluedo.getJoueurCourant(clu)
ficheJoueurCourant = joueur.getFiche(joueurCourant)
indiceJoueurCourant = cluedo.getIndiceJoueurCourant(clu)
nbJoueurs = cluedo.getNbJoueurs(clu)
listeJoueurs = cluedo.getListeJoueurs(clu)
information = ""
for i in range(1, nbJoueurs):
indiceInterroge = (indiceJoueurCourant + i) % nbJoueurs
joueurInterroge = listeJoueurs[indiceInterroge]
numJoueurInterroge = joueur.getNum(joueurInterroge)
information += "\nle joueur " + str(
numJoueurInterroge) + " est interrogé"
if joueur.estHumain(joueurInterroge) and joueurInterroge==cluedo.getJoueurPrincipal(clu) and\
joueur.reponseHypothese(joueurInterroge,hypothese)!=None:
cluedo.afficherCluedo(clu, information)
rep = demanderJoueurHumain(clu, information, joueurInterroge,
hypothese)
else:
rep = cluedo.demanderJoueurOrdinateur(clu, joueurInterroge,
hypothese)
if rep != None:
ficheIndices.connaissance(ficheJoueurCourant,numJoueurInterroge,carte.getNum(rep),carte.getCategorie(rep),\
ficheIndices.POSSEDE)
if joueurCourant == cluedo.getJoueurPrincipal(clu):
information += "\nLe joueur " + str(
numJoueurInterroge) + " vous a montré " + carte.getNom(rep)
else:
information += "\nLe joueur " + str(
numJoueurInterroge) + " a montré une carte"
break
else:
information += "\nLe joueur " + str(
numJoueurInterroge) + " ne possède aucune carte"
for cat, num in hypothese.items():
for j in range(nbJoueurs):
ficheIndices.connaissance(joueur.getFiche(listeJoueurs[j]),numJoueurInterroge,\
num,cat,ficheIndices.NEPOSSEDEPAS)
return information