def cycle_play(partie):
"""
Permet de jouer à Threes
:param partie: Partie de jeu en cours ou None sinon
:return: True si la partie est terminée, False si menu demandé
Séquencement des actions pour cette fonction :
1 - afficher le plateau de jeu,
2 - affiche la prochaine tuile pour informer le joueur,
3 - saisir le mouvement proposé par le joueur ; deux cas possibles :
* jouer le coup du joueur courant, mettre à jour le score et revenir au point 1-
* ou retourner False si menu demandé
4 - si partie terminée, retourne True
"""
if partie is None:
partie = create_new_play()
while not is_game_over(partie['plateau']):
full_display(partie['plateau'])
partie['next_tile'] = get_next_alea_tiles(partie['plateau'], 'encours')
print('Tuile suivante : ', partie['next_tile']['0']['val'])
user_move = get_user_move()
if user_move == 'm':
return False
else:
play_move(partie['plateau'], user_move)
put_next_tiles(partie['plateau'], partie['next_tile'])
print(full_display(partie['plateau']))
return True
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 create_new_play():
"""
:return: dictionnaire d'une nouvelle partie ayant pour clefs:
- 'plateau': (dictionnaire) mémorisant le plateau de jeu.
- 'next_tile': (dictionnaire) mémorisant la prochaine tuile à placer. Au départ ce dictionnaire est vide.
- 'score': (entier) le score courant du joueur.
"""
plateau = init_play()
next_tiles = get_next_alea_tiles(plateau, 'init')
put_next_tiles(plateau, next_tiles)
return {'plateau': plateau, 'next_tile': {}, 'score': get_score(plateau)}
def create_new_play():
"""
Crée une nouvelle partie sous la forme d'un dictionnaire.
Ses clés sont les suivantes:
- 'plateau': Un dictionnaire correspondant au plateau de jeu.
- 'next_tile': Un dictionnairement mémorisant la prochaine tuile à placer (vide au départ).
- 'score': Un entier correspondant au score courant du joueur.
:return: Un dictionnaire correspondant à la partie créée.
"""
plateau = init_play()
tiles = get_next_alea_tiles(plateau,
"init") # Génération des tuiles de départ.
put_next_tiles(plateau,
tiles) # Ajout des tuiles de départ dans le plateau.
return {'plateau': plateau, 'next_tile': {}, 'score': get_score(plateau)}
def cycle_play( partie ) :
while partie != None:
afficharge(partie['plateau'])
print(partie['next tile'])
choix = get_user_move()
if choix == 'm' :
return False
else :
play_move(partie['plateau'],choix)
partie['score']= get_score(partie['plateau'])
partie['next tile '] = put_next_tiles(partie['plateau'],get_next_alea_tiles(partie['plateau'],'encours'))
partie['plateau']['nombre_cases_libres']= get_nb_empty_room(partie['plateau'])
if check_game_over(partie['plateau']) :
return True
def test_put_next_tiles():
""" Fonction de test de put_next_tiles()."""
p = init_play()
tiles1 = {'mode': 'init',
'0': {'val': 2, 'lig': 0, 'col': 1},
'1': {'val': 1, 'lig': 3, 'col': 3},
'check': True}
put_next_tiles(p, tiles1)
assert p == {'n': 4,
'nb_cases_libres': 14,
'tiles': [0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,1]
}, 'Erreur : fonction put_next_tiles().'
tiles2 = {'mode': 'encours',
'0': {'val': 3, 'lig': 0, 'col': 2},
'check': True}
put_next_tiles(p, tiles2)
assert p == {'n': 4,
'nb_cases_libres': 13,
'tiles': [0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
}, 'Erreur : fonction put_next_tiles().'
p = {'n': 4,
'nb_cases_libres': 3,
'tiles': [2, 2, 3, 2, 6, 12, 24, 48, 96, 192, 384, 768, 0, 0, 0, 1]
}
tiles3 = {'mode': 'encours',
'0': {'val': 3, 'lig': 0, 'col': 0},
'check': True}
put_next_tiles(p, tiles3)
assert p == {'n': 4,
'nb_cases_libres': 2,
'tiles': [2, 2, 3, 2, 6, 12, 24, 48, 96, 192, 384, 768, 3, 0, 0, 1]
} or p == {'n': 4,
'nb_cases_libres': 2,
'tiles': [2, 2, 3, 2, 6, 12, 24, 48, 96, 192, 384, 768, 0, 3, 0, 1]
} or p == {'n': 4,
'nb_cases_libres': 2,
'tiles': [2, 2, 3, 2, 6, 12, 24, 48, 96, 192, 384, 768, 0, 0, 3, 1]
}, 'Erreur : fonction put_next_tiles().'
print('Fonction put_next_tiles() : OK')