CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2010 09 04 10:23:37

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

PUISSANCE 4

Information sur la source

Note :

9,00 / 10

Catégorie :Jeux Classé sous :jeu, puissance, canevas, getattr, tkinter Niveau :Débutant Date de création :06/01/2005 Date de mise à jour :16/12/2006 23:19:30 Vu / téléchargé :8 401 / 475

Auteur : lepecheur

Ecrire un message privé

Site perso

Commentaire sur cette source (11)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

Jeu de Puissance 4 pour 2 joueurs avec chute de la pièce dans la colonne et reconnaissance de partie gagnée.

+ Possibilité de continuer la partie pour pouvoir aligner des pièces plusieurs fois

Remarque: Quand on continue une partie déjà gagnée, une pièce ne peut compter que pour une seule ligne de 4.

Source

# -------------------------------------- Jeu de puissance 4 ---------------------------------- #
# Lepecheur #
# -------------------------------------------------------------------------------------------- #
# Interface
from Tkinter import *
# Classe du jeu
class Can(Canvas):
def __init__(self):
#Variables
self.cases = [] # Cases déjà remplies
self.listerouge = [] # Liste des cases rouges
self.listejaune = [] # Liste des cases jaunes
self.dgagnantes = [] # Cases déjà gagnantes et donc ne peuvent plus l'être à nouveau (cf "Continuer")
self.running = 1 # Type de partie en cours
self.couleur = ["Rouges", "Jaunes"]
self.color = ["red", "#EDEF3A"]
#Interface
self.clair = "light blue"
self.fonce = "navy blue"
self.police1 = "Times 17 normal"
self.police2 = "Arial 10 normal"
self.police3 = "Times 15 bold"
self.can = Canvas.__init__(self, width =446, height = 430, bg=self.fonce, bd=0)
self.grid(row = 1, columnspan = 5)
# Joueur en cours
self.joueur = 1
self.create_rectangle(20,400,115,425,fill = self.clair)
self.create_text(35, 405, text ="Joueur :", anchor = NW, fill = self.fonce, font= self.police2)
self.indiccoul = self.create_oval(85, 405, 100, 420, fill = self.color[1])
#Bouton Nouveau Jeu
self.create_rectangle(330,400,420,425,fill=self.clair)
self.create_text(340, 405, text ="Nouveau jeu", anchor = NW, fill = self.fonce, font= self.police2)
#Création des cases
self.ovals = []
for y in range(10, 390, 55):
for x in range(10, 437, 63):
self.ovals.append(self.create_oval(x, y, x + 50, y + 50 , fill= "white"))
#En cas de click
self.bind("<Button-1>", self.click)
# Pour relier à la fin les coordonnées des centres des cases
self.coordscentres = []
# Comptabilisation des suites de pièces
self.rouges, self.jaunes = 0,0
# Dictionnaire de reconnaissance
self.dictionnaire = {}
v = 0
for y in range(10, 390, 55):
for x in range(10, 437, 63):
self.dictionnaire[(x, y, x + 50, y + 50)] = v
v += 1
self.coordscentres.append((x + 25, y + 25))
def click(self,event): #En cas de click
if 330 < event.x and 400 < event.y and event.x < 420 and event.y < 425:
self.new()# =>Nouveau jeu
#Jeu en cours: reconnaissance de la case jouée
else :
if self.running != 0:
for (w, x, y, z) in self.dictionnaire:
if event.x > (w, x, y, z)[0] and event.y >(w, x, y, z)[1] and event.x < (w, x, y, z)[2] and event.y < (w, x, y, z)[3]:
self.colorier(self.dictionnaire[(w, x, y, z)]) # => Jouer
def colorier(self, n, nb=0): #Gère la coloration des cases
if n in self.cases : return # Une case coloriée ne peut plus changer de couleur
if n + 7 not in self.cases and n + 7 < 49: #Si la case en dessous est vide et existe, on essaie d'abord de colorier celle-là
self.colorier(n+7)
else:
#Sinon on colorie celle-ci
self.itemconfigure(self.ovals[n], fill = self.color[self.joueur])
self.cases.append(n)
self.color[self.joueur] == 'red' and self.listerouge.append(n) or self.listejaune.append(n)
self.listejaune = [case for case in self.listejaune if case not in self.listerouge]
self.verif(n)
#Changement de joueur
self.joueur = [0,1][[0,1].index(self.joueur)-1]
self.itemconfigure(self.indiccoul, fill = self.color[self.joueur])
#On regarde toutes les cases sont remplies
self.verificationFinale()
return
def verif(self, n): # Vérifie si la pièce ajoutée s'aligne avec trois autres déjà placées
if self.running == 0 : return
if n in self.listerouge and n+7 in self.listerouge and n+14 in self.listerouge and n+21 in self.listerouge: # D'abbord à la verticale,
# séparément car proximité d'un bord inintéressante
liste=[n, n+7, n+14, n+21] # Pour gérér les parties "plurigagnantes"
if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
return
#idem pour jaunes
if n in self.listejaune and n+7 in self.listejaune and n+14 in self.listejaune and n+21 in self.listejaune:
liste=[n, n+7, n+14, n+21]
if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
return
for x in (1,-6,8):
if n in self.listerouge: # en s'assurant qu'elles ne sont trop près des bords (pour ne pas arriver de l'autre coté du plateau)
if n % 7 != 6 and n+x in self.listerouge:
if n % 7 != 5 and n+ 2*x in self.listerouge:
if n % 7 != 4 and n + 3*x in self.listerouge:
liste = [n, n+x, n+2*x, n+3*x]
if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
return
if n%7 > 0 and (n-x) in self.listerouge:
liste = [n-x,n, n+x, n+2*x]
if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
return
if n%7 > 1 and (n-x) in self.listerouge:
if n%7 > 2 and n-(2*x) in self.listerouge:
liste = [n-2*x, n-x,n, n+x]
if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
return
#Pareil pour les jaunes
if n in self.listejaune:
if n % 7 != 6 and n+x in self.listejaune:
if n % 7 != 5 and n+ 2*x in self.listejaune:
if n % 7 != 4 and n + 3*x in self.listejaune:
liste = [n, n+x, n+2*x, n+3*x]
if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
return
if n%7 > 0 and (n-x) in self.listejaune:
liste = [n-x,n, n+x, n+2*x]
if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
return
if n%7 > 1 and (n-x) in self.listejaune:
if n%7 > 2 and n-(2*x) in self.listejaune:
liste = [n-2*x, n-x,n, n+x]
if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
return
for x in (-1,6,-8):
if n in self.listejaune:
if n % 7 != 0 and (n+x) in self.listejaune:
if n % 7 != 1 and n+(2*x) in self.listejaune:
if n % 7 != 2 and n + (3*x) in self.listejaune:
liste = [n, n+x, n+2*x, n+3*x]
if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
return
if n%7 <6 and (n-x) in self.listejaune:
liste = [n-x,n, n+x, n+2*x]
if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
return
if n%7 < 5 and (n-x) in self.listejaune:
if n%7 < 4 and n-(2*x) in self.listejaune:
liste = [n-2*x, n-x,n, n+x]
if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
return
if n in self.listerouge:
if n % 7 != 0 and (n+x) in self.listerouge:
if n % 7 != 1 and n+(2*x) in self.listerouge:
if n % 7 != 2 and n + (3*x) in self.listerouge:
liste = [n, n+x, n+2*x, n+3*x]
if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
return
if n%7 <6 and (n-x) in self.listerouge:
liste = [n-x,n, n+x, n+2*x]
if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
return
if n%7 < 5 and (n-x) in self.listerouge:
if n%7 < 4 and n-(2*x) in self.listerouge:
liste = [n-2*x, n-x,n, n+x]
if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
return
def verificationFinale(self): # Lorsque toutes les cases sont remplies
if len(self.cases)==49: # On comptabilise les points
typ =self.plus() # Type de partie gagnée
if typ[1]==0:
self.texte2 = Label(fen, text = "Les " + typ[0] + " ont définitivement gagné !", bg= self.fonce,
fg=self.clair, font=self.police1)
self.texte2.grid()
elif typ[1]==1:
self.texte2 = Label(fen, text = "Les " + typ[0] + " ont gagné les premiers!", bg= self.fonce,
fg=self.clair, font=self.police1)
self.texte2.grid()
else:
self.texte2 = Label(fen, text = typ[0], bg= self.fonce, fg=self.clair, font=self.police1)
self.texte2.grid(padx=110)
def win(self, qui, p, d): # Partie gagnée
#Marquage des pièces gagnantes
self.create_line(self.coordscentres[p][0], self.coordscentres[p][1],
self.coordscentres[d][0], self.coordscentres[d][1],
fill="blue")
if qui=="rouges" : self.rouges += 1 #Comptabilisation des suites
if qui=="jaunes" : self.jaunes += 1
if self.running == 3:
self.pRouges.config(text = "Rouges : " + str(self.rouges))
self.pJaunes.config(text = "Jaunes : " + str(self.jaunes))
return
#Affichage des scores
self.qui = qui
self.texte = Label(fen, text="Les %s ont gagné !" % (qui), bg= self.fonce, fg=self.clair, font=self.police1)
self.texte.grid()
self.running = 0
#Proposition de continuer
self.BtnContinuer = Button(fen, text=" Continuer cette partie", bd= 0, bg=self.fonce, fg=self.clair,
font=self.police3, command=self.continuer)
self.BtnContinuer.grid(padx=120)
def continuer(self): # Si on choisi de poursuivre la même partie (déjà gagnée par un joueur)
self.running = 3
# Affichage des scores
self.pRouges = Label(fen, text = "Rouges : %s" %(str(self.rouges)),
font=self.police3, bg=self.fonce, fg=self.clair)
self.pJaunes = Label(fen, text = "Jaunes : %s" %( str(self.jaunes)),
font=self.police3, bg=self.fonce, fg=self.clair)
self.BtnContinuer.destroy()
self.texte.destroy()
self.pRouges.grid(padx=160)
self.pJaunes.grid(padx=160)
def gagnantes(self, liste=[]): # On vérifie que les pièces ne sont pas encore gagnantes, et on les ajoute dans la liste si elles le deviennent
for i in liste:
if i in self.dgagnantes: return 0
for n in liste:
self.dgagnantes.append(n)
return 1
def plus(self): # Donner le résultat final
if self.rouges > self.jaunes : return "Rouges",0
if self.jaunes > self.rouges : return "Jaunes",0
if self.rouges != 0 : return self.qui, 1 # En cas d'égalité, le premier à avoir aligné ses pièces gagne
return "Personne n'a gagné", 2 #Sinon, tous deux ont perdu
def new(self):# Nouveau Jeu
# Opérations non certaines
try:
self.BtnContinuer.destroy()
except:
pass
try:
self.texte.destroy()
except:
pass
try:
self.texte2.destroy()
except:
pass
try:
self.pRouges.destroy()
except:
pass
try:
self.pJaunes.destroy()
except:
pass
# Opérations qui le sont
self.destroy()
self.__init__()
if __name__ == "__main__" :
fen = Tk()
fen.title("Puissance 4")
fen.config(bg="navy blue")
lecan = Can()
fen.mainloop()

# -------------------------------------- Jeu de puissance 4 ---------------------------------- # 
#           Lepecheur                                                                          #
# -------------------------------------------------------------------------------------------- # 

    # Interface
    
from Tkinter import *

    # Classe du jeu

class Can(Canvas):


    def __init__(self):
        
            #Variables
        
        self.cases      = [] # Cases déjà remplies
        self.listerouge = [] # Liste des cases rouges
        self.listejaune = [] # Liste des cases jaunes
        self.dgagnantes = [] # Cases déjà gagnantes et donc ne peuvent plus l'être à nouveau (cf "Continuer")
        self.running    = 1  # Type de partie en cours
        self.couleur    = ["Rouges", "Jaunes"]
        self.color      = ["red", "#EDEF3A"]
        
            #Interface
        
        self.clair      = "light blue"
        self.fonce      = "navy blue"
        self.police1    = "Times 17 normal"
        self.police2    = "Arial 10 normal"
        self.police3    = "Times 15 bold"
        self.can        = Canvas.__init__(self, width =446, height = 430, bg=self.fonce, bd=0)
        
        self.grid(row = 1, columnspan = 5)

            # Joueur en cours
        
        self.joueur = 1
        self.create_rectangle(20,400,115,425,fill = self.clair)
        self.create_text(35, 405, text ="Joueur :", anchor = NW, fill = self.fonce, font= self.police2)
        self.indiccoul = self.create_oval(85, 405, 100, 420, fill = self.color[1])
        
            #Bouton Nouveau Jeu
        
        self.create_rectangle(330,400,420,425,fill=self.clair)
        self.create_text(340, 405, text ="Nouveau jeu", anchor = NW, fill = self.fonce, font= self.police2)
        
            #Création des cases
        
        self.ovals = []
        for y in range(10, 390, 55):
            for x in range(10, 437, 63):
                self.ovals.append(self.create_oval(x, y, x + 50, y + 50 , fill= "white"))
                
            #En cas de click
                
        self.bind("<Button-1>", self.click)
        
            # Pour relier à la fin les coordonnées des centres des cases
        
        self.coordscentres = []
        
            # Comptabilisation des suites de pièces
        
        self.rouges, self.jaunes = 0,0
        
            # Dictionnaire de reconnaissance
        
        self.dictionnaire = {}
        v = 0
        for y in range(10, 390, 55):
            for x in range(10, 437, 63):
                self.dictionnaire[(x, y, x + 50, y + 50)] = v
                v += 1
                self.coordscentres.append((x + 25, y + 25))


    def click(self,event): #En cas de click
        if 330 < event.x and 400 < event.y and event.x < 420 and event.y < 425:
            self.new()# =>Nouveau jeu
            
            #Jeu en cours: reconnaissance de la case jouée
            
        else :
            if self.running != 0:
                for (w, x, y, z) in self.dictionnaire:
                    if event.x > (w, x, y, z)[0] and event.y >(w, x, y, z)[1] and event.x < (w, x, y, z)[2] and event.y < (w, x, y, z)[3]:
                        self.colorier(self.dictionnaire[(w, x, y, z)]) # => Jouer

                
    def colorier(self, n, nb=0): #Gère la coloration des cases
        
        if n in self.cases : return # Une case coloriée ne peut plus changer de couleur
           
        if n + 7 not in self.cases and n + 7 < 49: #Si la case en dessous est vide et existe, on essaie d'abord de colorier celle-là
            self.colorier(n+7)
            
        else:
            
                #Sinon on colorie celle-ci
            
            self.itemconfigure(self.ovals[n], fill = self.color[self.joueur])
            self.cases.append(n)
            self.color[self.joueur] == 'red' and self.listerouge.append(n) or self.listejaune.append(n)
            self.listejaune = [case for case in self.listejaune if case not in self.listerouge]
            self.verif(n)
            
                #Changement de joueur
            
            self.joueur = [0,1][[0,1].index(self.joueur)-1]
            self.itemconfigure(self.indiccoul, fill = self.color[self.joueur])

                #On regarde toutes les cases sont remplies
            
            self.verificationFinale()        
        
        return

    
    def verif(self, n): # Vérifie si la pièce ajoutée s'aligne avec trois autres déjà placées
        
        if self.running == 0 : return
        
        if n in self.listerouge and n+7  in self.listerouge and n+14  in self.listerouge and n+21 in self.listerouge: # D'abbord à la verticale,
                                                                                            # séparément car proximité d'un bord inintéressante
            liste=[n, n+7, n+14, n+21] # Pour gérér les parties "plurigagnantes"
            if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
            return
        
            #idem pour jaunes
        
        if n in self.listejaune and n+7 in self.listejaune and n+14 in self.listejaune and n+21 in self.listejaune:
            liste=[n, n+7, n+14, n+21]
            if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
            return
        
        for x in (1,-6,8):
            
            if n in self.listerouge: # en s'assurant qu'elles ne sont trop près des bords (pour ne pas arriver de l'autre coté du plateau)
                if n % 7 != 6 and n+x in self.listerouge:
                    if n % 7 != 5 and n+ 2*x in self.listerouge:
                        if n % 7 != 4 and n + 3*x in self.listerouge:
                            liste = [n, n+x, n+2*x, n+3*x]
                            if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
                            return
                        if n%7 > 0 and (n-x) in self.listerouge:
                            liste = [n-x,n, n+x, n+2*x]
                            if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
                            return
                    if n%7 > 1 and (n-x) in self.listerouge:
                        if n%7 > 2 and n-(2*x) in self.listerouge:
                            liste = [n-2*x, n-x,n, n+x]
                            if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
                            return
                        
                #Pareil pour les jaunes
                        
            if n in self.listejaune:
                if n % 7 != 6 and n+x in self.listejaune:
                    if n % 7 != 5 and n+ 2*x in self.listejaune:
                        if n % 7 != 4 and n + 3*x in self.listejaune:
                            liste = [n, n+x, n+2*x, n+3*x]
                            if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
                            return
                        if n%7 > 0 and (n-x) in self.listejaune:
                            liste = [n-x,n, n+x, n+2*x]
                            if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
                            return
                    if n%7 > 1 and (n-x) in self.listejaune:
                        if n%7 > 2 and n-(2*x) in self.listejaune:
                            liste = [n-2*x, n-x,n, n+x]
                            if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
                            return
                        
        
        for x in (-1,6,-8):
            
            if n in self.listejaune:
                if n % 7 != 0 and (n+x) in self.listejaune:
                    if n % 7 != 1 and n+(2*x) in self.listejaune:
                        if n % 7 != 2 and n + (3*x) in self.listejaune:
                            liste = [n, n+x, n+2*x, n+3*x]
                            if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
                            return
                        if n%7 <6 and (n-x) in self.listejaune:
                            liste = [n-x,n, n+x, n+2*x]
                            if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
                            return
                    if n%7 < 5 and (n-x) in self.listejaune:
                        if n%7 < 4 and n-(2*x) in self.listejaune:
                            liste = [n-2*x, n-x,n, n+x]
                            if self.gagnantes(liste) : self.win("jaunes", liste[0],liste[3])
                            return
                        
            if n in self.listerouge:
                if n % 7 != 0 and (n+x) in self.listerouge:
                    if n % 7 != 1 and n+(2*x) in self.listerouge:
                        if n % 7 != 2 and n + (3*x) in self.listerouge:
                            liste = [n, n+x, n+2*x, n+3*x]
                            if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
                            return
                        if n%7 <6 and (n-x) in self.listerouge:
                            liste = [n-x,n, n+x, n+2*x]
                            if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
                            return
                    if n%7 < 5 and (n-x) in self.listerouge:
                        if n%7 < 4 and n-(2*x) in self.listerouge:
                            liste = [n-2*x, n-x,n, n+x]
                            if self.gagnantes(liste) : self.win("rouges", liste[0],liste[3])
                            return


    def verificationFinale(self): # Lorsque toutes les cases sont remplies
        
        if len(self.cases)==49: # On comptabilise les points
            typ =self.plus() # Type de partie gagnée
            if typ[1]==0:
                self.texte2 = Label(fen, text = "Les " + typ[0] + " ont définitivement gagné !", bg= self.fonce,
                                    fg=self.clair, font=self.police1)
                self.texte2.grid()
            elif typ[1]==1:
                self.texte2 = Label(fen, text = "Les " + typ[0] + " ont gagné les premiers!", bg= self.fonce,
                                    fg=self.clair, font=self.police1)
                self.texte2.grid()
            else:
                self.texte2 = Label(fen, text = typ[0], bg= self.fonce, fg=self.clair, font=self.police1)
                self.texte2.grid(padx=110)

                
    def win(self, qui, p, d): # Partie gagnée
        
            #Marquage des pièces gagnantes
        
        self.create_line(self.coordscentres[p][0], self.coordscentres[p][1],
                         self.coordscentres[d][0], self.coordscentres[d][1],
                         fill="blue")

        if qui=="rouges" : self.rouges += 1 #Comptabilisation des suites
        if qui=="jaunes" : self.jaunes += 1

        if self.running == 3:
            self.pRouges.config(text = "Rouges : " + str(self.rouges))
            self.pJaunes.config(text = "Jaunes : " + str(self.jaunes))
            return

            #Affichage des scores
        
        self.qui = qui
        self.texte = Label(fen, text="Les %s ont gagné !" % (qui), bg= self.fonce, fg=self.clair, font=self.police1)
        self.texte.grid()
        self.running = 0
        
            #Proposition de continuer
        
        self.BtnContinuer = Button(fen, text=" Continuer cette partie", bd= 0, bg=self.fonce, fg=self.clair,
                                   font=self.police3, command=self.continuer)
        self.BtnContinuer.grid(padx=120)

        
    def continuer(self): # Si on choisi de poursuivre la même partie (déjà gagnée par un joueur)
        
        self.running = 3
        
            # Affichage des scores
            
        self.pRouges = Label(fen, text = "Rouges : %s" %(str(self.rouges)),
                             font=self.police3, bg=self.fonce, fg=self.clair)
        self.pJaunes = Label(fen, text = "Jaunes : %s" %( str(self.jaunes)),
                             font=self.police3, bg=self.fonce, fg=self.clair)

        self.BtnContinuer.destroy()
        self.texte.destroy()
        self.pRouges.grid(padx=160)
        self.pJaunes.grid(padx=160)

        
    def gagnantes(self, liste=[]): # On vérifie que les pièces ne sont pas encore gagnantes, et on les ajoute dans la liste si elles le deviennent

        for i in liste:
            if i in self.dgagnantes: return 0
        
        for n in liste:
            self.dgagnantes.append(n)
            
        return 1

    
    def plus(self): # Donner le résultat final
        
        if self.rouges > self.jaunes    : return "Rouges",0
        if self.jaunes > self.rouges    : return "Jaunes",0
        if self.rouges != 0             : return self.qui, 1 # En cas d'égalité, le premier à avoir aligné ses pièces gagne

        return "Personne n'a gagné", 2 #Sinon, tous deux ont perdu


    def new(self):# Nouveau Jeu
        
            # Opérations non certaines
        
        try:
            self.BtnContinuer.destroy()
        except:
            pass
        try:
            self.texte.destroy()
        except:
            pass
        try:
            self.texte2.destroy()
        except:
            pass
        try:
            self.pRouges.destroy()
        except:	
            pass
        try:
            self.pJaunes.destroy()
        except:
            pass
            
            # Opérations qui le sont
            
        self.destroy()
        self.__init__()

	
if __name__ ==	"__main__" :
    fen = Tk()
    fen.title("Puissance 4")
    fen.config(bg="navy blue")
    lecan = Can()
    fen.mainloop()

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

P4.py 14 020 octets

Télécharger le zip

Historique

06 janvier 2005 19:13:55 :: Ajout de capture d'écran
06 janvier 2005 21:23:49 :: Ajout d'un zip (faciliter le download?)
09 janvier 2005 11:53:29 :: Voilà j'avais parlé d'une ligne rouge reliant les pièces gagnantes, voilà qui est fait, mais comme j'ai aussi réduit la taille de la fenêtre, je laisse les deux codes, pour pouvoir comparer* Le zip contient également les deux versions
07 mai 2005 09:41:53 :: Elargissement du jeu à sept colonnes.
10 mai 2005 20:29:28 :: Correction d'un bug de reconnaissance
11 mai 2005 21:37:46 :: Plein de choses ! : Alongement du jeu à sept rangées Correction de la reconnaissance Ajout du 'mode' continuer après avoir une combinaison gagnante Commentaires :p [Version 2.5] Je n'arrive juste pas à enlever la bordure grrr, quelqu'un peut m'aider?
20 décembre 2005 11:05:00 :: - Commentaires - Changements mineurs
24 juillet 2006 15:24:53 :: Version 2.8 : légères améliorations graphiques
16 décembre 2006 23:19:30 :: remplacement de certaines lignes ==> plus compact + Mise en forme et commentaires

Sources du même auteur

DÉCALER LES TEMPS D'AFFICHAGE DES SOUS TITRES

INFORMATIONS SUR UN ISBN DEPUIS INTERNET

LOTO

Toutes les sources de lepecheur

Sources de la même categorie

CASSE BRIQUE par elnabo

COMPTEBON.PY par ACONNES

JEU DU SERPENT ////\\\\ SNAKE par elnabo

LES CONTES DE MONTE CRYPTO par amaury74

UN CLASSIC SOKOBAN par blackgrimly

Toutes les sources de la catégorie Jeux

Sources en rapport avec celle ci

CASSE BRIQUE par elnabo

CALCULATRICE SIMPLICISTE SOUS TKINTER par elnabo

LES CONTES DE MONTE CRYPTO par amaury74

TIC-TAC-TOE (THÉORIQUEMENT) IMBATTABLE par dustwind

JEU DE DAME par wizad

Commentaires et avis

Commentaire de lepecheur le 06/01/2005 20:50:54

Allez-y, déchaînez-vous, mon n'amour propre n'en sera pas (trop) altéré ;)

Commentaire de arnohoho le 03/05/2005 00:36:41

très bien sauf un tuc si je ne m'abuse le puissance 4 serai plutot de 6 de largeur ou en tout cas je trouve que 5 de largeur (horizontal pluot)
ça limite les coups possible

sinon c'est cool pas de bug détecté sinon je dirai (lol)
perso j'apprend a piene le python je cherche des bon tuto même si je devrai plutot finr celui que j'ai avant d'en chercher un autre...

en tout cas ce genre de sources me rassure quand au capaciter de la prog en python et la complexité "qu'il pourai avoir" essaie de faire ça en basique tous a pour quelque longues longues heures!

aller a plus

arnohoho

vive linux vive l'open sources vive les bugs!

Commentaire de lepecheur le 03/05/2005 07:42:52

Merci du commentaire, dès que j'ai du temps je vais l'élargir.

Commentaire de alkove le 06/05/2005 06:21:52

7 trous de largeur en fait ^^

ca va devenir limite d'utiliser la méthode de lister toute les combinaisons gagnantes, pour voir si un joueur a gagné

sinon beau travail !

Commentaire de lepecheur le 06/05/2005 20:57:41

Je vais essayer avec une méthode d'orientation de l'alignement des pièces et voir ce que ça peut donner.
Merci pour la largeur.

Commentaire de lepecheur le 07/05/2005 09:43:03

Voilà c'est fait !

Commentaire de arnohoho le 10/05/2005 12:44:49

pas mal juste j'ai trouver un bug il donner le rouge gagnant alors qu'il ne l'était pas je n'arrive pas à trouver quand cela le fait exactenemt mais j'ai pri soin de faire une capture d'écran quand cela à buguer

pour d'ecription 1 rouge avant derniere ligne du haut (pour les y) et 2 pour l'horizontal soit y = 4 , x =2
et il fait le lien avec un autre rouge ce trouvant y= 5 , x=6........

y a donc un bug puisse que il sont a 5 d'égart et en plus pas sur la même ligne bon si tu veux un d'escription
plus clair je t'envoie la capture (à mon avis cela t'aidera mieux)
sinon c'est trés bien
encouragement a plus
arnohoho

Commentaire de lepecheur le 10/05/2005 20:24:35

Voilà c'est corrigé (je pense)

Commentaire de Idefix57 le 29/04/2006 19:14:12

Tres beau travail et Merci .

On apprend bien sur ce forum .

Idefix57

Commentaire de xeolin le 15/06/2006 15:30:34

la source est simpas mais je me rapelle que il y avait un boeug mais je ne sais pu lequel...

8/10

Commentaire de lepecheur le 19/07/2006 22:40:44

Merci pour vos commentaire.

Si quelqu'un retombe sur un bug, cela me ferait plaisir de tenter de perfectionner ce jeu.N'hésitez donc pas à me le dire ^^
Merci

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

Réalisation d'un plus ou moins sur Tkinter [ par kuritsu ] Bonsoir tout le monde, et je vous souhaite la bonne année à tous par la même occasion. Je viens de me mettre à la programmation sous Python, et j'avo Tkinter [ par camoyce ] bonjour a tous je m intéresse depuis peu a la programmation en me renseignant j ai découvert python qui je l avoue est très intéressent ma question p Changement de couleur [ par elnabo ] Bonjour, j'essaye de faire un petit script qui permet de choisir une couleur avec Tkinter en se servant d'un widget Scale. Seulement, je ne crois pas Problème avec un widget Canvas [ par pl29 ] Bonjour, Un problème pour afficher une image dans un widget Canvas : Je voudrais que l'image apparaisse dans le Canvas suite au clic sur un bouton p créer une simulation d'un jeu de cartes [ par jimux06 ] # simulation d'un tirage de cartes # dans la version 3.1.x # afficher la date du jour (jj-mm-aaaa) et l'heure (hh:mm:ss), avant chaque jeu # utiliser Tkinter, non déplacement d'un ballon incompréhensible [ par ubranov ] Bonjour, Je cherche simplement à animer un petit ballon dans une fenêtre grâce au module Tkinter. Je n'arrive vraiment pas à comprendre en quoi le co urllib2 et interface graphique [ par rezuz ] bonjour à tous. aprés avoir eu de nombreux "problemme" avec les 72 minutes de limitation vidéo de MEGAVIDEO, j'ai décidé de faire un programme qui se scrollbar dans scrollbox avec TKinter [ par MHI ] Est-ce que quelqu'un sait comment ajouter les scrollbar à une scrollbox :J'ai essayé ceci :lstFile = Tkinter.Listbox(frmMain)lstFile.place(x = 20, y = checkButton avec TKinter [ par MHI ] comment faire pour tester si un checkButton est coché ? Probleme avec TKinter [ par titasse ] Bonjour, je debute en python. J'ai un probleme lorsque je veux importer TKinter avec la commande from TKinter import * j'ai le message suivant : Imp

Nos sponsors

Derniers Blogs

ENUMERABLECOLLECTION par Matthieu MEZIL

[HS] CHROME 6 + MOI = COUP DE GUEULE ! par JeremyJeanson

[WP7] UTILISER UN WRAPPANEL DANS UNE APPLICATION WINDOWS PHONE 7 par Audrey

[WP7] BESOIN D'AVOIR DES DONNéES EN CACHE par Nicolas

[TFS] COMMENT FORCER LA SAISIE D'UN AREA OU ITERATION par cyril

Forum

ENREGISTRER UN FICHIER .TXT AVEC CARACTèRES ACCENTUéS par Mic92

RE : URLLIB2 ET INTERFACE GRAPHIQUE par aera group

RE : PYTHON 3.0 par aera group

RE : PYTHON 3.0 par xeolin

RE : PYTHON 3.0 par aera group

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Recherche consultant NET C Sharp
Budget : 12 000€
Integration parametrage formation Question writer 4 Hot potatoes
Budget : 300€
URGENT Creation site vitrine Joomla Laboratoire protheses dentaires
Budget : 600€

Logiciels

Bureau de Gestion - ERP Devis Facturation (2.02)
BUREAU DE GESTION - ERP DEVIS FACTURATION (2.02)

- Version gratuite du 10/06/2010 Le Bureau de Gestion est un logiciel dédié à la gestion de l'en...

Cliquez pour télécharger Bureau de Gestion - ERP Devis Facturation
sDEVIS-FACTURES vlPRO (3.8.0)
SDEVIS-FACTURES VLPRO (3.8.0)

sDEVIS-FACTURES vlPRO a été mis au point pour permettre besoins des particuliers, créateurs, entr...

Cliquez pour télécharger sDEVIS-FACTURES vlPRO
LettresFaciles (5.6.0)
LETTRESFACILES (5.6.0)

LettresFaciles est un logiciel facilitant la création et la rédaction de lettres types. Son inte...

Cliquez pour télécharger LettresFaciles
MyPlanning 2010 (5.6.0)
MYPLANNING 2010 (5.6.0)

MyPlanning 2010 permet de créer des plannings sous la représentation de diagrammes. Plannings pré...

Cliquez pour télécharger MyPlanning 2010
Emicsoft Mac DVD en iPad Convertisseur (3.1.16)
EMICSOFT MAC DVD EN IPAD CONVERTISSEUR (3.1.16)

Emicsoft Mac DVD en iPad Convertisseur, logiciel professionnel de convertir les fichiers DVD en i...

Cliquez pour télécharger Emicsoft Mac DVD en iPad Convertisseur