Formino

Professeurs référents :

M FAURY (ISN)

Jeu de société FORMINO

Inès BLANCO-MAZIN et Agathe LORAIN, TS5, 2017-2018

Projet : Réaliser le jeu formino.

Règles du jeu : FORMN_RG

Compétences :

Dimension algorithmique	Créer les cartes qui donnent les formes Générer un plateau de jeu
Éléments de programmation	Déplacer ses pions Comparer les cartes au plateau de jeu
Utilisation des réseaux	Éventuellement créer le jeu en réseau
Représentation de l’information	Créer une interface graphique

Contraintes : Il faut s’approprier Tkinter.

Répartition des tâches :

Inès	Agathe
Générer les cartes Programme qui compare la carte au plateau de jeu en cours Faire le décompte des points	Créer le plateau plus une partie propre à chaque joueur Changer les pions de place « Traduire » les cartes visuellement

Cahier des charges :

Chaque joueur a devant lui le plateau de jeu et les cartes avec les formes qu’il doit réaliser. L’ordinateur doit reconnaître les formes faites et compter les points. Lorsqu’un joueur arrive au nombre de points déterminés le jeu s’arrête.

Ressources documentaires :

Site « L’informatique c’est fantastique ! »

Règle du jeu (source personnelle)

Avancement du projet :

Date	Inès	Agathe
30/01	Liste des tâches à réaliser, répartition du travail. Première approche de Tkinter.
7/02	Création des cartes (début)	Apprendre à utiliser Tkinter
Vacances de février		Création de la fenêtre, du plateau. Mise en page.
28/02	Création des cartes (suite)	Affichage des cartes pour un joueur.
entre le 20 et le 28/03		Optimisation du code du plateau et de l’affichage d’une carte. Amélioration de la lisibilité du code.
02/04		Recherche de l’introduction d’un évènement pour déplacer les pions. Optimisation de ce code pour modifier le plateau.
04/04	Fonction pour faire tourner les cartes Fonction pour comparer deux cartes Création des cartes (suite)	Fin de l’optimisation de la fonction « bouger pions ». Réorganisation du code avec l’introduction de la fonction application.
Vacances d’avril		Organisation du plateau avec la méthode grid, redimension du plateau. Affichage de la main de chaque joueur dans une fenêtre à part.
25/04	Modification du programme pour créer les cartes (la première façon n’étant pas pratique)	Réglage des problèmes pour qu’un évènement déplace les pions et modifie la liste du plateau.
08/05		Création d’un canvas pour afficher le score des joueurs et déterminer à qui est-ce le tour de jouer.

[reveal heading= »%image% Programme »]

Programme principal

from tkinter import *
from creer_cartes import *


class AppFormino(Tk):
    def __init__(self):
        Tk.__init__(self)
        self.geometry("%dx%d+%d+%d" % (800, 600, 400, 0))
        
        self.plateau = [0,0,0,0,1,2,2,2,2] # Disposition par defaut du plateau
        self.joueur_courant = 1 # A qui de jouer


        self.texte = StringVar() # pour afficher a qui le tour
        self.texte.set("C'est au tour du joueur Bleu")
        self.instruct1=Label(self, textvariable=self.texte, fg="blue", cursor="circle", font="bold", relief="raised")
        self.instruct1.grid(row=2, column=3, columnspan=10)

        self.score= StringVar()
        self.score.set("Score")
        self.afscore=Label(self, textvariable=self.score, fg="grey", cursor="circle", font="bold", relief="raised")
        self.afscore.grid(row=1, column=15)
        
        self.minsize(800,250) # taille de la fenetre
        self.title("Formino")# titre
        self['bg']='white' # couleur fond
        self.resizable(width=False, height=False)# taille fixe
        
        self.grid()
        self.createWidgets()
          
        # Generation du paquet de cartes
        self.cartes = creer_cartes()
        print(self.cartes)
        
        # get screen width and height
        ws = self.winfo_screenwidth() # width of the screen
        hs = self.winfo_screenheight() # height of the screen
        self.mainJB = MainJoueur(self, 0, "Joueur 1")
        w = 250
        h = 250
        self.mainJB.geometry("%dx%d+%d+%d" % (w, h, 10, 0))
        self.mainJR = MainJoueur(self, 2, "Joueur 2")
        self.mainJR.geometry("%dx%d+%d+%d" % (w, h, ws-w-20, 0))
        
        
        # Dit qui doit commencer a jouer
        self.d1=0 # le JB commence
        self.d2=1
    
    def bouger_pionJoueurB(self, event):
            global c #position du pion cliqué dans la grille
            global u # = indice du "1" ds la liste
            c=0
            u=0
            x=event.x ; y=event.y # coordonnées du lieu cliqué
            a=10; b=10 
            for g in range(3):
                b=10
                if a<=y<=a+100: #si le pion est sur la première ligne
                    for q in range(3):
                        if b<=x<=b+100: # si le pion est dans la deuxième colonne
                            u=self.plateau.index(1)
                            self.cliq_trouJB()
                        c+=1 ; b+=125
                else:
                    c+=3
                a+=125 
            
    def cliq_trouJB(self): # Verifie si on clique a l'emplacement libre
        if c==u:
            self.cliq_bon_color()
        elif self.plateau[c]==2: # Le JB a clique sur les pions du JR
            self.cliq_bon_color()
        else:
            self.plateau[c]=1 # le pion cliqué devient le trou
            self.plateau[u]=0 # le trou est comblé par le pion du JB
            self.affiplat()
            self.d2=0 ; self.d1=1
            self.texte.set("C'est au tour du joueur Rouge !")
            self.instruct1.configure(fg = "red")

        
    def bouger_pionJoueurR(self, event):
            global c
            global u # = indice du "1" ds la liste
            c=0
            u=0
            x=event.x ; y=event.y
            a=10; b=10
            for g in range(3):
                b=10
                if a<=y<=a+100:
                    for q in range(3):
                        if b<=x<=b+100:
                            u=self.plateau.index(1)
                            self.cliq_trouJR()
                        c+=1 ; b+=125
                else:
                    c+=3
                a+=125 
    
    
    def cliq_trouJR(self): # Verifie si on clique a l'emplacement libre
            if c==u: #ca veut dire qu'on a clique sur le trou
                self.cliq_bon_color()
            elif self.plateau[c]==0: # Le JR a clique sur pions du JB
                self.cliq_bon_color()
            else:
                self.plateau[c]=1
                self.plateau[u]=2
                self.affiplat()
                self.d1=0 ; self.d2=1
                self.texte.set("C'est au tour du joueur Bleu !")
                self.instruct1.configure(fg = "blue")
    
    def cliq_bon_color(self): # Le joueur ne peut pas deplacer les pions d'un autre
            self.texte.set("VOUS N'AVEZ PAS CLIQUE SUR VOS PIONS ! ! ! ")
            self.instruct1.grid(row=2, column=4, columnspan=5)
            if self.d1==0:
                self.d1=0 ; self.d2=1
            elif self.d2==0 :
                self.d2=0 ; self.d1=1
    

    def a_qui_le_tour (self, event):
        self.affiplat()
        if self.d1==0:
            self.bouger_pionJoueurB(event)
            #comparer_plateau(self.d1, self.plateau, self.cartes)
        elif self.d2==0:
            self.bouger_pionJoueurR(event)
            #comparer_plateau(self.d1, self.plateau, self.cartes)
            
        
        
    def createWidgets(self):
        # Creation du plateau
        self.plat=Canvas(self, width="370",height="370",background="grey")
        self.plat.grid(row=5, column=5, columnspan=15, rowspan=10, padx=10)
        self.plat.bind('<Button-1>', self.a_qui_le_tour)
        self.affiplat()
        
        self.quitButton = Button(self, text='Quit',command=self.destroy) # Use destroy instead of quit
        self.quitButton.grid(row=20, column=20)

    def affiplat(self): # Afficher le plateau
        x, y =10, 10
        for i in range(0,8,3):
            a=i
            x=10
            for j in self.plateau[a:a+3]:
                if j==0:
                    self.plat.create_oval(x,y,x+100,y+100, fill="blue")
                elif j==2:
                    self.plat.create_oval(x,y,x+100,y+100, fill="red")
                else:
                    self.plat.create_oval(x,y,x+100,y+100, fill="black")
                x+=125
            y+=125


class MainJoueur(Toplevel):
    def __init__(self, parent, couleur, nom):
        Toplevel.__init__(self, parent)
        self.parent = parent
        self.couleur = couleur
        self.minsize(250,250)
        self.title(nom)
        self.grid()
        self.cartes = []  # Cartes dans la main du joueur
        self.createWidgets()
        
        
    def createWidgets(self):
        #Affichage d'une carte
        self.afcarte=Canvas(self, width="200",height="200",background="grey")
        self.afficart()
        self.afcarte.grid()
        self.quitButton = Button(self, text='Quit',command=self.destroy) # Use destroy instead of quit
        self.quitButton.grid()

    def afficart(self): # Afficher la carte pour le joueur
        self.cartes.append(tirage(self.parent.cartes))
        self.cartes=self.cartes[0]
        y=10; x=5
        for i in range(0,3):
            x=5
            for j in self.cartes[i]:
                if j==0:
                    self.afcarte.create_oval(x,y,x+35,y+35, fill="green")
                else :
                    self.afcarte.create_oval(x,y,x+35,y+35, fill="black")
                x+=45
            y+=45


app = AppFormino()
app.mainloop()

Module creer_cartes.py

from random import randint

def comparer(L1,L2):
    q=0
    i=0
    for i in range(3):
        
        if L1[i]==L2[i]:
            q+=1
    if q==3:
        q=1
    else:
        q=0
    return q
    
def tourner(L):
    L[0][0],L[0][1],L[0][2],L[1][0],L[1][2],L[2][0],L[2][1],L[2][2] = L[0][2],L[1][2],L[2][2],L[0][1],L[2][1],L[0][0],L[1][0],L[2][0]

def creer_cartes():
    cartes=[] # paquet de cartes au final
    carte=[] 
    
    
    lot=[[0,0,0],[0,0,1],[0,1,0],[1,0,0],[0,1,1],[1,0,1],[1,1,0],[1,1,1]]
    for i in range(8):
        carte=[]
        carte.append(lot[i])
        for j in range(8):
            carte_w=list(carte)
            carte_w.append(lot[j])
            for k in range(8):
                carte_x=list(carte_w)
                carte_x.append(lot[k])
                cartes.append(carte_x)
    
    
    
    cartef=[] 
    for c in cartes:
        n = 0
        for l in c:
            n += sum(l)
        if n == 5:
            cartef.append(c)
    print(cartef)
    
    
    # 
    # for y in range(len(cartes)):
    #     test=[]
    #     test=cartes[y]
    #     n=0
    #     for z in range(3):
    #         tes=test[z]
    #         for a in range(3):
    #             if tes[a]==1:
    #                 n+=1
    #     print(n)
    #     if n==5:
    #         cartef.append(cartes[y])
    
    
    
    cartes=[]
    q=0
    for y in range(len(cartef)):
        tri=[]
        m=0
        tri = cartef[y][:]
        for z in range(y+1,len(cartef)):
            for i in range(4):
                tourner(tri)
                q = comparer(tri,cartef[z])
                if q==1:
                    m+=1
        
        if m==0:
            cartes.append(tri)
    
    return cartes


def tirage(cartes):
    a=(randint(0, len(cartes)))
    b=cartes[a]
    del cartes[a]
    return b


def comparer_plateau(d1, plateau, cartes):
    if d1==0:#joueur bleu
        for i in range(4):
            complat= plateau
            complat[complat.index(2)]=1
        for i in range(4):
            tourner(cartes)
            comparer(complat,cartes)
        if q==1:
            bleu+=1
    else :
        for i in range(4):
            complat= plateau
            complat[complat.index(0)]=1
        for i in range(4):
            tourner(cartes)
            comparer(complat,cartes)
        if q==1:
            rouge+=1
            

if __name__ == "__main__":
    cartes = creer_cartes()
    tirage(cartes)
    comparer_plateau(0)
    

 

[/reveal]