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

Ce site au démarrage

begin process at 2010 03 15 04:26:17

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é :7 747 / 464

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

COMPTEBON.PY par ACONNES

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

LES CONTES DE MONTE CRYPTO par amaury74

UN CLASSIC SOKOBAN par blackgrimly

LE COMPTE EST BON par PythonLin

Toutes les sources de la catégorie Jeux

Sources en rapport avec celle ci

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

PETIT JEU DE MORPION par samurize

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 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 au sujet de Tkinter et le module turtle [ par nico1900 ] from turtle import *forward(120)left(90) color('red') forward(80)bon en fait je voulais tester le module turtle avec l e code ci-d Un Canvas comme dans Tkinter, mais pour wxPython [ par samurize ] Slt tout le monde.   Voila tout est dans le titre (ou a peu pres  ) :   Je suis à la recherche d'un module pouvant s'integrer da Taille de widgets sous Tkinter [ par Uims ] Bonjour, Quelqu"un saurait comment definir la taille d'un widgets sous tkinter??? Exemple: fen 1 = Tk(taille=600) J'espere que je me fait comprend Ouverture d'un fichier windows (avec Tkinter) [ par Uims ] Bonjour, Je travaille sous python et Tkinter et j'aurai voulu savoir comment dire a python de demarrer (comme on clique sur un fichier) une applicati Tkinter et Python [ par Telimektar1er ] Voila j'ai commencé e python il y a une semaine et jusqu à aujourd'hui aucun problème. Mais voilà, je viens de commencer la cr&#23 help, faire un mastermind en python et en tkinter avant le 24 !!! [ par Crick132 ] je suis étudiante en 2ème année, je dois réaliser un mastermind en python avec 8 couleurs et 5 combinaisons possibles.si quelqu'un

Nos sponsors

Derniers Blogs

[RIA SERVICES] MAITRE - DéTAIL ET DOMAINDATASOURCE par Audrey

CSDL FUNCTION par Matthieu MEZIL

LINQ TO ENTITIES par Matthieu MEZIL

FAIRE APPARAITRE L'ONGLET 'DéVELOPPEUR' DANS OFFICE 2010 par neodante

[ASTUCE] PATCH POUR MICROSOFT FORUMS NNTP BRIDGE V1 par pierre

Forum

AFFICHAGE DU MAXIMUM D'UNE LISTE par laloutre78

RE : GESTION D'UNE INTERFACE GRAPHIQUE par lespinx

RE : ET UN SOUCIS (UN DE PLUS...) par notepc

GESTION D'UNE INTERFACE GRAPHIQUE par lilly74

[PROGRAMME PYTHON] CRYPTAGE RSA (CHERCHE CODEUR) par GelH

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Site internet php
Budget : 350€
site formation reiki distance
Budget : 900€
Banniere Flash Drupal
Budget : 150€

Logiciels

Xilisoft Convertisseur Vidéo Ultimate (5.1.39.0305)
XILISOFT CONVERTISSEUR VIDéO ULTIMATE (5.1.39.0305)

Xilisoft Convertisseur Vidéo Ultimate est un outil puissant de conversion vidéo, facile à utilise...

Cliquez pour télécharger Xilisoft Convertisseur Vidéo Ultimate
Xilisoft DVD Ripper Ultimate (5.0.64.0304)
XILISOFT DVD RIPPER ULTIMATE (5.0.64.0304)

Xilisoft DVD Ripper Ultimate est un logiciel excellent pour copier et convertir DVD vers presque ...

Cliquez pour télécharger Xilisoft DVD Ripper Ultimate
Axalot, logiciel de sauvegarde de données en ligne (1.10.108.1)
AXALOT, LOGICIEL DE SAUVEGARDE DE DONNéES EN LIGNE (1.10.108.1)

Perdre tout le contenu de votre disque dur, vous imaginez ? Vos photos, vos musiques, votre compt...

Cliquez pour télécharger Axalot, logiciel de sauvegarde de données en ligne
Rigs of Rods (63.3)
RIGS OF RODS (63.3)

c'est un jeu de multi-simulation camions,autobus voitures, avions, bateaux, hélicoptère avec défo...

Cliquez pour télécharger Rigs of Rods
Konvertor (4.00)
KONVERTOR (4.00)

Le logiciel est un gestionnaire multimedia affichant, jouant et convertissant plus de 2000 format...

Cliquez pour télécharger Konvertor