Bonjour j'ai pour ces vacance un projet python(edupython) c'est un puissance 4.Je ne comprend pas grand chose aux modules que mon professeur m'a donner donc je vous demande de m'aider.Si possible rapidement merci.

Voici les modules a ne pas changer:

################################################################################
# Mini projet Puissance 4 à réaliser en équipe de 3
# Le plateau de jeu est modélisé par une liste de 6 éléments représentant les lignes du plateau
# Chaque ligne contient 6 éléments représentant les case du plateau
# La valeur de la case sera 0 pour une case vide ou 1 pour un pion rouge ou 3 pour un pion jaune
# Pour accéder à une case,il faut indiquer son numéro de ligne et son numéro de colonne
# sans oublier que les indices commencent à zéro.
# Ainsi pour la case en haut à gauche (1ère ligne,1ère colonne), on écrira grille[0][0]
#       pour la case en 4e ligne et 2e colonne :  grille[3][1]
################################################################################
# Chacun de vous sera responsable de l'un des modules suivants
# VOTRE travail sera de compléter VOTRE module afin de rendre le jeu fonctionnel.
from gravite import *
from horizontal_vertical import alignement_quadrillage
from oblique import alignement_oblique

####### Le code ci-dessous n'est pas à modifier ################################
import IHM

def nouvelle_partie():
    ''' Cette fonction renvoie une grille vide et le joueur de départ.
        Elle déclenche aussi l'affichage du plateau vide sur l'IHM.    '''
    IHM.affichage_plateau_vide()
    return [[0] * 7 for _ in range(6)], 1

def placement_pion(grille, joueur, num_ligne, num_colonne):
    ''' Cette fonction place le pion du joueur passé en paramètre dans la
        case dont le numéro de ligne et de colonne sont eux aussi passés en
        paramètre. La gravité et l'affichage de la grille dans la console sont
        appliqués si le module gravite a été complété.  '''
    cl = case_libre_la_plus_basse(grille, num_colonne)
    if cl is not None : num_ligne, num_colonne = cl
    grille[num_ligne][num_colonne]= joueur
    affichage_console(grille)
    IHM.collage_du_pion( joueur, num_ligne, num_colonne )

# On affiche la fenêtre d'interface graphique du jeu
IHM.chargement_jeu()
continuer_jeu = True
# On démarre une nouvelle partie
grille, joueur = nouvelle_partie()
# Tant que le jeu continue ...
while continuer_jeu == True :
    # Pour chaque évènement, sur la fenêtre d'interface graphiqe
    for event in IHM.pygame.event.get():
        # Si cet évènement est un clic sur la croix rouge, on stoppe le jeu
        if event.type == IHM.pygame.locals.QUIT:
            continuer_jeu = False
        # Si cet évènement est un clic gauche, on vérifie la zone cliquée
        if event.type == IHM.pygame.locals.MOUSEBUTTONDOWN and event.button == 1:
            pion_x, pion_y = event.pos[0], event.pos[1]
            # Si la zone cliquée est "Nouvelle partie", on démarre une partie partie
            if 0<=pion_x<=349 and 600<=pion_y<=700:
                grille, joueur = nouvelle_partie()
            # Sinon la zone cliquée est "Quitter", on stoppe le jeu
            elif 350<=pion_x<=700 and 600<=pion_y<=700:
                continuer_jeu = False
            # Sinon si la partie n'est pas finie, on identifie la case choisie
            elif not joueur == 0 :
                num_ligne, num_colonne = IHM.recuperation_case(pion_x, pion_y)
                # Si la case est libre, on place le pion du joueur actuel
                if grille[num_ligne][num_colonne] == 0:
                    placement_pion(grille, joueur, num_ligne, num_colonne)
                    # Si le joueur a gagné, on affiche la victoire
                    if alignement_quadrillage(grille) or alignement_oblique(grille) :
                        IHM.victoire(joueur)
                        joueur = 0
                    # Sinon on passe au joueur suivant
                    elif joueur == 1 : joueur = 3
                    else : joueur = 1
# On ferme la fenêtre d'interface graphique du jeu
IHM.pygame.quit()

,

import pygame
from pygame.locals import *

def chargement_jeu():
    ''' Cette fonction affiche l'interface graphique du jeu de puissance 4. '''
    global fenetre
    global pionr
    global pionj
    # Création de la fenêtre
    pygame.init()
    fenetre = pygame.display.set_mode((700,700))
    # Chargement des visuels des pions
    pionr = pygame.image.load("images/PionRouge.png").convert_alpha()
    pionj = pygame.image.load("images/PionJaune.png").convert_alpha()
    # Ajout des boutons "Nouvelle partie" et "Quitter"
    bouton_jouer = pygame.image.load("images/bouton jouer.png")
    bouton_sortie = pygame.image.load("images/bouton sortie.png")
    fenetre.blit(bouton_jouer, (0,600))
    fenetre.blit(bouton_sortie, (350,600))
    # Affichage de la fenêtre
    pygame.display.flip()

def affichage_plateau_vide():
    ''' Cette fonction affiche le plateau vide.
        La fonction chargement_jeu() doit avoir été appelée avant. '''
    global fond
    fond = pygame.image.load("images/grille.png")
    fenetre.blit(fond, (0,0))
    pygame.display.flip()

def recuperation_case(pion_x, pion_y):
    ''' Cette fonction renvoie le numéro de ligne et le numéro de colonne de la
        case contenant le pixel (pion_x, pion_y) de l'interface graphique  '''
    return int(pion_y/100), int(pion_x/100)

def collage_du_pion(joueur, num_ligne, num_colonne):
    ''' Cette fonction dessine le pion du joueur donné à la position donnée.
        Le paramètre joueur doit avoir la valeur 1 pour les pions rouges.    '''
    if joueur == 1 : pion = pionr
    else : pion = pionj
    fond.blit(pion, (num_colonne*100,num_ligne*100) )
    fenetre.blit(fond, (0,0))
    pygame.display.flip()

def victoire(joueur):
    ''' Cette fonction affiche le message de victoire pour le joueur donné.
        Le paramètre joueur doit avoir la valeur 1 pour les pions rouges.    '''
    if joueur == 1 : vic = pygame.image.load("images/Rougegagne.png").convert_alpha()
    else : vic = pygame.image.load("images/Jaunegagne.png").convert_alpha()
    fond.blit(vic, (125,140))
    fenetre.blit(fond, (0,0))
    pygame.display.flip()

Mon professeur m'a donner des images pour l'interface(déja mis):

• Et voici les modules qu'il faut remplir:

################################################################################
# Votre travail consiste à compléter les fonctions suivantes afin de pouvoir   #
# afficher la grille dans la console et de rétablir la gravité pour les pions  #
################################################################################
# Il s'agit bien sûr de respecter scrupuleusement les specifications.
# Un commentaire pour les lignes de code non triviales est exigé.
# Pour tester votre script, il suffit d'exécuter le programme JeuPuissance4.
# Le jeu se joue avec la souris uniquement, les joueurs se la passe à tour de role.
# Si vos fonctions sont justes alors le jeu fonctionnera !
# Bon courage.


def affichage_console(grille):
    ''' Cette fonction affiche la grille dans la console.
        Chaque ligne de la grille est affichée sur une ligne différente dans le console.
        Un séparateur est affiché après la grille.
    '''
    pass      # permet d'exécuter une fonction vide

def case_libre_la_plus_basse(grille,num_colonne):
    ''' Cette fonction renvoie la case libre la plus basse de la colonne donnée.
        Si la colonne est pleine, cette fonction renverra None.
    entrée:
        grille: tableau de 6 lignes et 7 colonnes représentant le plateau du jeu
        num_colonne: numéro de la colonne à analyser
    return: (num_ligne,num_colonne) correspondant au numéro de ligne et au
        numéro de colonne de la case vide la plus basse dans la colonne donnée.
    '''
    pass      # permet d'exécuter une fonction vide

,

################################################################################
# Votre travail consiste à compléter les fonctions ci-dessous afin de          #
#  contribuer à la détection d'une victoire                                    #
################################################################################
# Il s'agit bien sûr de respecter scrupuleusement les specifications.
# Un commentaire pour les lignes de code non triviales est exigé.
# Pour tester votre script, il suffit d'exécuter le programme JeuPuissance4.
# Le jeu se joue avec la souris uniquement, les joueurs se la passe à tour de role.
# Si vos fonctions sont justes alors le jeu fonctionnera !
# Bon courage.

def alignement_oblique_descendant(grille):
    ''' Cette fonction renvoie True si la grille contient un alignement oblique
        descendant de 4 pions de même couleur. Sinon elle renvoie False. '''
    pass     # permet d'exécuter une fonction vide

def alignement_oblique_montant(grille):
    ''' Cette fonction renvoie True si 4 pions de même couleur sont alignés
        horizontalement. Elle renvoie False sinon.   '''
    pass     # permet d'exécuter une fonction vide

def alignement_oblique(grille):
    ''' Cette fonction renvoie True si la grille contient un alignement oblique
        de 4 pions de même couleur (que ce soit en descendant ou en montant.
        Sinon elle renvoie False. '''
    pass     # permet d'exécuter une fonction vide

et

################################################################################
# Votre travail consiste à compléter les fonctions ci-dessous afin de          #
#  contribuer à la détection d'une victoire                                    #
################################################################################
# Il s'agit bien sûr de respecter scrupuleusement les specifications.
# Un commentaire pour les lignes de code non triviales est exigé.
# Pour tester votre script, il suffit d'exécuter le programme JeuPuissance4.
# Le jeu se joue avec la souris uniquement, les joueurs se la passe à tour de role.
# Si vos fonctions sont justes alors le jeu fonctionnera !
# Bon courage.

def alignement_horizontal(grille):

    ''' Cette fonction renvoie True si 4 pions de même couleur sont alignés
        horizontalement. Elle renvoie False sinon.   '''
    pass     # permet d'exécuter une fonction vide

def alignement_vertical(grille):
    ''' Cette fonction renvoie True si 4 pions de même couleur sont alignés
        horizontalement. Elle renvoie False sinon.   '''
    pass     # permet d'exécuter une fonction vide

def alignement_quadrillage(grille):

    ''' Cette fonction renvoie True si la grille contient un alignement
        horizontal ou vertical de 4 pions de même couleur.
        Sinon elle renvoie False. '''
    pass     # permet d'exécuter une fonction vide

Voila les 3 modules a remplir.

Merci beaucoup si vous m'aider.

Vous avez essayé quoi et quel soucis rencontrez vous? Parce que si c'est pour juste faire votre boulot, vous ne progresserez pas et autant rendre copie blanche et la solution du professeur.

Je n'ai pas compris comment il fallait faire pour regarder si des pions étaient accoter d'un autre et comment faire pour faire

-
Edité par Sifasi_strc 26 octobre 2023 à 17:03:30

Ta grille c'est une matrice 6 lignes de 7 colonnes, donc chaque case a une coordonnée (x,y) (on définit le point (0,0) en haut à gauche par facilité).

Donc comment faire pour savor si un pion de coordonnée (x,y) possède un voisin ? je te laisse là-dessus

En regardant les coordonnée de (x+1,y), (x-1,y),(x,y-1),(x,y+1) ?

avec une boucle for?

sans oublier les coins pour vérifier les diagonales gagnantes.
teste et vois