Nous souhaitons créer un environnement permettant de jouer au puissance 4.

• Le jeu se joue sur une grille de 6 lignes et 7 colonnes.
• Chaque joueur a une couleur de jeton – jaune et rouge en général.
• Chaque joueur, a son tour, insère un jeton dans la colonne de son choix, si bien sûr elle n'est pas déjà pleine. Le jeton tombe dans la case libre la plus bas de la colonne.
• Un joueur gagne quand il crée un alignement de 4 de ses jetons, horizontalement, verticalement ou en diagonale.
• Si la grille est pleine et qu'il n'y a toujours aucun alignement, c'est un match nul.

Nous devons distinguer deux aspects différents de notre programme :

• D'un côté, nous avons besoin d'un ensemble de commande qui permettent l'évolution du jeu : insérer un jeton dans une colonne, décider à quelle ligne tombe le jeton, rechercher un alignement, etc. C'est la bibliothèque de fonction.
• De l'autre il nous faut dérouler une partie. Demander au premier joueur de choisir une colonne, puis passer au second joueur, etc ; ou bien on pourrait faire jouer l'humain contre la machine ; ou encore faire jouer la machine contre la machine. Il s'agit du programme principal qui utilise les fonctions de la bibliothèque.

On va commencer par produire toute une liste de fonctions utiles. Chacune de ces fonctions réalisent un petit aspect du jeu. Ensuite, on pourra réaliser le programme principal.

Le jeu normal se joue sur 7 colonnes, 6 lignes et avec des alignements de 4. Nous allons donc trouver dans notre programme des 7, des 6 et des 4 à de nombreux endroits.

Supposons que l'on veuille essayer un puissance 4 sur une grille de 11×8. Cela ne devrait pas poser de difficultés pour un ordinateur. Pourtant, si nous avons écrit 7 et 6 un peu partout dans le programme, il nous faudra remplacer tous les 7 par 11 et tous les 6 par 8. C'est pénible…

Au lieu de cela on commence le programme en définissant des constantes :

"""
module fonctionspuissance4
"""

COLS = 7   # Nombre de colonnes de la grille
LIGNES = 6 # Nombre de lignes de la grille
TO_WIN = 4 # Nombre de jetons à aligner pour gagner

Le programme a besoin de savoir à chaque instant l'état de la grille : que contient telle ou telle case ?

Il y a plusieurs possibilité.

• Il serait naturel d'utiliser un tableau à deux dimensions : 7 lignes et 6 colonnes.
• On peut aussi utiliser un tableau à 1 dimension contenant 7×6 cases.

Je préconise la seconde solution. Le tableau contiendra donc LIGNES * COLS cases. La case pour la ligne lig et la colonne col sera située à la position lig * COLS + col. Les numéros de lignes et colonnes commencent à 0, la ligne 0 est en haut.

On décide aussi que

• une case vide contient le numéro 0,
• une case contenant le jeton du joueur 1 contient 1,
• une case contenant le jeton du joueur 2 contient 2,
• et ainsi de suite – rien n'empêche d'envisager un jeu à plus de 2 joueurs !

Voici un exemple. Ici le joueur 1 a les jeton jaunes et le joueur 2 a les jetons rouges.

# tableau correspondant
[0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0,
 0, 0, 1, 0, 0, 0, 0,
 0, 0, 2, 1, 2, 0, 0,
 0, 1, 2, 2, 1, 0, 0,
 2, 1, 1, 1, 2, 2, 0]

Bien que j'ai noté ce tableau sur plusieurs lignes, il s'agit bien d'un tableau à une dimension puisqu'il n'y a qu'une paire de crochets.

# c'est exactement le même tableau du point de vue de Python :
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 1, 2, 0, 0, 0, 1, 2, 2, 1, 0, 0, 2, 1, 1, 1, 2, 2, 0]

def make_empty_grid() -> list:
    """
    Renvoie un tableau de LIGNES * COLS cases et ne contenant que des 0
    """
    # à vous de compléter

def read(grid:list, lig:int, col:int) -> int:
    """
    grid: tableau de LIGNES * COLS éléments
    lig: entier dans [0;LIGNES[, indice de ligne
    col: entier dans [0;COLS[, indice de colonne
    Renvoie le contenu de grid correspondant à la ligne lig et colonne col
    """
    assert 0 <= lig < LIGNES
    assert 0 <= col < COLS
    assert len(grid) == LIGNES * COLS
    return # Complétez !

Il pourra être utile de donner une version lisible du contenu de la grille. Je propose la solution suivante.

SYMBOLS = " OX" # symboles pour les différents joueurs.
# SYMBOLS[0] correspond à une case vide.

def grid_to_str(grid:list) -> str:
    """
    grid: tableau de LIGNES * COLS éléments
    renvoie une version texte de la grille.
    """
    # création d'une grille avec les symboles au lieu des numéros
    symb_grid = [SYMBOLS[joueur] for joueur in grid]
    # création d'une grille de ligne
    symb_lignes = ["|"+"|".join(symb_grid[lig*COLS:(lig+1)*COLS])+"|" for lig in range(LIGNES)]
    return "\n".join(symb_lignes)

C'est un peu compliqué. Quelques détails pour les plus curieux :

• symb_grid = [SYMBOLS[joueur] for joueur in grid] utilise un tableau en compréhension : On crée directement un tableau dont les éléments sont obtenus par exécution de la boucle.
• symb_grid[lig*COLS:(lig+1)*COLS] permet d'extraire un tronçon correspondant à une ligne lig donnée,
• "|".join(symb_grid[lig*COLS:(lig+1)*COLS]) permet de coller les éléments de ce tronçon avec un trait de séparation de colonne,
• "|"+"|".join(symb_grid[lig*COLS:(lig+1)*COLS])+"|" permet d'ajouter des traits de colonnes au début et à la fin,
• [... for lig in range(LIGNES)] permet de faire cela pour toutes les lignes et de mettre l'ensemble des résultats dans un tableau,
• "\n".join(symb_lignes) permet de coller les lignes obtenus par un symbole de retour chariot – retour à la ligne – que l'on note "\n".

Une colonne si la case du haut de cette colonne est occupée. Pour une colonne col il nous suffit de lire le contenu de cette colonne et de la ligne 0 et de voir si le contenu est occupé.

def col_is_full(grid:list, col:int) -> bool:
    """
    grid: tableau de LIGNES * COLS éléments
    col: indice de la colonne
    renvoie True si la colonne est pleine, False sinon
    """
    # à vous...

Il faut vérifier chaque colonne. Si au moins une n'est pas pleine, c'est que la grille n'est pas pleine.

def grid_is_full(grid:list) -> bool:
    """
    grid: tableau de LIGNES * COLS éléments
    renvoie True si la grille est pleine, False sinon
    """
    # à vous...

Ajoute un jeton du joueur donné dans la plus haute case libre de la colonne.

def insert(grid:list, col:int, player:int):
    """
    grid: tableau de LIGNES * COLS éléments
    col: indice de la colonne
    player: numéro du joueur
    """
    assert not col_is_full(grid, col)
    # À vous !

Cette partie est plus difficile. L'humain reconnaît d'un coup d'œil la présence ou l'absence d'alignement. Je vous propose l'approche suivante :

• On choisit une orientation – diagonale ↘, diagonale ↗, verticale, horizontale
• On choisit un point de départ, par exemple le coin supérieur gauche
• On parcourt cet alignement du point de départ jusqu'à atteindre un bord. On relève les valeurs rencontrées.

FONCTION get_line
ENTRÉES
    grille
    pas: déplacement à faire d'un case à l'autre
    depart: position de départ
SORTIE: une chaîne de caractères line valeurs de l'alignement
DÉBUT
    soit position en cours définie par la position de depart
    soit line une chaine vide
    TANT QUE position en cours à l'intérieur de la grille RÉPÉTER
        lire le contenu de la grille en position,
        ajouter ce qui a été lu au bout de line
        modifier position selon le pas
    FIN
    RENVOYER line
FIN

Exemple :

0000000
0000000
0010000
0022200
0012120
1121211

Si on se donne depart= (0,0), cela désigne le coin supérieur gauche. pas = (1,1) fait se déplacer en diagonale ↘. L'appel get_line(grille, pas, depart) doit renvoyer "001211".

Exemple d'utilisation :

• get_line(grid, (1,1), (0,0)) renvoie la diagonale ↘ partant du coin supérieur droit,
• get_line(grid, (1,1), (0,1)) renvoie la diagonale ↘ partant de la deuxième case de la première ligne,
• get_line(grid, (-1,1), (0,3)) renvoie la diagonale ↙ partant de la quatrième case de la première ligne,
• get_line(grid, (0,1), (0,3)) renvoie la colonne partant de la quatrième case de la première ligne,
• get_line(grid, (1,0), (2,0)) renvoie la troisième ligne.

On ajoute une deuxième fonction pour compter le nombre max de répétitions d'un symbole :

def line_has_victory(line:str, valeur:int) -> bool:
    '''
    line: chaîne représentant un alignement. ex : "012111"
    valeur: valeur recherchée. ex : 1
    renvoie True si line contient un alignement assez long
      ex: ici non, il n'y a que 3 fois le 1 à la suite
    '''

Et maintenant vous pouvez envisager une fonction qui parcours toutes les lignes possibles à la recherche d'une victoire.

def grid_has_victory(grid:list) -> bool:
    """
    grid: grille de jeu
    renvoie True si un alignement gagnant a été trouvé, False sinon
    """
    # À vous !

À placer dans un fichier fonctionspuissance4.py.

"""
module fonctionspuissance4
"""

COLS = 7   # Nombre de colonnes de la grille
LIGNES = 6 # Nombre de lignes de la grille
TO_WIN = 4 # Nombre de jetons à aligner pour gagner

def make_empty_grid() -> list:
    """
    Renvoie un tableau de LIGNES * COLS cases et ne contenant que des 0
    """
    # à vous de compléter
    
def read(grid:list, lig:int, col:int) -> int:
    """
    grid: tableau de LIGNES * COLS éléments
    lig: entier dans [0;LIGNES[, indice de ligne
    col: entier dans [0;COLS[, indice de colonne
    Renvoie le contenu de grid correspondant à la ligne lig et colonne col
    """
    assert 0 <= lig < LIGNES
    assert 0 <= col < COLS
    assert len(grid) == LIGNES * COLS
    return # Complétez !

SYMBOLS = " OX" # symboles pour les différents joueurs.
# SYMBOLS[0] correspond à une case vide.

def grid_to_str(grid:list) -> str:
    """
    grid: tableau de LIGNES * COLS éléments
    renvoie une version texte de la grille.
    """
    # création d'une grille avec les symboles au lieu des numéros
    symb_grid = [SYMBOLS[joueur] for joueur in grid]
    # création d'une grille de ligne
    symb_lignes = ["|"+"|".join(symb_grid[lig*COLS:(lig+1)*COLS])+"|" for lig in range(LIGNES)]
    return "\n".join(symb_lignes)

def col_is_full(grid:list, col:int) -> bool:
    """
    grid: tableau de LIGNES * COLS éléments
    col: indice de la colonne
    renvoie True si la colonne est pleine, False sinon
    """
    # à vous...

def grid_is_full(grid:list) -> bool:
    """
    grid: tableau de LIGNES * COLS éléments
    renvoie True si la grille est pleine, False sinon
    """
    # à vous...

def insert(grid:list, col:int, player:int):
    """
    grid: tableau de LIGNES * COLS éléments
    col: indice de la colonne
    player: numéro du joueur
    """
    assert not col_is_full(grid, col)
    # À vous !

def get_line(grid:list, step:tuple, start:tuple) -> str:
    """
    grid: grille de jeu
    step: paire (step_lig,step_col) indiquant le déplacement d'une case à la suivante
    start: paire (start_lig, start_col) indiquant la position de départ
    renvoie une chaîne correspondant à l'alignement demandé
    """
    # À vous !

def line_has_victory(line:str, valeur:int) -> bool:
    '''
    line: chaîne représentant un alignement. ex : "012111"
    valeur: valeur recherchée. ex : 1
    renvoie True si line contient un alignement assez long
      ex: ici non, il n'y a que 3 fois le 1 à la suite
    '''

def grid_has_victory(grid:list) -> bool:
    """
    grid: grille de jeu
    renvoie True si un alignement gagnant a été trouvé, False sinon
    """
    # À vous !

Il faut importer les fonctions définies précédemment.

# main.py

from fonctionspuissance4 import *

Ensuite le jeu suit l'algorithme suivant :

DÉBUT
    créer une grille vide
    afficher la grille
    joueur en cours est 1
    partie_finie est faux
    TANT QUE partie finie est faux RÉPÉTER
        demander au joueur en quelle colonne il souhaite jouer
        jouer le coup pour le joueur en cours
        afficher la grille
        SI la grille contient une victoire ALORS
            partie_finie passe à vrai
            afficher un message indiquant la victoire du joueur
        SINON SI la grille est pleine ALORS
            partie_finie passe à vrai
            afficher un message indiquant le match nul
        SINON
            changer de joueur
        FIN
    FIN
FIN

À vous de compléter le fichier main.py