سلام برنامه زیر توی قسمت ساخت صفحه اصلی بازی ژتون هست که نفرات روبروی هم قرار میپیرند با یگ جدول مانند شطرنج یکی یکی حروف میچینند و هر کدومشون یک امتیاز میگیرن این قسمت شما تگمیل کنید سایر قسمتها هم من تکمیل میکنم میزاریم توی صفحه ممنون
clss Jeton:
"""
Cette classe représente un jeton.
Les attributs d'un jeton sont:
- lettre: str, représentant la lettre écrite sur le jeton. Par convention toutes les lettres au scrabble sont en majuscules. Dans ce travail nous ne considérons pas les jetons jokers qui n'ont aucune lettre inscrite.
- valeur: int, compris entre 0 et 20 inclusivement et représentant le nombre de points associé au jeton.
"""
def __init__(self, lettre, valeur):
"""
Constructeur de la classe. Permet de créer un Jeton à partir d'une lettre et d'un nombre de points
:param lettre: str, représentant la lettre écrite sur le jeton.
:param valeur: int, > 0 représentant le nombre de points associé au jeton.
:exception: Levez une exception avec assert si la valeur ne respecte pas
la condition suivante 0 <= valeur <= 20 ou si la lettre n'est pas en majuscule.
"""
# À compléter
# Mettre votre code ici
self.lettre = lettre
self.valeur = valeur
def __str__(self):
""" ** Vous n'avez pas à coder cette méthode **
Formatage d'un jeton. Cette méthode est appelée lorsque vous faites str(v) où v est un jeton.
:return: str, correspondant au formatage du jeton.
"""
if self.valeur < 10:
res = "{}{}".format(self.lettre, chr(0x2080 + self.valeur))
else:
res = "{}{}{}".format(self.lettre, chr(0x2080 + int(self.valeur/10)), chr(0x2080 + int(self.valeur%10)))
return res
class Case:
"""
Cette classe représente une case sur un tableau de scrabble.
Les attributs d'une case sont:
- multiplicateur: int, >= 1 et <= 3.
Si la case n'est pas spéciale son multiplicateur de points est de 1.
Autrement, il sera de 2 dans le cas d'une case compte double ou
3 dans le cas d'une case compte triple.
- type: str, 'M' si la case est spéciale et affecte le pointage des mots;
'L' si la case est spéciale et affecte le pointage des lettres;
None si la case n'est pas spéciale.
- jeton_occupant: Jeton,
"""
def __init__(self, multiplicateur=1, type=None):
"""
Constructeur de la classe.
Notez qu'une case nouvellement créée est vide, c'est-à-dire le jeton occupant est None.
:param multiplicateur: (int, optionel) multiplicateur de la case.
:param type: (str, optionel) type de la case.
:exception: Levez une exception avec assert si le multiplicateur ne respecte pas
la condition suivante 1 <= multiplicateur <= 3 ou si le type n'est ni None, ni 'M', ni 'L'.
"""
# À compléter
# Mettre votre code ici
def est_vide(self):
"""
Vérifie si une case est vide ou pas (jeton_occupant est None ou pas).
:return: True si la case est vide, False sinon.
"""
# À compléter
# Mettre votre code ici
def placer_jeton(self, jeton):
"""
Place un jeton dans la case.
:param jeton: Jeton, objet à placer dans la case.
:return: Ne retourne rien.
:exception: Levez une exception avec assert si la case est déjà occupée.
"""
# À compléter
# Mettre votre code ici
def retirer_jeton(self):
"""
Retire le jeton de la case.
:return: Le jeton retiré.
:exception: Levez une exception avec assert si la case est vide.
"""
# À compléter
# Mettre votre code ici
def valeur_jeton(self):
"""
Permet de trouver la valeur du jeton dans la case.
:return: int, valeur du jeton occupant.
:exception: Levez une exception avec assert si la case est vide.
"""
# À compléter
# Mettre votre code ici
def lettre_jeton(self):
"""
Permet de trouver la lettre inscrite sur le jeton dans la case.
:return: str, lettre du jeton occupant.
:exception: Levez une exception avec assert si la case est vide.
"""
# À compléter
# Mettre votre code ici
@property
def code_couleur(self):
""" ** Vous n'avez pas à coder cette méthode **
Méthode permettant de trouver la couleur associée à une case.
:return: int, code de couleur de la case.
"""
if self.type == "M" and self.multiplicateur == 2:
return 43
elif self.type == "M" and self.multiplicateur == 3:
return 41
elif self.type == "L" and self.multiplicateur == 2:
return 46
elif self.type == "L" and self.multiplicateur == 3:
return 44
else:
return 0
def __str__(self):
""" ** Vous n'avez pas à coder cette méthode **
Formatage d'une case. Cette méthode est appelée lorsque vous faites str(v) où v est un case
:return: str, correspondant au formatage de la case.
"""
s = "" if self.estvide() else str(self.jetonoccupant)
return "\x1b[0;30;{}m{:^4s}\x1b[0m".format(self.code_couleur, s)
class Plateau:
"""
Cette classe représente un plateau de scrabble.
Une partie de la logique du jeu sera implémentée ici donc lisez bien les spécifications de chaque méthode.
ex:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
A A
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
B B
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
C C
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
D D
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
E E
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
F F
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
G G
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
H ★ H
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
I I
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
J J
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
K K
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
L L
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
M M
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
N N
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
O O
+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Nous avons un attribut de classe:
- DIMENSION qui représente la dimension (nombre de lignes ou de colonnes) pour le plateu de scrabble. Par défaut sa valeur est de 15.
Un plateau de scrabble a pour attribut:
- cases: Case list list, une liste de liste de cases.
Le programmeur peut avoir accès et manipuler les cases du plateau avec des indexes i et j, tels que 0 <= i < Plateau.DIMENSION et 0 <= i < Plateau.DIMENSION.
Pour vous aider un peu:
* cases[i] vous retourne la i+1 ème ligne du plateau. (L'index i == 0 correspond donc à la première ligne, et ainsi de suite).
* cases[i][j] vous donne la case au croisement de la i+1 ème ligne et de la j+1 ème colonne du plateau. (L'index j == 0 correspond donc à la première colonne, et ainsi de suite).
L'utilisateur de la classe, désignera les cases grâce à un code au format « XY » où X représente une lettre comprise entre 'A' et 'O', et Y un nombre compris entre 1 et 15. Ex: K9, E15.
- La lettre désigne une ligne: 'A' pour la 1ère ligne, B pour la seconde ligne, etc.
- Le nombre désigne une colonne: 5 correspond à la 5ème colonne.
Par exemple:
- K9 permet de désigner la case à l'intersection de la 11ème ligne et de la 9ème colonne.
- E15 permet de désigner la case à l'intersection de la 5ème ligne et 15ème colonne.
Note: Vous pouvez vour servir du graphe ASCII plus haut pour une meilleure compréhension.
"""
DIMENSION = 15
def __init__(self):
""" ** Vous n'avez pas à coder cette méthode **
Constructeur d'un plateau.
Pour compléter cette méthode vous devez vous référer à la configuration réelle d'un plateau de scrabble.
Vous pouvez commencer par créer l'attribut cases en considérant qu'aucune case n'est spéciale.
Regardez ensuite sur un vrai plateau de scrabble quelles positions sont spéciales, créer ces cases spéciales et remplacez les anciennes cases.
"""
self.cases = [[Case() for in range(Plateau.DIMENSION)] for in range(Plateau.DIMENSION)]
for (i, j) in [(0, 0), (0, 7), (0, 14), (7, 0), (7, 14), (14, 0), (14, 7), (14, 14)]:
self.cases[i][j] = Case(3, 'M')
for (i, j) in [(1, 5), (1, 9), (5, 1), (5, 5), (5, 9), (5, 13),
(9, 1), (9, 5), (9, 9), (9, 13), (13, 5), (13, 9)]:
self.cases[i][j] = Case(3, 'L')
for i in [1, 2, 3, 4]:
self.cases[i][i] = Case(2, 'M')
self.cases[i][Plateau.DIMENSION - i - 1] = Case(2, 'M')
self.cases[Plateau.DIMENSION - i - 1][Plateau.DIMENSION - i - 1] = Case(2, 'M')
self.cases[Plateau.DIMENSION - i - 1][i] = Case(2, 'M')
for i, j in [(1, 1), (4, 0), (0, 4), (5, 1), (1, 5), (7, 4)]:
self.cases[7 - i][7 - j] = Case(2, 'L')
self.cases[7 + i][7 - j] = Case(2, 'L')
self.cases[7 - i][7 + j] = Case(2, 'L')
self.cases[7 + i][7 + j] = Case(2, 'L')
self.cases[7][7] = Case(2, 'M')
@staticmethod
def codepositionest_valide(code):
""" ** Vous n'avez pas à coder cette méthode **
Méthode statique permettant de valider si un code de positionnement sur le tableau est valide ou pas.
:param code: str au format « XY » ou « xy » représentant un code de positionnement.
:return: True si le code passé en argument est un code de positionnement au format « XY » ou « xy » valide. En gros, c'est insensible à la casse.
"""
code = code.upper()
valide = 2 <= len(code) <= 3 and code[0].isalpha() and code[1:].isdigit()
if valide:
index_ligne = ord(code[0]) - ord('A')
index_colonne = int(code[1:]) - 1
return 0 <= indexligne < Plateau.DIMENSION and 0 <= indexcolonne < Plateau.DIMENSION
return False
@staticmethod
def decode_position(code):
"""
Méthode statique servant à transformer un code de positionnement sur le plateau
en index d'accès de ligne et de colonne sur le plateau.
:param s: str au format « XY » ou « xy » représentant un code de positionnement.
:return: tuple (int, int), l'index de la ligne et l'index de la colonne associés au code.
:exception: Levez une exception avec assert si le code de la position est invalide. Pensez à utiliser Plateau.codepositionest_valide.
"""
# À compléter
# Mettre votre code ici
def caseestvide(self, position_code):
"""
Permet de déterminer si une case est vide, c'est-à-dire qu'elle ne contient pas de jeton.
:param positioncode: str, au format « XY » ou « xy » qui un code de positionnement de la case sur le plateau. Pensez à réutiliser Plateau.decodeposition sur position_code.
:return: True si la case est vide, False sinon. Rappelez-vous qu'il existe une méthode est_vide disponible pour les objets de type Case.
:exception: Levez une exception avec assert si le code de la position est invalide.
"""
# À compléter
# Mettre votre code ici
def est_vide(self):
"""
Permet de déterminer si le plateau est vide, c'est à dire que toutes les cases sont vides.
:return: True si le plateau est vide, False sinon.
"""
# À compléter
# Mettre votre code ici
def ajouterjeton(self, jeton, positioncode):
"""
Permet d'ajouter un jeton dans une case vide du plateau. La case est indiquée grâce à son code de positionnement.
:param jeton: Jeton, le jeton à ajouter sur le plateau.
:param position_code: str, la position où ajouter (au format « XY » ou « xy »)
:return: Ne retourne rien.
:exception: Levez une exception avec assert si le code de la position est invalide ou la case n'est pas vide.
"""
# À compléter
# Mettre votre code ici
def retirerjeton(self, positioncode):
"""
Permet d'enlever le jeton dans une case du plateau. La case est indiquée grâce à son code de positionnement.
:param position_code: str, la position où enlever le jeton (au format « XY » ou « xy »).
:return: Jeton, le jeton à enlever du plateau. Rappelez-vous qu'il existe une méthode retirer_jeton disponible pour les objets de type Case.
:exception: Levez une exception avec assert si le code de la position est invalide ou la case n'est pas vide.
"""
# À compléter
# Mettre votre code ici
def casesadjacentesoccupees(self, position_code):
""" ** Vous n'avez pas à coder cette méthode **
Étant donnée une position, cette méthode permet de voir si au moins l'une de ses positions voisines est occupée.
Les cases voisines sont les cases juste en haut, en bas, à gauche et à droite de la case concernée.
NB: Les cases voisines diagonales ne comptent pas.
:param position_code: str, la position d'intérêt.
:return: True si au moins l'une des cases voisines est occupée, False si aucune case voisine n'est occupée.
:exception: Levez une exception avec assert si le code de la position est invalide
"""
indexligne, indexcolonne = Plateau.decodeposition(positioncode)
voisins = [(indexligne, indexcolonne - 1), (indexligne, indexcolonne + 1), (indexligne + 1, indexcolonne), (indexligne - 1, indexcolonne)]
voisins = [(i, j) for i, j in voisins if (0 <= i < Plateau.DIMENSION)
and (0 <= j < Plateau.DIMENSION)]
return any([not self.cases[i][j].est_vide() for (i, j) in voisins])
def validerpositionsavantajout(self, positionscodes):
""" ** Vous n'avez pas à coder cette méthode **
Cette méthode implémente certaines règles du jeu donc soyez attentifs au texte ci-dessous.
Étant données des positions_codes où un utilisateur veut placer ses jetons, cette méthode permet de valider s'il peut réelement ajouter les jetons à ces positions.
Les positions sont valides si:
- elles sont toutes vides;
- elles sont toutes sur la même ligne ou la même colonne;
- une fois qu'elles seront placées sur une même ligne ou une même colonne, elles formeront un mot et pas plus sur cette même ligne ou colonne. Ici, le mot formé n'est pas important du tout donc n'essayez pas de le trouver;
Par exemple, si toutes les positions sont sur la ligne 5, votre code doit juste s'assurer qu'entre les positions où vous devez ajouter des jetons, des cases ne sont vides.
- si le plateau est vide, le centre du plateau doit être dans les positions;
- sinon, au moins une des positions doit être adjacente à une des cases occupées
du plateau (Pensez à réutilisez casesadjacentesoccupees et caseestvide).
:param positions_codes: str list, liste de string représentant les positions où on veut ajouter des jetons.
:return: True si les positions sont valides, False sinon.
:exception: Levez une exception avec assert si le code d'une des positions est invalide.
"""
positionsdecodees = [Plateau.decodeposition(p) for p in positions_codes]
lignes, cols = zip(*positions_decodees)
lignes, cols = list(set(lignes)), list(set(cols))
memeligne, memecol = len(lignes) == 1, len(cols) == 1
valide = memeligne or memecol
valide = valide and all([self.caseestvide(p) for p in positions_codes])
if valide:
if self.est_vide():
valide = (7, 7) in positions_decodees
else:
valide = any([self.casesadjacentesoccupees(pos) for pos in positions_codes])
if valide and meme_ligne:
ligne, n, m = lignes[0], min(cols), max(cols)
valide = all([(not self.cases[ligne][i].est_vide()) for i in range(n, m + 1) if i not in cols])
elif valide and meme_col:
col, n, m = cols[0], min(lignes), max(lignes)
valide = all([(not self.cases[i][col].est_vide()) for i in range(n, m + 1) if i not in lignes])
return valide
def placermots(self, jetonsaajouter, positioncodes):
"""
Permet de placer plusieurs jetons sur le plateau afin de former un ou plusieurs mots.
Pensez à réutiliser validerpositionsavant_ajout.
:param jetonsaajouter: Jetons à ajouter pour placer nos mots.
:param position_codes: str list, liste de chaînes de caractères représentant les positions où on veut placer les jetons.
:return: tuple de type (str list, int):
- Le premier élement est la liste des mots formés avec les jetons si l'ajout a été fait, liste vide sinon.
- Le second élément est le score obtenu si l'ajout a été fait, 0 sinon.
:exception: Levez une exception avec assert si les positions sont invalides.
"""
# À compléter
# Mettre votre code ici
def motsscoreobtenus(self, nouvelles_positions):
""" ** Vous n'avez pas à coder cette méthode **
Trouver les mots ajoutés et le score total obtenu lorsque le joueur vient juste d'ajouter des jetons aux positions de la liste en argument.
:param nouvelles_positions: str list, liste de chaînes de caractères représentant les dernières positions où des jetons ont été ajoutés.
:return: L'ensemble des mots formés par l'ajout de jetons aux nouvelles positions.
"""
positionsdecodees = [Plateau.decodeposition(p) for p in nouvelles_positions]
score_total = 0
lignes, cols = zip(*positions_decodees)
mots = []
for ligne in set(lignes):
lmots, score = self.__motsetscoresurligneoucolonne(nouvelles_positions, ligne)
mots += lmots
score_total += score
for col in set(cols):
lmots, score = self.__motsetscoresurligneoucolonne(nouvelles_positions, colonne=col)
mots += lmots
score_total += score
return mots, score_total
def __motsetscoresurligneoucolonne(self, nouvelles_positions, ligne=None, colonne=None):
""" ** Vous n'avez pas à coder cette méthode **
Permet de trouver les mots sur une ligne ou une colonne et le score associé.
:param nouvelles_positions: str list, liste de chaînes de caractères représentant les dernières positions où des jetons ont été ajoutés.
:param ligne: (int, optionel), index de la ligne d'intérêt
:param colonne: (int, optionel), index de la colonne d'intérêt
:return: tuple (str list, int), la liste des mots trouvés sur la ligne ou la colonne et le score total.
Plus précisément la liste devra contenir au maximum un élément car un tout nouvel ajout de jetons ne peut pas créer plus d'un mot sur la même ligne ou colonne.
:exception: Levez une exception avec assert si la ligne et la colonne sont spécifiées ou aucun des deux ne l'est.
"""
assert (ligne is None) ^ (colonne is None), "Précisez seulement la ligne ou la colonne, pas les deux."
positionsdecodees = [Plateau.decodeposition(p) for p in nouvelles_positions]
mots, score_total = [], 0
mot, scoremot, multiplicateur, posmot = "", 0, 1, []
for i in range(Plateau.DIMENSION):
pos = (ligne, i) if ligne is not None else (i, colonne)
case = self.cases[pos[0]][pos[1]]
if case.est_vide():
if len(mot) > 1 and any([p in posmot for p in positionsdecodees]):
mots.append(mot)
scoretotal += scoremot * multiplicateur
mot, scoremot, multiplicateur, posmot = "", 0, 1, []
else:
mot += case.lettre_jeton()
pos_mot.append(pos)
if pos in positions_decodees and case.type == "L":
scoremot += case.valeurjeton() * case.multiplicateur
else:
scoremot += case.valeurjeton()
if pos in positions_decodees and case.type == "M":
multiplicateur *= case.multiplicateur
if len(mot) > 1 and any([p in posmot for p in positionsdecodees]):
mots.append(mot)
scoretotal += scoremot * multiplicateur
return mots, score_total
def __str__(self):
""" ** Vous n'avez pas à coder cette méthode **
Formatage du plateau pour l'affichage.
Utilise des codes Unicode, ce qui pourrait causer des problèmes avec le système d'exploitation utilisé par certains.
:return: str, correspondant au formatage du plateau.
"""
ligne_separation = ' +' + '----+' * Plateau.DIMENSION + '\n'
chaine = ' '
for colonne in range(Plateau.DIMENSION):
chaine += "{:^5d}".format(colonne+1)
chaine += '\n'
chaine += ligne_separation
for rangee in range(Plateau.DIMENSION):
chaine += '{} |'.format(chr(ord('A')+rangee))
for colonne in range(Plateau.DIMENSION):
if rangee == colonne and rangee == 7 and self.cases[rangee][colonne].est_vide():
s = "\x1b[0;30;{}m{:^4s}\x1b[0m".format(self.cases[rangee][colonne].code_couleur, '\u2605')
else:
s = "{:^4s}".format(str(self.cases[rangee][colonne]))
chaine += s + '|'
chaine += ' {}\n'.format(chr(ord('A') + rangee))
chaine += ligne_separation
chaine += ' '
for colonne in range(Plateau.DIMENSION):
chaine += "{:^5d}".format(colonne+1)
chaine += '\n'
return chaine
