Tristan 4 months ago
parent d2a5d390fd
commit 5407c7ec92
  1. BIN
      BombParty-15-03-22.zip
  2. 46
      before/bombparty_avant_adaptation.py
  3. 169
      before/bomparty_avant_gui.py
  4. 44
      bombgui.py
  5. 274
      bombparty_gui.py
  6. 30
      bomparty.py
  7. 0
      old/compteur.py
  8. 0
      old/joueur.py

Binary file not shown.

@ -0,0 +1,46 @@
from tkinter import *
def salut(mot):
print(mot)
zonedetexte.delete(0,END)
def hide(truc):
truc.pack_forget()
mot_affiche.configure(text="")
zonedetexte.configure(state="normal")
fenetre = Tk()
fenetre.title('BombParty')
fenetre.geometry('720x480')
fenetre.resizable(False, False)
fenetre.config(background='white')
#canvas = Canvas(fenetre, width=1280, height=720, background='white')
zonedetexte = Entry(fenetre, justify='center')
zonedetexte.bind("<Return>",(lambda event: salut(zonedetexte.get())))
mot_affiche = Label(fenetre, text="Cliquer sur commencer, pour lancer la partie !",width=720, anchor=CENTER)
mot_affiche.grid(sticky="s")
debut = Button(fenetre, text="Commencer", command = print("salut"))
debut.configure(command=lambda: hide(debut))
#mot_affiche.place(x=fenetre.winfo_width()/2, y=fenetre.winfo_height()/2, anchor="center")
'''
canvas.create_rectangle(
255, 379, 464, 437,
outline="#fb0",
fill="#fb0"
)
'''
## Debug
def pointeur1(event) :
x = event.x
y = event.y
print(x,y,1)
fenetre.bind("<Button-1>",pointeur1)
## Debug
mot_affiche.pack()
zonedetexte.pack(pady=30)
zonedetexte.configure(state="disabled")
debut.pack(pady=5)
#canvas.pack()
fenetre.mainloop()

@ -0,0 +1,169 @@
# Jeu de BombParty
from secrets import token_bytes
import time
import random as rd
import os
#Nettoyage
clearConsole = lambda: os.system('cls' if os.name in ('nt', 'dos') else 'clear')
clearConsole()
#On importe les mots
with open("mots.txt", "r",encoding="utf8") as motsfichier:
mots = motsfichier.readlines()
#On retire \n de notre liste de mots
for i in range(len(mots)):
mots[i]=mots[i].replace("\n","")
#On importe les syllabes
with open("syllabes.txt", "r",encoding="utf8") as syllabesfichier:
syllabes = syllabesfichier.readlines()
#On retire \n de notre liste de syllabes
for i in range(len(syllabes)):
syllabes[i]=syllabes[i].replace("\n","")
#Tirage au sort de la syllabe
def tirage_syllabe():
syllabe=rd.choice(syllabes)
return syllabe
#Demander au joueur un mot
def demander_mot(syllabe_a_trouver):
mot=input(f'''Vous devez trouver un mot contenant la syllabe : {syllabe_a_trouver}
Votre proposition : ''')
return mot
#Vérifier si la syllabe est bien dans le mot
def mots_et_syllabes_valable(syllabe_a_trouver,mot_du_joueur):
if syllabe_a_trouver in mot_du_joueur:
return True
else:
print("""
Ce mot ne possède pas la syllabe requise.""")
return False
#Rechercher le mot dans notre base de données de mots, puis vérifier sa syllabe
def comparer_mot(mot,syllabe_a_trouver):
if mot in mots:
return mots_et_syllabes_valable(syllabe_a_trouver,mot)
else:
print("""
Ce mot n'existe pas dans notre base de données.""")
return False
# ---------------- Arthur ---------------------- #
#Détermination du nombre de joueurs
def demander_nb_joueurs():
resultat=input("""Combien de joueurs ?
Votre proposition : """)
return int(resultat)
#On vérifie si la valeur entrée fait parties du nombre de joueur compatible au jeu
def check_bon_nb_joueurs(nb):
O=[1,2,3,4,5,6] # Nombre de joueurs possibles
if nb in O:
print("La partie se jouera donc avec",nb,"joueur(s)")
time.sleep(2)
return nb
else:
return check_bon_nb_joueurs(demander_nb_joueurs())
#On demande le nombre de joueurs pour notre partie
nbjoueurs=int(check_bon_nb_joueurs(demander_nb_joueurs))
#On crée nos variables de points nécéssaires à notre jeu
#Cette liste contiens nos points de joueurs. Chaque 1 correspond à un joueur. Joueur 2 = pj[0]
pj=[0,1,1,1,1,1,1]
#A quel joueur est-ce le tour ?
tour_du_joueur=0
#On change de tour
def tour_suivant(tour):
tour=tour+1
return tour
#Une partie est-elle en cours ?
partie_en_cours=1
#
# Le code du jeu
#
def jeu(tour_du_joueur,pj):
clearConsole()
print("Joueur",tour_du_joueur,", c'est votre tour !")
print("--------------------------")
syllabe_a_trouver=tirage_syllabe()
mot_du_joueur=demander_mot(syllabe_a_trouver)
if comparer_mot(mot_du_joueur,syllabe_a_trouver)==True:
print("")
print("Bravo, vous avez trouvé un mot !! Vous gagnez 1 point.")
pj=pj+1
print("")
print("Vous possèdez maintenant",pj,"points !")
print("---------------------------")
time.sleep(5)
return pj
print("")
print("Vous ne gagnez donc aucun point !")
print("-------------------------")
time.sleep(3)
return pj
#Script de notre partie de jeu
while partie_en_cours==1:
#Si tout le monde a fini de jouer, on retourne au joueur 1
if tour_du_joueur>nbjoueurs:
tour_du_joueur=1
#Si le jeu n'a toujours pas commencé, on commence par le joueur 1
elif tour_du_joueur==0:
print("Début de la partie !")
tour_du_joueur=1
if tour_du_joueur==1:
#C'est au joueur 1
print("")
pj[1] = jeu(tour_du_joueur,pj[1])
tour_du_joueur = tour_suivant(tour_du_joueur)
elif tour_du_joueur==2:
#C'est au joueur 2
print("")
pj[2] = jeu(tour_du_joueur,pj[2])
tour_du_joueur = tour_suivant(tour_du_joueur)
elif tour_du_joueur==3:
#C'est au joueur 3
print("")
pj[3] = jeu(tour_du_joueur,pj[3])
tour_du_joueur = tour_suivant(tour_du_joueur)
elif tour_du_joueur==4:
#C'est au joueur 4
print("")
pj[4] = jeu(tour_du_joueur,pj[4])
tour_du_joueur = tour_suivant(tour_du_joueur)
elif tour_du_joueur==5:
#C'est au joueur 5
print("")
pj[5] = jeu(tour_du_joueur,pj[5])
tour_du_joueur = tour_suivant(tour_du_joueur)
elif tour_du_joueur==6:
#C'est au joueur 6
print("")
pj[6] = jeu(tour_du_joueur,pj[6])
tour_du_joueur = tour_suivant(tour_du_joueur)
'''
Idée future :
- Contrairement au BombParty originel, il faut qu'on donne des points au joueurs, et non pas qu'on leur enlève des vies.
- En fonction du temps de réponse au mot, le joueur gagne plus ou moins de points
- Faire le système de récompenses par lettres sur le côté (comme le vrai)
- Faire un système de joker
- Faire un système de récompenses quand on a utilisé toutes les lettres
- Faire un joli countdown avec .......... pour les delays
'''

@ -1,44 +0,0 @@
import tkinter as tk
import tkinter.font as tkFont
def amogus(mot):
print("sus")
SyllLab["text"]=mot
GLineEdit_58.delete(0,tk.END)
print(mot)
# Création de la fenêtre principale (root)
root = tk.Tk()
# Définition du titre de la fenêtre
root.title("BombParty !")
# Définition de la taille de la fenêtre
width=769
height=563
root.geometry(str(width)+"x"+str(height))
# Création d'un label dans lequel on affichera les syllabes
LabelSyll=tk.Label(root)
LabelSyll["fg"] = "#333333"
LabelSyll["justify"] = "center"
LabelSyll["text"] = "Compléter cette Syllabe :"
LabelSyll.place(x=230,y=30,width=321,height=63)
# Création d'un champ de texte dans lequel le jouuer entrera les mots
GLineEdit_58=tk.Entry(root)
GLineEdit_58.bind("<Return>", (lambda event: amogus(GLineEdit_58.get())))
GLineEdit_58["borderwidth"] = "1px"
GLineEdit_58["fg"] = "#333333"
GLineEdit_58["justify"] = "center"
GLineEdit_58["text"] = "Entrer ici la réponse"
GLineEdit_58.place(x=170,y=430,width=410,height=73)
# Créatiin d'un label avec la syllabe à trouver :
SyllLab=tk.Label(root)
SyllLab["fg"] = "#333333"
SyllLab["font"] = tkFont.Font(family='Times',size=94)
SyllLab["justify"] = "center"
SyllLab["text"] = ""
SyllLab.place(x=0,y=80,width=771,height=329)
root.mainloop()

@ -1,46 +1,278 @@
from faulthandler import disable
from tkinter import *
import time
import random as rd
import os
def salut(mot):
print(mot)
'''
_____ _
| __ \ | |
| |__) | __ ___ ______ ___ ___ __| | ___
| ___/ '__/ _ \______/ __/ _ \ / _` |/ _ \
| | | | | __/ | (_| (_) | (_| | __/
|_| |_| \___| \___\___/ \__,_|\___|
'''
# Nettoie la console.
clearConsole = lambda: os.system('cls' if os.name in ('nt', 'dos') else 'clear')
clearConsole()
# Importation des mots dans notre projet
with open("mots.txt", "r",encoding="utf8") as motsfichier:
# On ajoute nos mots dans une liste
mots = motsfichier.readlines()
for i in range(len(mots)):
# On retire les entrées dans nos mots
mots[i]=mots[i].replace("\n","")
# Importation des syllabes dans notre projet
with open("syllabes.txt", "r",encoding="utf8") as syllabesfichier:
# On ajoute nos syllabes dans une liste
syllabes = syllabesfichier.readlines()
for i in range(len(syllabes)):
# On retire les entrées de nos syllabes
syllabes[i]=syllabes[i].replace("\n","")
# Cette liste contiens les points des joueurs
pj=[0,0,0,0,0,0,0]
# Préparation du système de tours
tour_du_joueur=0
'''
______ _ _
| ____| | | (_)
| |__ ___ _ __ ___| |_ _ ___ _ __ ___
| __/ _ \| '_ \ / __| __| |/ _ \| '_ \/ __|
| | | (_) | | | | (__| |_| | (_) | | | \__ \
|_| \___/|_| |_|\___|\__|_|\___/|_| |_|___/
'''
# Reset Zone de Texte (GUI)
# 'mot' est le contenu de notre zone de texte.
def reset_zdt(mot):
# On vérifie si il y a du contenu dans notre zone de texte avant d'exécuter des choses.
if zonedetexte.get()=="":
return
# Si il y a bien quelquechose, alors nous pouvons exécuter la suite.
else:
# On exécute une fonction avec 'mot' comme argument.
jeu("proposition",mot)
# On retire le texte de la zone de texte.
zonedetexte.delete(0,END)
# Cette fonction permet de désactiver la zone de texte.
def disable_zdt():
zonedetexte.configure(state="disabled")
refresh()
# Cette fonction permet d'activer la zone de texte.
def enable_zdt():
zonedetexte.configure(state="normal")
refresh()
# Cette fonction permet de supprimer le contenu de la zone de texte.
def clear_zdt():
zonedetexte.delete(0,END)
def hide(truc):
truc.pack_forget()
refresh()
# Cette fonction permet d'actualiser la fenêtre
def refresh():
fenetre.update()
# Lancement du Jeu (GUI)
def launch_game():
# On retire le bouton start de notre fenêtre.
bouton_start.pack_forget()
# On reset notre écran d'instructions.
mot_affiche.configure(text="")
# On ouvre notre zone de texte.
zonedetexte.configure(state="normal")
# On lance un tour
jeu("tour")
# Cette fonction tire au sort une syllabe depuis notre liste de syllabes
def tirage_syllabe():
# On renvoie une variable tirée au sort.
return rd.choice(syllabes)
# Cette fonction vérifie si le mot du joueur contiens bien la syllabe à trouver
def mot_contiens_syllabe(syllabe_a_trouver,mot_du_joueur):
# On vérifie si c'est bien le cas
if syllabe_a_trouver in mot_du_joueur:
return True
# Si ce n'est pas le cas on return False
else:
return False
# On vérifie si le mot entré par le joueur est conu par notre base de données.
def mot_dans_bdd(mot_du_joueur):
if mot_du_joueur in mots:
return True
# Si ce n'est pas le cas on return False
else:
return False
# On vérifie si le nombre de joueurs entré est bien compris entre 1 et 6
def verif_nb_joueurs(nb_j):
O=[1,2,3,4,5,6] # Nombre de joueurs possibles
if nb_j in O:
return True
# Si ce n'est pas le cas on return False
else:
return False
# La fonction du jeu
def jeu(action,mot=""):
# Action : tour
if action=="tour":
# On crée une variable globale qui sera notre syllabe à trouver
global syllabe_a_trouver
global tentative
tentative=0
# On définit notre syllabe à trouver
syllabe_a_trouver=tirage_syllabe()
# On affiche la syllabe à trouver
jeu("affiche")
# Action : proposition
if action=="proposition":
# Nombre de tentatives dépassées
if tentative>3:
jeu("tentative")
return
# On vérifie si le mot contiens la syllabe requise
if mot_contiens_syllabe(syllabe_a_trouver,mot)==True:
# On vérifie si le mot est dans la base de données
if mot_dans_bdd(mot)==True:
# Si c'est le cas, on lance l'action gagnée !
jeu("oui")
# Si ce n'est pas le cas, on informe le joueur, et relance le tour.
else:
tentative=tentative+1
print(tentative)
# On affiche un message au joueur
mot_affiche.configure(text="Ce mot est inconnu. Aucun point ne sera donc compté.")
# On raffraichis la fenêtre
refresh()
# On nettoie la zone de texte
clear_zdt()
# On désactive la zone de texte
disable_zdt()
# On attends 2 secondes
time.sleep(2)
# On relance le jeu
jeu("affiche",mot)
else:
tentative=tentative+1
# On affiche un message au joueur
mot_affiche.configure(text="Le mot donné le contiens pas la syllabe requise.")
# On raffraichis la fenêtre
refresh()
# On nettoie la zone de texte
clear_zdt()
# On désactive la zone de texte
disable_zdt()
# On attends 2 secondes
time.sleep(2)
# On relance le jeu
jeu("affiche",mot)
# Action : oui (gagné !)
if action=="oui":
# On augmente les points du joueur 0
pj[0]=pj[0]+1
points=pj[0]
# On nettoie la zone de texte
clear_zdt()
# On désactive la zone de texte
disable_zdt()
# On affiche un message de félicitations
mot_affiche.configure(text=f'''Bonne réponse ! Vous avez {points} point(s) !''')
# On raffraichis la fenêtre
refresh()
# On attends 3s
time.sleep(3)
# On relance un tour
jeu("tour")
if action=="affiche":
# On active la zone de texte
enable_zdt()
# On raffiche la consigne
mot_affiche.configure(text=f'''Syllabe : {syllabe_a_trouver}''')
# On raffraichis la fenêtre
refresh()
if action=="tentative":
# Message d'échec au joueur
mot_affiche.configure(text="Vous n'avez trouvé aucun mot. -1 Point :(")
# Points du joueur
pj[0]=pj[0]-1
# On nettoie la zone de texte
clear_zdt()
# On désactive la zone de texte
disable_zdt()
# On actualise la fenêtre
refresh()
# On attends 2 secondes
time.sleep(2)
# On recommence un nouveau tour
jeu("tour")
'''
_____ _ __
|_ _| | | / _|
| | _ __ | |_ ___ _ __| |_ __ _ ___ ___
| | | '_ \| __/ _ \ '__| _/ _` |/ __/ _ \
_| |_| | | | || __/ | | || (_| | (_| __/
|_____|_| |_|\__\___|_| |_| \__,_|\___\___|
'''
# Notre fenêtre Tkinter
fenetre = Tk()
# Le titre de la fenêtre
fenetre.title('BombParty')
fenetre.geometry('720x480')
# Les dimensions de la fenêtre
fenetre.geometry('720x200')
# On désactive la possibilité de redimensionner la fenêtre
fenetre.resizable(False, False)
# On définit un arrière-plan blanc
fenetre.config(background='white')
#canvas = Canvas(fenetre, width=1280, height=720, background='white')
# On crée notre zone de texte.
# C'est dans celle-ci que le joueur entrera les mots
zonedetexte = Entry(fenetre, justify='center')
zonedetexte.bind("<Return>",(lambda event: salut(zonedetexte.get())))
# On associe cette zonedetexte à la touche Entrée pour effectuer des actions par la suite.
zonedetexte.bind("<Return>",(lambda event: reset_zdt(zonedetexte.get())))
# On crée un écran dans lequel les informations au joueur seront affichées.
mot_affiche = Label(fenetre, text="Cliquer sur commencer, pour lancer la partie !",width=720, anchor=CENTER)
# On poisitonne notre objet dans la fenêtre.
mot_affiche.grid(sticky="s")
debut = Button(fenetre, text="Commencer", command = print("salut"))
debut.configure(command=lambda: hide(debut))
#mot_affiche.place(x=fenetre.winfo_width()/2, y=fenetre.winfo_height()/2, anchor="center")
# On crée un bouton start
bouton_start = Button(fenetre, text="Commencer", command = print("salut"))
# On configure notre bouton afin qu'il exécute le début de notre jeu.
bouton_start.configure(command=lambda: launch_game())
'''
canvas.create_rectangle(
255, 379, 464, 437,
outline="#fb0",
fill="#fb0"
)
'''
## Debug
##
## Ce code est à des fins de déboggage.
##
def pointeur1(event) :
x = event.x
y = event.y
print(x,y,1)
fenetre.bind("<Button-1>",pointeur1)
## Debug
##
## Ce code est à des fins de déboggage.
##
# On ajoute tout nos objets à la fenêtre.
mot_affiche.pack()
zonedetexte.pack(pady=30)
zonedetexte.configure(state="disabled")
debut.pack(pady=5)
#canvas.pack()
bouton_start.pack(pady=5)
# On lance l'interface.
fenetre.mainloop()

@ -1,9 +1,9 @@
# Jeu de BombParty
from secrets import token_bytes
import time
import random as rd
import os
'''
#Nettoyage
clearConsole = lambda: os.system('cls' if os.name in ('nt', 'dos') else 'clear')
clearConsole()
@ -22,18 +22,19 @@ with open("syllabes.txt", "r",encoding="utf8") as syllabesfichier:
#On retire \n de notre liste de syllabes
for i in range(len(syllabes)):
syllabes[i]=syllabes[i].replace("\n","")
'''
'''
#Tirage au sort de la syllabe
def tirage_syllabe():
syllabe=rd.choice(syllabes)
return syllabe
'''
#Demander au joueur un mot
def demander_mot(syllabe_a_trouver):
mot=input(f'''Vous devez trouver un mot contenant la syllabe : {syllabe_a_trouver}
Votre proposition : ''')
return mot
'''
#Vérifier si la syllabe est bien dans le mot
def mots_et_syllabes_valable(syllabe_a_trouver,mot_du_joueur):
if syllabe_a_trouver in mot_du_joueur:
@ -42,8 +43,9 @@ def mots_et_syllabes_valable(syllabe_a_trouver,mot_du_joueur):
print("""
Ce mot ne possède pas la syllabe requise.""")
return False
'''
#Rechercher le mot dans notre base de données de mots, puis vérifier sa syllabe
'''
def comparer_mot(mot,syllabe_a_trouver):
if mot in mots:
return mots_et_syllabes_valable(syllabe_a_trouver,mot)
@ -51,7 +53,7 @@ def comparer_mot(mot,syllabe_a_trouver):
print("""
Ce mot n'existe pas dans notre base de données.""")
return False
'''
# ---------------- Arthur ---------------------- #
#Détermination du nombre de joueurs
@ -61,6 +63,7 @@ def demander_nb_joueurs():
return int(resultat)
#On vérifie si la valeur entrée fait parties du nombre de joueur compatible au jeu
'''
def check_bon_nb_joueurs(nb):
O=[1,2,3,4,5,6] # Nombre de joueurs possibles
if nb in O:
@ -69,16 +72,17 @@ def check_bon_nb_joueurs(nb):
return nb
else:
return check_bon_nb_joueurs(demander_nb_joueurs())
'''
#On demande le nombre de joueurs pour notre partie
nbjoueurs=int(check_bon_nb_joueurs(demander_nb_joueurs))
#nbjoueurs=int(check_bon_nb_joueurs(demander_nb_joueurs))
#On crée nos variables de points nécéssaires à notre jeu
#Cette liste contiens nos points de joueurs. Chaque 1 correspond à un joueur. Joueur 2 = pj[0]
pj=[0,1,1,1,1,1,1]
#pj=[0,1,1,1,1,1,1]
#A quel joueur est-ce le tour ?
tour_du_joueur=0
#tour_du_joueur=0
#On change de tour
def tour_suivant(tour):
tour=tour+1
@ -91,10 +95,10 @@ partie_en_cours=1
# Le code du jeu
#
def jeu(tour_du_joueur,pj):
clearConsole()
print("Joueur",tour_du_joueur,", c'est votre tour !")
print("--------------------------")
syllabe_a_trouver=tirage_syllabe()
#clearConsole()
#print("Joueur",tour_du_joueur,", c'est votre tour !")
#print("--------------------------")
#syllabe_a_trouver=tirage_syllabe()
mot_du_joueur=demander_mot(syllabe_a_trouver)
if comparer_mot(mot_du_joueur,syllabe_a_trouver)==True:
print("")

Loading…
Cancel
Save