def line_move(plateau, num_lig, sens):
"""
Permet de déplacer les tuiles d'une ligne dans un sens donné en respectant les règles du jeu Threes.
:param plateau: Un dictionnaire correspondant à un plateau de jeu.
:param num_lig: Un entier correspondant à l'indice de la ligne où se fait le déplacement.
:param sens: Un entier correspondant au sens du déplacement: 1 vers la gauche, 0 vers la droite.
"""
n = plateau['n']
tiles = plateau['tiles']
lig = num_lig * n
if sens == 1: # Déplacement vers la gauche.
i = 0
while i < n - 1: # Parcours de gauche à droite.
if is_room_empty(plateau, num_lig, i): # Si présence d'une case vide
line_pack(plateau, num_lig, i, sens) # Tassement vers la gauche.
i = n # Sortie de la boucle.
elif is_fusion_possible(tiles[lig + i], tiles[lig + i + 1]): # Si une fusion est possible entre l'élément courant et l'élément suivant.
tiles[lig + i] += tiles[lig + i + 1] # élément courant += élément suivant
line_pack(plateau, num_lig, i + 1, sens) # Tassement vers la gauche en réponse à la fusion.
i = n # Sortie de la boucle.
else:
i += 1 # Itération suivante.
elif sens == 0: # Déplacement vers la droite.
i = n - 1
while i > 0: # Parcours de droite à gauche.
if is_room_empty(plateau, num_lig, i): # Si présence d'une case vide
line_pack(plateau, num_lig, i, sens) # Tassement vers la droite.
i = 0 # Sortie de la boucle.
elif is_fusion_possible(tiles[lig + i], tiles[lig + i - 1]): # Si une fusion est possible entre l'élément courant et l'élément précédent.
tiles[lig + i] += tiles[lig + i - 1] # élément courant += élément précédent
line_pack(plateau, num_lig, i - 1, sens) # Tassement vers la droite en réponse à la fusion.
i = 0 # Sortie de la boucle.
else:
i -= 1 # Itération suivante.
def test_is_room_empty():
"""
Fonction de test de is_room_empty().
"""
p = {'n': 4,'nb_cases_libres': 14,'tiles': [0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}
assert not is_room_empty(p, 0, 1), 'Erreur : fonction is_room().'
assert is_room_empty(p, 3, 2), 'Erreur : fonction is_room().'
try:
is_room_empty(p, 15, 2) # génère une erreur
except AssertionError:
print('is_room_empty(p, 15, 2) a bien levé une erreur.')
else:
assert True == False, 'is_room_empty(p, 15, 2) aurait du lever une erreur.'
print('Fonction is_room_empty() : OK')
def column_move(plateau, num_col, sens):
"""
Permet de déplacer les tuiles d'une colonne dans un sens donné en respectant les règles du jeu Threes.
:param plateau: Un dictionnaire correspondant à un plateau de jeu.
:param num_col: Un entier correspondant à l'indice de la colonne où se fait le déplacement.
:param sens: Un entier correspondant au sens du déplacement: 1 vers le haut, 0 vers le bas.
"""
n = plateau['n']
tiles = plateau['tiles']
if sens == 1: # Déplacement vers le haut.
i = 0
while i < n - 1: # Parcours de gauche à droite.
if is_room_empty(plateau, i, num_col): # Si présence d'une case vide
column_pack(plateau, num_col, i, sens) # Tassement vers le haut.
i = n # Sortie de la boucle.
elif is_fusion_possible(tiles[i*n + num_col], tiles[n*(i + 1) + num_col]): # Si une fusion est possible entre l'élément courant et l'élément suivant.
tiles[i*n + num_col] += tiles[n*(i + 1) + num_col] # élément courant += élément suivant
column_pack(plateau, num_col, i + 1, sens) # Tassement vers le haut en réponse à la fusion.
i = n # Sortie de la boucle.
else:
i += 1 # Itération suivante.
elif sens == 0: # Déplacement vers le bas.
i = n - 1
while i > 0: # Parcours de droite à gauche.
if is_room_empty(plateau, i, num_col): # Si présence d'une case vide
column_pack(plateau, num_col, i, sens) # Tassement vers le bas.
i = 0 # Sortie de la boucle.
elif is_fusion_possible(tiles[i*n + num_col], tiles[n*(i - 1) + num_col]): # Si une fusion est possible entre l'élément courant et l'élément précédent.
tiles[i*n + num_col] += tiles[n*(i - 1) + num_col] # élément courant += élément précédent
column_pack(plateau, num_col, i - 1, sens) # Tassement vers le bas en réponse à la fusion.
i = 0 # Sortie de la boucle.
else:
i -= 1 # Itération suivante.
def test_put_next_tiles():
plateau = init_play()
tiles = get_next_alea_tiles(plateau, "init") # Tests avec le mode 'init'
put_next_tiles(plateau, tiles)
assert not is_room_empty(plateau, tiles['0']['lig'], tiles['0']['col'])
assert not is_room_empty(plateau, tiles['1']['lig'], tiles['1']['col'])
tiles = get_next_alea_tiles(plateau,
"encours") # Tests avec le mode 'encours'
put_next_tiles(plateau, tiles)
assert not is_room_empty(plateau, tiles['0']['lig'], tiles['0']['col'])
print("Test de la fonction put_next_tiles: Ok")
def cycle_play(partie):
"""
Permet de jouer au jeu Threes.
Séquencement des actions de cette fonction:
1 - Affichage du plateau de jeu
2 - Affichage de la valeur de la tuile suivante
3 - Saisie du mouvemement proposé par le joueur ; deux cas possibles:
* jouer le coup du joueur courant, mettre à jour le score et revenir au point 1.
* retourner False si le menu est demandé.
4 - Retourne True si la partie est terminée.
:param partie: Une partie de jeu en cours (voir game/play/create_new_play) ou None sinon.
:return: True si la partie est terminée, False si le menu est demandé.
"""
assert not partie is None, "Erreur: Aucune partie n'est en cours." # Vérification qu'une partie est en cours.
plateau = partie['plateau']
while not is_game_over(plateau):
full_display(plateau) # Affichage du plateau de jeu.
if len(partie['next_tile']
) == 0: # Vérification qu'une tuile n'est pas déjà stockée.
partie['next_tile'] = get_next_alea_tiles(
plateau, "encours"
) # Dans ce cas, on tire une nouvelle tuile et on la stocke dans la partie.
next_tile = partie['next_tile']['0']
print("La valeur de la tuile suivante est:",
next_tile['val']) # Affichage de la valeur de la tuile.
move = get_user_move() # Récupération du mouvement du joueur.
if move != 'm': # Vérification que le joueur ne demande pas le menu principal.
play_move(plateau, move)
if not is_room_empty(
plateau, next_tile['lig'], next_tile['col']
): # Si les coordonnées de la prochaine tuile sont déjà prises
next_tile['lig'], next_tile['col'] = get_free_space(
plateau) # suite au mouvement, on les redéfinit.
put_next_tiles(plateau,
partie['next_tile']) # Ajout de la tuile suivante.
partie['next_tile'] = {
} # Réinitialisation de la tuile stockée pour permettre un nouveau tirage.
partie['score'] = get_score(plateau) # Mise à jour du score.
else:
return False
return True
def test_get_free_space():
plateau = init_play()
lig, col = get_free_space(plateau)
assert is_room_empty(plateau, lig, col)
plateau = {
'n': 4,
'nb_cases_libres': 1,
'tiles': [6, 2, 3, 12, 2, 6, 2, 12, 2, 2, 12, 1, 12, 12, 12, 0]
}
lig, col = get_free_space(plateau)
assert lig == 3 and col == 3 # Vérification que les coordonnées de la case libre correspondent bien à celles de l'unique case libre disponible.
assert is_room_empty(plateau, lig, col)
print("Test de la fonction get_free_space: Ok")
def get_free_space(plateau):
"""
Retourne un tuple représentant une case vide aléatoire de la grille d'un plateau de jeu.
:param plateau: Un dictionnaire correspondant à un plateau de jeu.
:return: Deux entiers correspondant aux coordonnées d'une case vide (= dont la valeur vaut 0).
"""
# La recherche de coordonnées doit se faire entre 0 et la taille du plateau - 1. Or, la recherche d'un nombre
# aléatoire se fait entre deux bornes incluses c'est pour cela qu'on retire 1 à la borne supérieure.
n = plateau['n'] - 1
lig, col = randint(0, n), randint(0, n)
while not is_room_empty(plateau, lig, col): # Tant qu'une case vide n'a pas été trouvée, on en recherche une.
lig, col = randint(0, n), randint(0, n)
return lig, col
def put_next_tiles(plateau, tiles):
"""
Permet de placer une ou deux tuiles dans le plateau.
plateau : dictionnaire contenant le plateau d'un jeu
tiles : dictionnaire sous la forme de celui renvoyé par la fonction get_next_alea_tiles().
"""
while tiles['mode'] == 'encours' and not is_room_empty(
plateau, tiles['0']['lig'], tiles['0']['col']):
tile_0 = randint(0, plateau['n']**2 - 1)
tiles['0']['lig'] = tile_0 // plateau['n']
tiles['0']['col'] = tile_0 % plateau['n']
set_value(plateau, tiles['0']['lig'], tiles['0']['col'], tiles['0']['val'])
if tiles['mode'] == 'init':
set_value(plateau, tiles['1']['lig'], tiles['1']['col'],
tiles['1']['val'])
get_nb_empty_rooms(
plateau) # Ne pas oublier d'actualiser nb_cases_libres dans plateau.
def get_next_alea_tiles(plateau, mode):
""" Retoune une ou deux tuile(s) dont la position (lig, col) est tirée
aléatoirement et correspond à un emplacement libre du plateau
plateau : dictionnaire contenant le plateau du jeu
mode : valeurs possibles pour ce paramètre et significations
*************************************************************************************
* mode *
*************************************************************************************
* 'init' : * 'encours' : *
*************************************************************************************
* Un dictionnaire contenant deux tuiles * Un dictionnaire contenant une tuile, de *
* de valeur 1 et 2 est retourné. * valeur comprise entre 1 et 3 est *
* La position de chaque tuile est tirée * retournée. La position de la tuile est *
* aléatoirement et correspond à un * tirée aléatoirement et correspond à un *
* emplacement libre du plateau ; ce mode * emplacement libre du plateau ; ce mode *
* est utilisé lors de l'initialisation * est utilisé en cours de jeu. *
* du jeu. * *
*************************************************************************************
Voir l'exemple pour connaître la structure du dictionnaire.
:Exemple:
p = init_play()
tiles = get_next_alea_tiles(p,'init')
print(tiles)
{'mode': 'init',
'0': {'val': 2, 'lig': 0, 'col': 1},
'1': {'val': 1, 'lig': 3, 'col': 3},
'check': True}
tiles=get_next_alea_tiles(p,'encours')
print(tiles)
{'mode': 'encours',
'0': {'val': 3, 'lig': 0, 'col': 2},
'check': True}
Remarques :
* Les positions et valeurs de tuiles pourront être différentes
pour vos tests car elles sont tirées aléatoirement.
* La clef 'check' a une valeur True si la partie n'est pas terminée,
False sinon.
"""
if mode == 'init':
tile_0 = randint(0, plateau['n']**2 - 1)
tile_1 = randint(0, plateau['n']**2 - 1)
while not is_room_empty(plateau, tile_0 // plateau['n'],
tile_0 % plateau['n']):
tile_0 = randint(0, plateau['n']**2 - 1)
while not is_room_empty(plateau, tile_1 // plateau['n'],
tile_1 % plateau['n']) or tile_1 == tile_0:
tile_1 = randint(0, plateau['n']**2 - 1)
return {
'mode': mode,
'0': {
'val': 2,
'lig': tile_0 // plateau['n'],
'col': tile_0 % plateau['n']
},
'1': {
'val': 1,
'lig': tile_1 // plateau['n'],
'col': tile_1 % plateau['n']
},
'check': plateau['nb_cases_libres'] - 2 > 0
}
elif mode == 'encours':
tile_0 = randint(0, plateau['n']**2 - 1)
while not is_room_empty(plateau, tile_0 // plateau['n'],
tile_0 % plateau['n']):
tile_0 = randint(0, plateau['n']**2 - 1)
return {
'mode': mode,
'0': {
'val': randint(1, 3),
'lig': tile_0 // plateau['n'],
'col': tile_0 % plateau['n']
},
'check': plateau['nb_cases_libres'] - 1 > 0
}
else:
assert mode in ['init',
'encours'], 'Erreur : fonction get_next_alea_tiles().'