#include <SCServo.h>
SCServo SERVO;

#include <Servo.h>

Servo Servo_elevateur;
Servo Servo_planche_gauche;
Servo Servo_planche_droite;
Servo Servo_aimant_centre;
Servo Servo_aimant_lateraux;

int btn_elevateur_UP = 22;      // Broche 22 sur l'arduino mega
int btn_elevateur_DOWN = 23;    // Broche 23 sur l'arduino mega
int btn_aimant_centre = 24;     // Broche 24 sur l'arduino mega
int btn_aimant_lateraux = 25;   // Broche 25 sur l'arduino mega
int btn_planche = 26;           // Broche 26 sur l'arduino mega
// botons reset
int btn_RESET = 27;             // Broche 27 sur l'arduino mega
int btn_banniere = 28;          // Servo SCS15 - Broche 28 sur l'arduino mega 

boolean val_btn_elevateur_UP,
        val_btn_elevateur_DOWN,
        val_btn_aimant_centre,
        val_btn_aimant_lateraux,
        val_btn_planche,
        val_btn_banniere;

const int PWM2A = 11;     // Broche PWM du moteur M1
const int PWM2B = 3;      // Broche PWM du moteur M2
const int PWM0A = 6;      // Broche PWM du moteur M3
const int PWM0B = 5;      // Broche PWM du moteur M4
const int DIR_CLK = 4;    // Ligne d'horloge d'entrée de données
const int DIR_EN = 7;     // Broches d'activation du L293D
const int DATA = 8;       // Câble USB
const int DIR_LATCH = 12; // Horloge de verrouillage de la mémoire de sortie

const int Move_Forward = 39;      // Avancer
const int Move_Backward = 216;    // Reculer
const int Left_Move = 116;        // Translation vers la gauche
const int Right_Move = 139;       // Translation vers la droite
const int Right_Rotate = 149;     // Rotation à droite
const int Left_Rotate = 106;      // Rotation à gauche
const int Stop = 0;               // Arrêt
const int Upper_Left_Move = 36;   // Déplacement en haut à gauche
const int Upper_Right_Move = 3;   // Déplacement en haut à droite
const int Lower_Left_Move = 80;   // Déplacement en bas à gauche
const int Lower_Right_Move = 136; // Déplacement en bas à droite
const int Drift_Left = 20;        // Dérive vers la gauche
const int Drift_Right = 10;       // Dérive vers la droite

int Speed1 = 255; // Définir la vitesse par défaut entre 1 et 255
int Speed2 = 255; // Définir la vitesse par défaut entre 1 et 255
int Speed3 = 255; // Définir la vitesse par défaut entre 1 et 255
int Speed4 = 255; // Définir la vitesse par défaut entre 1 et 255

/******************JOYSTICK****************/
const int JOYSTICK_X_GAUCHE = A0;
const int JOYSTICK_Y_GAUCHE = A1;
const int JOYSTICK_X_DROIT = A2;
const int JOYSTICK_Y_DROIT = A3;
const int JOYSTICK_BUTTON_GAUCHE = 29;
const int JOYSTICK_BUTTON_DROIT = 30;

int X_GAUCHE = 0;
int Y_GAUCHE = 0;
int X_DROIT = 0;
int Y_DROIT = 0;

// Zone morte du joystick gauche
const int ZONE_MORTE = 150;
const int ZONE_MORT_CENTRE = 512;
const int VITESSE_MAX = 255;

void Motor(int Dir, int Speed1, int Speed2, int Speed3, int Speed4)
{
  analogWrite(PWM2A, Speed1); // Régulation de la vitesse du moteur par PWM
  analogWrite(PWM2B, Speed2); // Régulation de la vitesse du moteur par PWM
  analogWrite(PWM0A, Speed3); // Régulation de la vitesse du moteur par PWM
  analogWrite(PWM0B, Speed4); // Régulation de la vitesse du moteur par PWM

  digitalWrite(DIR_LATCH, LOW);           // DIR_LATCH passe au niveau bas et prépare l'écriture de la direction
  shiftOut(DATA, DIR_CLK, MSBFIRST, Dir); // Écriture de la valeur de direction Dir
  digitalWrite(DIR_LATCH, HIGH);          // DIR_LATCH passe au niveau haut et sort la direction
}


void setup() {
  //Serial.begin(9600);
  //******** SCS15 *******//
  Serial.begin(1000000);
  SERVO.pSerial = &Serial;
  SERVO.EnableTorque(0XFE, 1);
  //SERVO.EnableTorque(2, 1);
  
  // boutons
  pinMode(btn_elevateur_UP, INPUT_PULLUP);
  pinMode(btn_elevateur_DOWN, INPUT_PULLUP);
  pinMode(btn_aimant_centre, INPUT_PULLUP);
  pinMode(btn_aimant_lateraux, INPUT_PULLUP);
  pinMode(btn_planche, INPUT_PULLUP);
  pinMode(btn_RESET, INPUT_PULLUP);
  pinMode(btn_banniere, INPUT_PULLUP);

  // Joystick
  pinMode(DIR_CLK, OUTPUT);
  pinMode(DATA, OUTPUT);
  pinMode(DIR_EN, OUTPUT);
  pinMode(DIR_LATCH, OUTPUT);
  pinMode(PWM0B, OUTPUT);
  pinMode(PWM0A, OUTPUT);
  pinMode(PWM2A, OUTPUT);
  pinMode(PWM2B, OUTPUT);

  /******************JOYSTICK****************/
  pinMode(JOYSTICK_X_GAUCHE, INPUT);
  pinMode(JOYSTICK_Y_GAUCHE, INPUT);
  pinMode(JOYSTICK_X_DROIT, INPUT);
  pinMode(JOYSTICK_Y_DROIT, INPUT);
  pinMode(JOYSTICK_BUTTON_GAUCHE, INPUT_PULLUP);
  pinMode(JOYSTICK_BUTTON_DROIT, INPUT_PULLUP);

  // Servomoteurs
  Servo_elevateur.attach(54);         // Borhce 54 sur l'arduino mega
  Servo_planche_gauche.attach(53);   // Borhce 53 sur l'arduino mega
  Servo_planche_droite.attach(52);    // Borhce 52 sur l'arduino mega
  Servo_aimant_centre.attach(51);     // Borhce 51 sur l'arduino mega
  Servo_aimant_lateraux.attach(50);   // Borhce 50 sur l'arduino mega
  delay(10);
  Servo_elevateur.write(90);       // On arrête le servo
  Servo_planche_gauche.write(0);   // a redéfinir en fonction du calibrage
  Servo_planche_droite.write(180);   // a redéfinir en fonction du calibrage
  Servo_aimant_centre.write(0);    // a redéfinir en fonction du calibrage
  Servo_aimant_lateraux.write(0);  // a redéfinir en fonction du calibrage
  delay(500);
  
}

void loop() {
  // recupt valeurs boutons
  val_btn_elevateur_UP = digitalRead(btn_elevateur_UP);
  val_btn_elevateur_DOWN = digitalRead(btn_elevateur_DOWN);
  val_btn_aimant_centre = digitalRead(btn_aimant_centre);
  val_btn_aimant_lateraux = digitalRead(btn_aimant_lateraux);
  val_btn_planche = digitalRead(btn_planche);

  Serial.println(val_btn_elevateur_UP);

  // Lecture des valeurs des joysticks
  X_GAUCHE = analogRead(JOYSTICK_X_GAUCHE);
  Y_GAUCHE = analogRead(JOYSTICK_Y_GAUCHE);
  X_DROIT = analogRead(JOYSTICK_X_DROIT);
  Y_DROIT = analogRead(JOYSTICK_Y_DROIT);

  pose_banniere();

  // Calcul de la vitesse en fonction de la distance au centre
  int vitesse = 0;

  // Gestion des mouvements avec vitesse variable
  if (Y_GAUCHE < (ZONE_MORT_CENTRE - ZONE_MORTE)){
    // Avancer - Plus on pousse vers l'avant, plus la vitesse augmente
    vitesse = map(Y_GAUCHE, 0, ZONE_MORT_CENTRE - ZONE_MORTE, VITESSE_MAX, 0);
    Motor(Move_Forward, vitesse, vitesse, vitesse, vitesse);
  }
  else if (Y_GAUCHE > (ZONE_MORT_CENTRE + ZONE_MORTE)){
    // Reculer - Plus on tire vers l'arrière, plus la vitesse augmente
    vitesse = map(Y_GAUCHE, ZONE_MORT_CENTRE + ZONE_MORTE, 1023, 0, VITESSE_MAX);
    Motor(Move_Backward, vitesse, vitesse, vitesse, vitesse);
  }
  else if (X_GAUCHE < (ZONE_MORT_CENTRE - ZONE_MORTE)){
    // Translation droite - Plus on pousse à droite, plus la vitesse augmente
    vitesse = map(X_GAUCHE, 0, ZONE_MORT_CENTRE - ZONE_MORTE, VITESSE_MAX, 0);
    Motor(Right_Move, vitesse, vitesse, vitesse, vitesse);
  }
  else if (X_GAUCHE > (ZONE_MORT_CENTRE + ZONE_MORTE)){
        // Translation gauche - Plus on pousse à gauche, plus la vitesse augmente
    vitesse = map(X_GAUCHE, ZONE_MORT_CENTRE + ZONE_MORTE, 1023, 0, VITESSE_MAX);
    Motor(Left_Move, vitesse, vitesse, vitesse, vitesse);
  }
  // Ajout du contrôle des rotations avec le joystick droit
  else if (X_DROIT < (ZONE_MORT_CENTRE - ZONE_MORTE)){
    // Rotation droite - Plus on pousse à droite, plus la rotation est rapide
    vitesse = map(X_DROIT, 0, ZONE_MORT_CENTRE - ZONE_MORTE, VITESSE_MAX, 0);
    Motor(Right_Rotate, vitesse, vitesse, vitesse, vitesse);
  }
  else if (X_DROIT > (ZONE_MORT_CENTRE + ZONE_MORTE)){
    // Rotation gauche - Plus on pousse à gauche, plus la rotation est rapide
    vitesse = map(X_DROIT, ZONE_MORT_CENTRE + ZONE_MORTE, 1023, 0, VITESSE_MAX);
    Motor(Left_Rotate, vitesse, vitesse, vitesse, vitesse);
  }
  else{
    // Zone morte - Arrêt
    Motor(Stop, 0, 0, 0, 0);
  }

  // Affichage des valeurs sur le port série
  Serial.print("X_GAUCHE: ");
  Serial.print(X_GAUCHE);
  Serial.print(" | ");
  Serial.print(" Y_GAUCHE: ");
  Serial.print(Y_GAUCHE);
  Serial.print(" | ");
  Serial.print(" X_DROIT: ");
  Serial.print(X_DROIT);
  Serial.print(" | ");
  Serial.print(" Vitesse: ");
  Serial.println(vitesse);

  gestion_boutons();

  delay(10);
}

void gestion_boutons(){
  if (val_btn_elevateur_UP == 0){
    Serial.println("Elevation du rateau");
    Servo_elevateur.attach(53);
    Servo_elevateur.write(125);
    delay(100);
  }
  else{
    Servo_elevateur.detach();
    Servo_elevateur.write(90);
    delay(100);
  }

  if (val_btn_aimant_centre == 0){
    Serial.println("Detachement aimant centraux");
    Servo_aimant_centre.write(90);
    delay(100);
  }
  else{
    Servo_aimant_centre.write(0);
    delay(100);
  }

  if (val_btn_aimant_lateraux != 0){
    Servo_aimant_lateraux.write(90);
    delay(100);
  }
  else
  {
    Servo_aimant_lateraux.write(0);
    delay(100);
  }

  if (val_btn_planche != 0)
  {
    Servo_planche_gauche.write(90);
    delay(100);
  }
  else
  {
    Servo_planche_gauche.write(0);
    delay(100);
  }
}
void pose_banniere(){
  val_pin_btn_drapeau = digitalRead(pin_btn_drapeau);
  Serial.println(val_pin_btn_drapeau);

  if (val_pin_btn_drapeau == 0) {
    SERVO.WritePos(0XFE, 950, 500);
    Serial.println("bannière PAS déposée");
    delay(8000); // Laisse 8sec pour déposer la bannière 
  }
  else {
    SERVO.WritePos(0XFE, 510, 500);
    delay(100);
  }
}


  

git clone https://github.com/myscript/interactive-ink-examples-uwp


cd interactive-ink-examples-uwp

import random
import tkinter as tk
from tkinter import StringVar, Entry, Button, PhotoImage
 
 
# Définir la fonction choisir_mot qui choisit un mot aléatoire
def choisir_mot():
    mots = ["python", "apprentissage", "programmation", "ordinateur", "developpement"]
    return random.choice(mots)
 
 
# Définir la fonction afficher_mot qui affiche le mot à deviner avec les lettres trouvées
def afficher_mot(mot, lettres_trouvees):
    affichage = ""
    for lettre in mot:
        if lettre in lettres_trouvees:
            affichage += lettre
        else:
            affichage += "-"
    return affichage
 
 
# Définir la fonction pendu qui permet de jouer au jeu du pendu avec une interface graphique
def pendu():
    # Choisir un mot aléatoire
    mot_a_deviner = choisir_mot()
 
    # Initialiser les variables de jeu
    lettres_trouvees = []
    tentatives_max = 6
    tentatives = 0
 
    # Créer une fenêtre Tkinter
    fenetre = tk.Tk()
    fenetre.geometry("300x200")
    fenetre.title("Jeu du Pendu")
 
    # Créer les éléments graphiques
    label_mot = tk.Label(fenetre, text=afficher_mot(mot_a_deviner, lettres_trouvees))
    label_mot.pack()
 
    entry_lettre = tk.Entry(fenetre)
    entry_lettre.pack()
 
    label_tentatives = tk.Label(fenetre, text="Tentatives restantes : " + str(tentatives_max - tentatives))
    label_tentatives.pack()
 
    # Fonction pour vérifier la lettre choisie
    def verifier_lettre():
        nonlocal tentatives
        lettre_choisie = entry_lettre.get()
        entry_lettre.delete(0, tk.END)
 
        if lettre_choisie in lettres_trouvees:
            label_tentatives.config(text="Vous avez déjà deviné cette lettre. Essayez encore.")
        elif lettre_choisie in mot_a_deviner:
            lettres_trouvees.append(lettre_choisie)
            label_mot.config(text=afficher_mot(mot_a_deviner, lettres_trouvees))
 
            if "-" not in afficher_mot(mot_a_deviner, lettres_trouvees):
                label_tentatives.config(text="Félicitations ! Vous avez deviné le mot : " + mot_a_deviner)
        else:
            tentatives += 1
            label_tentatives.config(text="Incorrect. Tentatives restantes : " + str(tentatives_max - tentatives))
            if tentatives == tentatives_max:
                label_tentatives.config(
                    text="Désolé, vous avez atteint le nombre maximum de tentatives. Le mot était : " + mot_a_deviner)
 
    # Créer le bouton pour valider la lettre choisie
    btn_valider = tk.Button(fenetre, text="Valider", command=verifier_lettre)
    btn_valider.pack()
 
    fenetre.mainloop()
# Appeler la fonction pendu pour jouer au jeu
pendu()
 
 

code de Tom
 
import random
 
def choisir_mot():
    mots = ["oiseaux","machin","truc","bizare","intergouvernementalisations"," anticonstitutionnellement","Aminométhylpyrimidinylhydroxyéthylméthylthiazolium"]
    return random.choice(mots)
 
 
def afficher_mot(mot, lettres_trouvees):
    affichage = ""
    for lettre in mot:
        if lettre in lettres_trouvees:
            affichage += lettre
        else:
            affichage += "_"
    return affichage
 
def pendu():
    mot_a_deviner = choisir_mot()
 
#creation du TABLEAU appele lettre trouvees
    lettres_trouvees =[]
 
    tentatives_max = 6
    tentatives = 0
 
    print("bienvenue dans le jeu du pendu(toi)!")
 
# while = tant que...
    while tentatives <= tentatives_max:
        lettre_choisie = input("tape la bonne lettre si t'es pas un GROS NOOOOOOOB : ").lower()
 
        if lettre_choisie in lettres_trouvees :
            print ("tu as deja tape cette lettre gros noob. reesaie sal noob.")
            continue
 
        if lettre_choisie in mot_a_deviner:
            lettres_trouvees.append(lettre_choisie)
            mot_actuel = afficher_mot(mot_a_deviner, lettres_trouvees)
            print(mot_actuel)
 
            if "_" not in mot_actuel:
                print("Si un noob réussi, c'est que c'est facile : ", mot_a_deviner)
                break
 
        else:
            tentatives += 1
            print("je ne savais pas que c'etait possible d'etre aussi noob : ", tentatives_max- tentatives)
 
    if tentatives == tentatives_max:
        print("Je le savais, aucune chance qu'un noob comme toi réussisse : ", mot_a_deviner)
    pendu()

# Importer le module random
import random
 
# Définir la fonction choisir_mot qui choisit un mot aléatoire
def choisir_mot():
    mots = ["python", "apprentissage", "programmation", "ordinateur", "developpement"]
    return random.choice(mots)
 
# Définir la fonction afficher_mot qui affiche le mot à deviner avec les lettres trouvées
def afficher_mot(mot, lettres_trouvees):
    affichage = ""
    for lettre in mot:
        if lettre in lettres_trouvees:
            affichage += lettre
        else:
            affichage += "_"
    return affichage
 
# Définir la fonction pendu qui permet de jouer au jeu du pendu
def pendu():
    # Choisir un mot aléatoire
    mot_a_deviner = choisir_mot()
 
    # Initialiser les variables de jeu
    lettres_trouvees = []
    tentatives_max = 6
    tentatives = 0
 
    # Afficher un message de bienvenue
    print("Bienvenue dans le jeu du pendu !")
 
    # Boucle principale du jeu
    while tentatives < tentatives_max:
        # Demander à l'utilisateur de deviner une lettre
        lettre_choisie = input("Devinez une lettre : ").lower()
 
        # Vérifier si la lettre a déjà été devinée
        if lettre_choisie in lettres_trouvees:
            print("Vous avez déjà deviné cette lettre. Essayez encore.")
            continue
 
        # Vérifier si la lettre est dans le mot à deviner
        if lettre_choisie in mot_a_deviner:
            lettres_trouvees.append(lettre_choisie)
            mot_actuel = afficher_mot(mot_a_deviner, lettres_trouvees)
            print(mot_actuel)
 
            # Vérifier si le mot a été entièrement deviné
            if "_" not in mot_actuel:
                print("Félicitations ! Vous avez deviné le mot :", mot_a_deviner)
                break
        else:
            tentatives += 1
            print("Incorrect. Tentatives restantes : ", tentatives_max - tentatives)
 
    # Afficher un message de fin de jeu
    if tentatives == tentatives_max:
        print("Désolé, vous avez atteint le nombre maximum de tentatives. Le mot était :", mot_a_deviner)
 
# Appeler la fonction pendu pour jouer au jeu
pendu()

from tkinter import *
from tkinter.ttk import *
 
root = Tk()
 
Label(root, text='GeeksforGeeks', font=(
    'Verdana', 15)).pack(side=TOP, pady=10)
 
photo = PhotoImage(file=r"C:\Users\made in takos\PycharmProjects\jeuxClic\ico.png")
 
photoimage = photo.subsample(3, 3)
Button(root, text='Click Me !', image=photoimage,
       compound=LEFT).pack(side=TOP)
 
mainloop()
 
 
 
def compteur_temps():
    while i <= 60:
        i+=1
        print(i)
        time.sleep(1)
 
# On défini la fonction appelée à chaque clic sur le bouton
def incrementer_compteur():
    # Permet d'accéder à la variable globale
    global compteur
    compteur += 1
    print("Compteur :", compteur)
 
# On défini la fonction appelée lorsque la fenêtre score se ferme
def fermer_fenetre():
    #fenetre_score.destroy()
    if compteur >= 20:
        print("T'es NUL!!!")
    else:
        print("T'es FOOOOORT!!!")
    quit()
 
############## INTERFACE #############
fenetre = Tk()
fenetre.title("jeu Clic")
compteur_temps()
 
for ligne in range(5):
    for colonne in range(5):
        Button(fenetre, text='L%s-C%s' % (ligne, colonne), borderwidth=1, command=incrementer_compteur).grid(row = ligne, column = colonne)
# On crée le bouton en position aléatoire
Button(fenetre, text='LR-CR', borderwidth=1, command=lambda:[fermer_fenetre(), fenetre_score()]).grid(row = rnd_x, column = rnd_Y)
 
def fenetre_score():
    global compteur
    # On crée une nouvelle fenêtre
    fenetre_score = Toplevel(fenetre)
    fenetre_score.title("Score")
 
    # On ajoute un label pour afficher le score
    label_score = Label(fenetre_score, text="Votre score est de {}".format(compteur))
    label_score.pack(padx=10, pady=10)
 
    # On ajoute un bouton pour fermer la fenêtre
    bouton_fermer = Button(fenetre_score, text="Fermer", command=fermer_fenetre)
    bouton_fermer.pack(pady=10)
 
#fenetre.mainloop()
mainloop()

from tkinter import *
from tkinter.ttk import *
 
root = Tk()
 
Label(root, text='GeeksforGeeks', font=(
    'Verdana', 15)).pack(side=TOP, pady=10)
 
photo = PhotoImage(file=r"C:\Users\made in takos\PycharmProjects\jeuxClic\ico.png")
photoimage = photo.subsample(3, 3)
Button(root, text='Click Me !', image=photoimage,
       compound=LEFT).pack(side=TOP)
 
mainloop()

from tkinter import *
import random
import time
 
# On déclare nos variables pour les position en X et Y
rnd_x = random.randint(0, 5)
rnd_Y = random.randint(0, 5)
# On initialise la variable de score à 0
compteur = 0
 
 
def compteur_temps():
    i=0
    while i <= 60:
        i += 1
        print(i)
        time.sleep(1)
        break
    while i <= 60:
        i += 1
        print(i)
        time.sleep(1)
# On défini la fonction appelée à chaque clic sur le bouton
def incrementer_compteur():
    # Permet d'accéder à la variable globale
    global compteur
    compteur += 1
    print("Compteur :", compteur)
 
 
# On défini la fonction appelée lorsque la fenêtre score se ferme
def fermer_fenetre():
    # fenetre_score.destroy()
    if compteur >= 20:
        print("T'es NUL!!!")
    else:
        print("T'es FOOOOORT!!!")
    quit()
 
 
############## INTERFACE #############
fenetre = Tk()
fenetre.title("jeu Clic")
#compteur_temps()
from tkinter import *
from tkinter.ttk import *
 
photo = PhotoImage(file=r"C:\Users\Prog'\Documents\PychamProjects\pythonClic\1.png")
photoimage = photo.subsample(3, 3)
 
for ligne in range(5):
    for colonne in range(5):
        Button(fenetre, image=photoimage, command=incrementer_compteur).grid(row=ligne, column=colonne)
# On crée le bouton en position aléatoire
Button(fenetre, image=photoimage, command=lambda:[fermer_fenetre(), fenetre_score()]).grid(row = rnd_x, column = rnd_Y)
 
 
def fenetre_score():
    global compteur
    # On crée une nouvelle fenêtre
    fenetre_score = Toplevel(fenetre)
    fenetre_score.title("Score")
 
    # On ajoute un label pour afficher le score
    label_score = Label(fenetre_score, text="Votre score est de {}".format(compteur))
    label_score.pack(padx=10, pady=10)
 
    # On ajoute un bouton pour fermer la fenêtre
    bouton_fermer = Button(fenetre_score, text="Fermer", command=fermer_fenetre)
    bouton_fermer.pack(pady=10)
 
 
# fenetre.mainloop()
mainloop()
 
(moi GPT)

 
#########################################
# - #Effacer le btn une fois cliqué
# - #Donner un indice après un certain score
# - #Ajouter un compteur de temps
#
#
 
from tkinter import *
from tkinter.ttk import *
import random
import time
 
fenetre = Tk()
fenetre.title("jeu Clic")
#compteur_temps()
 
photo = PhotoImage(file=r"C:\Users\made in takos\PycharmProjects\jeuxClic\ico.png")
photoimage = photo.subsample(3, 3)
 
rnd_x = random.randint(0, 10)
rnd_y = random.randint(0, 10)
 
# On initialise la variable de score à 0
compteur = 0
 
def retirer_bouton(ligne, colonne):
    global compteur
    compteur += 1
    score_label.config(text="Score : " + str(compteur))
    widgets = fenetre.grid_slaves(row=ligne, column=colonne)
    for widget in widgets:
        widget.grid_remove()
 
# On crée le bouton en position aléatoire
def placer_bouton_aleatoire():
    Button(fenetre, image = photoimage, command=lambda:[retirer_bouton(rnd_x, rnd_y),fenetre_score(), fermer_fenetre()]).grid(row=rnd_x, column=rnd_y)
placer_bouton_aleatoire()
 
def fenetre_score():
    global compteur
    score_label = Label(fenetre, text=" " + str(compteur))
    score_label = Label(fenetre, text="Score : " + str(compteur))
    score_label.grid(row=10, column=0,  pady=10)
 
def compteur_temps():
    i=0
    while i <= 60:
        i += 1
        print(i)
        time.sleep(1)
        break
    while i <= 60:
        i += 1
        print(i)
        time.sleep(1)
# On défini la fonction appelée à chaque clic sur le bouton
def incrementer_compteur():
    # Permet d'accéder à la variable globale
    global compteur
    compteur += 1
    print("Compteur :", compteur)
 
 
# On défini la fonction appelée lorsque la fenêtre score se ferme
def fermer_fenetre():
    # fenetre_score.destroy()
    if compteur >= 20:
        print("T'es NUL!!! ton score est de : ", compteur)
 
    else:
        print("T'es FOOOOORT!!!")
    quit()
 
 
############## INTERFACE #############
for ligne in range(10):
    for colonne in range(10):
        Button(fenetre, image = photoimage, command=lambda ligne=ligne, colonne=colonne: retirer_bouton(ligne, colonne)).grid(row=ligne, column=colonne)
 
score_label = Label(fenetre, text="Score : " + str(compteur))
 
score_label.grid(row=0, column=14, padx=10, pady=10, sticky="n")
 
# fenetre.mainloop()
mainloop()

from tkinter import *
from tkinter.ttk import *
import random
import time
rand = 15
# On déclare nos variables pour les position en X et Y
rnd_x = random.randint(0, rand)
rnd_Y = random.randint(0, rand)
# On initialise la variable de score à 0
compteur = 0
 
 
def compteur_temps():
    i=0
    while i <= 60:
        i += 1
        print(i)
        time.sleep(1)
        break
    while i <= 60:
        i += 1
        print(i)
        time.sleep(1)
# On défini la fonction appelée à chaque clic sur le bouton
def incrementer_compteur():
    # Permet d'accéder à la variable globale
    global compteur
    compteur += 1
    print("Compteur :", compteur)
 
    if compteur == 4:
        print("indice la ligne est:",rnd_x)
 
 
# On défini la fonction appelée lorsque la fenêtre score se ferme
def fermer_fenetre():
    # fenetre_score.destroy()
    if compteur >= 15:
        print("T'es NUL!!!")
    else:
        print("T'es FOOOOORT!!!")
    quit()
 
 
############## INTERFACE #############
fenetre = Tk()
fenetre.title("jeu Clic")
#compteur_temps()
 
photo = PhotoImage(file=r"C:\Users\Prog'\Documents\PychamProjects\pythonClic\Sans titre.png")
photoimage = photo.subsample(3, 3)
 
for ligne in range(rand):
    for colonne in range(rand):
        Button(fenetre, image=photoimage, command=incrementer_compteur).grid(row=ligne, column=colonne)
# On crée le bouton en position aléatoire
Button(fenetre, image=photoimage, command=lambda:[fermer_fenetre(), fenetre_score()]).grid(row = rnd_x, column = rnd_Y)
 
 
def fenetre_score():
    global compteur
    # On crée une nouvelle fenêtre
    fenetre_score = Toplevel(fenetre)
    fenetre_score.title("Score")
 
    # On ajoute un label pour afficher le score
    label_score = Label(fenetre_score, text="Votre score est de {}".format(compteur))
    label_score.pack(padx=10, pady=10)
 
    # On ajoute un bouton pour fermer la fenêtre
    bouton_fermer = Button(fenetre_score, text="Fermer", command=fermer_fenetre)
    bouton_fermer.pack(pady=10)
 
 
# fenetre.mainloop()
mainloop()