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

Ce site au démarrage

begin process at 2012 02 05 01:58:51

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é :10 162 / 528

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

QUESTIONNAIRE par darkanghel91

JEU DU PLUS OU MOINS par Iphonemax

TAQUIN 4*4 par fredericfabry

ASTRE2.0 CASSE-BRIQUES par Mints

JEU DU NOMBRE MYSTERE EN PYTHON par messorama

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 Positionner le curseur dans un widget text (Tkinter) [ par Souslannodenime ] Voila, j'ai crée un client pour un système de chat via socket(un genre de irc-like) et j'aimer savoir comment faire pour que le widget text(qui me se Tkinter [ par williammalavelle ] Bonjour à tous, Question stupide : je débute sous Python et sous Tkinter. J'ai un script python que je souhaite lié à Tkinter (j'ai préparé les fenêt Selecteur de couleur [ par PunkFloyd91 ] Bonjour, je suis débutant et essais de créer un petit logiciel de traitement d'images du style "paint" en python 3 avec la 'library' de tkinter. Je ch

Nos sponsors

Derniers Blogs

CSS CONTENT STATE SELECTORS (PERSONNAL DRAFT) par FREMYCOMPANY

MBA : POURQUOI FAIRE ET COMMENT LE CHOISIR ? par ROMELARD Fabrice

Y'A DES ERREURS QUI PEUVENT RENDRE LE DéVELOPPEUR VIOLENT par Aleks

[HYPER-V 3] PRéSENTATION DES COMMANDLETS POWERSHELL par Pierrick CATRO-BROUILLET

IIS7 - COMPRESSION GZIP par cyril

Forum

PYVISA PROBLèME par sandrine44

RE : TUTORIAUX PYTHON par MeTeC1

RE : MESSAGE SUR RESEAU par Guillamue06

RE : CRéER UN PETIT JEU DE SIMULATION POLITIQUE par Guillamue06

MESSAGE SUR RESEAU par sanhoua

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Cherche referenceur astucieux
Budget : 1 500€
Recherche expert advisor sous mql4 hedging
Budget : 200€
Creation boutique en ligne iphone- android - Republication.
Budget : 4 000€

Logiciels

Easy-Planning (1.0.0.1)
EASY-PLANNING (1.0.0.1)

Basé sur les mêmes principes que MyPlanning, Easy-Planning permet de créer des plannings sous la ...

Cliquez pour télécharger Easy-Planning
Academy System (17.1.3.0)
ACADEMY SYSTEM (17.1.3.0)

Logiciel de gestion des établissements. - élèves/étudiants (inscription, dossier, absence...) -...

Cliquez pour télécharger Academy System
COLLECTOR PLUS (3.00B)
COLLECTOR PLUS (3.00B)

COLLECTOR PLUS version 3.00B est un logiciel utilisant une base de données alimentée par : - L...

Cliquez pour télécharger COLLECTOR PLUS
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)

PONAMEDIA TV DEVIENS HELLLOOO FLASH LA TV SUR VOTRE ORDINATEUR. Toute une plateforme Multi...

Cliquez pour télécharger PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO
LettresFaciles 2011 (8.0.0.1)
LETTRESFACILES 2011 (8.0.0.1)

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

Cliquez pour télécharger LettresFaciles 2011