Author: 1ère spé NSI 2021- 2022

Projets

Jeu du pendu codé en Python

Vous êtes seul et ne savez pas quoi faire? Nous vous proposons un jeux du pendu: affrontez l’ordinateur!

Notre projet consiste à créer un programme en python sur un jeux traditionnel d’école: le jeux du pendu. 

Introduction

L’ordinateur va choisir un mot parmi une liste prédéfinie et inconnue de vous, joueur. Vous devez alors essayer de retrouver le mot en proposant différentes lettres. Vous avez le droit a 8 erreurs, et pas une de plus. Une fois toutes les tentatives épuisées, le bonhomme est pendu: vous avez perdu! Mais si vous trouvez le mot avant d’avoir épuisé toutes vos chances, alors c’est gagné!!

Lorsque vous avez trouvé la bonne lettre, un message s’affiche pour vous informer que votre proposition est juste. Le mot qui était vide se complète alors par la bonne lettre. Ainsi il sera plus facile de deviner quel est le mot.

Le code en entier

from random import randint,choice

def initialisation(): 
    liste_mots=["chocolat", "tentacule", "dictionnaire", "magnifique", "saucisson", "xylophone", "serveur", "houx", "clavier"]
    choix = choice(liste_mots) 
    myst = ""
    for i in choix:
        myst += "_"
    return (choix,myst)

def verification(lettre,mot): 
    if lettre in mot:
        return True
    else:
        return False

def mot_complet(mot):
    if "_" not in mot:
        return True
    else:
        return False

def complete_mot(lettre,mot,myst):
    for i in range(len(mot)):
        if mot[i] == lettre
            temp = list(myst) 
            temp[i] = lettre 
            myst = "".join(temp)
    return myst 

def dessin_pendu(n):
    dessin = ""
    if n == 1:
        dessin = "\n" * 7 + " =============="
    elif n == 2:
        dessin = "\n" + "  ||/\n" + "  ||\n" + "  ||\n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 3:
        dessin = "==============\n" + "  ||/\n" + "  ||\n" + "  ||\n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 4:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||\n" + "  ||\n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 5:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||         O\n" + "  ||\n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 6:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||         O\n" + "  ||        /|\ \n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 7:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||         O\n" + "  ||        /|\ \n" + "  ||         |\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 8:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||         O\n" + "  ||        /|\ \n" + "  ||         |\n" + "  ||        / \ \n" + " /||\n" + " =============="
    return dessin
  
def jeu():
    tentatives = 8
    mot_choisi,mot_cache = initialisation()
    while (tentatives > 0) and (not mot_complet(mot_cache)):
        print("\nNombre de tentatives restantes :\t", tentatives, "\n")
        print(" ".join(mot_cache),"\n\n")
        lettre_choisie = input("Choisir une lettre (en minuscule) :\t")
        if verification(lettre_choisie,mot_choisi):
            mot_cache = complete_mot(lettre_choisie, mot_choisi, mot_cache)
            print("\nLa lettre se trouve bien dans le mot\n")
        else:
            tentatives -= 1
            print("\nLa lettre ne se trouve pas dans le mot...\n\n", dessin_pendu(8 - tentatives),"\n\n")
    if tentatives == 0:
        print(" ".join(mot_cache))
        print("\nLe mot était :\n")
        print(" ".join(mot_choisi))
        print("\nVous avez malheureusement échoué ... \n")
    if "_" not in mot_cache:
        print(" ".join(mot_cache),"\n\n")
        print("\nBravo, vous avez gagné !\n")
    input("\nVeuillez taper sur la touche Entrer pour recommencer\n\n")
    menu()    
        
def menu():
    print("\n-----------BIENVENUE SUR LE JEU DU PENDU-----------\n")
    print("-------------------BONNE CHANCE--------------------\n\n")
    print("C'EST PARTI! \n")
    jeu()

menu()

Nous avons choisi la bibliothèque random pour avoir accès à choice qui nous permet donc d’avoir un programme capable de faire un choix de manière complètement aléatoire.

Les appels aux différentes fonctions

Le programme ci dessus se résume en une ligne;

menu()

Celle ci sert à faire appel à la fonction menu, qui elle même va faire appel à d’autres fonctions. Ainsi le programme peut s’exécuter. Par exemple, on remarque que la fonction menu fait appel à la fonction jeu, qui elle même, fait appel à d’autres fonctions (à voir dans le code ci-dessous)

def menu():
    #cette fonction présente le jeu
    jeu() #renvoie à la fonction "jeu"
    
def jeu():
  #cette fonction est le squelette du programme. elle permet de relier les nombreuses fonctions de manière a pouvoir jouer
    mot_choisi,mot_cache = initialisation() #renvoie à la fonction initialisation
    while (tentatives > 0) and (not mot_complet(mot_cache)): #tant que le nb de tentatives est > 0 et que --> renvoie à la fonction mot complet  --> alors...
        
        """ 
        etc...
        """

Les grandes lignes

Pour pouvoir jouer au jeu du pendu, nous avons besoin d’avoir une liste de mots prédéfinie dans laquelle, un mot au hasard, va être choisi. Le mot, qui aura été sélectionné, apparaitra sous forme de tirets (le nombre de tirets correspondant au nombre de lettres dans le mot).

def initialisation():
    liste_mots=["chocolat", "tentacule", "dictionnaire", "magnifique", "saucisson", "xylophone", "serveur", "houx", "clavier"]
    choix = choice(liste_mots) 
    myst = "" 
    for i in choix:
        myst += "_"
    return (choix,myst)

Une fois le mot apparu sous la forme de tirets, il faut que lorsqu’une lettre est découverte par le joueur, elle prenne la place du tiret auquel elle correspond (complete_mot). Pour cela, le mot va être transformé en une liste et pourra donc être parcouru par le programme. Mais tout d’abord il faut vérifier que la lettre se trouve bien dans le mot (verification).

def verification(lettre,mot): 
    if lettre in mot:
        return True
    else:
        return False

def complete_mot(lettre,mot,myst):  
    for i in range(len(mot)):
        if mot[i] == lettre
            temp = list(myst) # Transforme le mot en une liste temp
            temp[i] = lettre # Remplace le tiret underscore par la lettre
            myst = "".join(temp) # Re-combine les éléments de temp pour en faire à nouveau un mot
    return myst # Renvoi le mot caché, complété avec la (ou les) lettre(s)

Dans ce jeu, nous avons fait le choix de représenter un bonhomme pendu, comme dans le jeu classique d’école. Pour cela, nous avons programmé une fonction permettant d’afficher une partie du dessin du pendu, au fur et à mesure que le nombre de chances diminue, . Au début il n’y a donc pas de dessin; dessin = "" . Plus le pendu apparait, plus les chances de trouver le bon mot diminuent.

def dessin_pendu(n):
    dessin = ""
    if n == 1:
        dessin = "\n" * 7 + " =============="
    elif n == 2:
        dessin = "\n" + "  ||/\n" + "  ||\n" + "  ||\n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 3:
        dessin = "==============\n" + "  ||/\n" + "  ||\n" + "  ||\n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 4:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||\n" + "  ||\n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 5:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||         O\n" + "  ||\n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 6:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||         O\n" + "  ||        /|\ \n" + "  ||\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 7:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||         O\n" + "  ||        /|\ \n" + "  ||         |\n" + "  ||\n" + " /||\n" + " =============="
    elif n == 8:
        dessin = "============Δ=\n" + "  ||/        |\n" + "  ||         O\n" + "  ||        /|\ \n" + "  ||         |\n" + "  ||        / \ \n" + " /||\n" + " =============="
    return dessin
dessin final (tentative = 0, le joueur a perdu)

Pour terminer, nous avons donc crée une fonction qui, comme dit plus haut, structure notre programme. Elle lie toutes les autres fonctions. Le nombre de tentatives y est rentré, et le programme se lance.

Tant que le nombre de tentatives est supérieur à 0 et que le mot n’est pas complet, le script s’exécute. Si la lettre choisie par le joueur est dans le mot, alors le (ou les dans certains cas) tiret correspondant à la lettre sera remplacé par celle-ci. Sinon, le nombre de tentatives diminue de 1 et le dessin du pendu correspondant au nombre de tentatives apparait.

Pour gagné, il suffit donc de vérifier s’il reste ou non des tirets dans le mot (mot_complet). Lorsqu’il n’y en a plus et que tentative>0, alors c’est gagné. Et lorsque le nombre de tentative = 0, alors le mot apparait en entier, c’est perdu.

def jeu():
    tentatives = 8
    mot_choisi,mot_cache = initialisation()
    while (tentatives > 0) and (not mot_complet(mot_cache)):
        print("\nNombre de tentatives restantes :\t", tentatives, "\n")
        print(" ".join(mot_cache),"\n\n") # Pour un affichage montrant bien le nombre de lettres à trouver en séparant chaque tiret underscore
        lettre_choisie = input("Choisir une lettre (en minuscule) :\t")
        if verification(lettre_choisie,mot_choisi):
            mot_cache = complete_mot(lettre_choisie, mot_choisi, mot_cache)
            print("\nLa lettre se trouve bien dans le mot\n")
        else:
            tentatives -= 1
            print("\nLa lettre ne se trouve pas dans le mot...\n\n", dessin_pendu(8 - tentatives),"\n\n")
    if tentatives == 0:
        print(" ".join(mot_cache))
        print("\nLe mot était :\n")
        print(" ".join(mot_choisi))
        print("\nVous avez malheureusement échoué ... \n")
    if "_" not in mot_cache:
        print(" ".join(mot_cache),"\n\n")
        print("\nBravo, vous avez gagné !\n")
    input("\nVeuillez taper sur la touche Entrer pour recommencer\n\n")
    menu()    
    
    
def mot_complet(mot): 
    if "_" not in mot:
        return True
    else:
        return False    

Une fois la partie finie, il ne reste plus qu’à cliquer sur la touche Entrer et le programme nous renvoie au menu de base. Une nouvelle partie peut commencer.

A vous de jouer

Si contre, vous trouverez le lien pour télécharger le programme et faire des parties dignes de ce nom. Quelques explications ont été rajoutées dans ce code pour, si vous le souhaitez, réussir à comprendre plus en détail comment il fonctionne.

Maintenant, à vous de jouer!

Projets

Simulateur de transmission du covid-19

Vérifiez que vous respectez bien le protocole sanitaire avec ce simulateur. Il vous permettra de vous donner une idée sur votre civisme, votre exposition au coronavirus en espace clos ainsi qu’à visualiser les variables qui entrent en jeu dans ce processus de transmission.

Introduction

Ce projet a été réalisé par Iliess L., Luca B. et Romain B., élèves en première NSI en 2021/2022 au lycée Louis Pasteur.

Depuis près de deux ans, nous sommes en pleine pandémie. Cette pandémie a engendré un très grand nombre de morts. Pour éviter que d’autres gens ne meurent à cause du Covid-19 et sensibiliser, nous avons décidé de créer un simulateur de propagation de Covid-19 assez fiable. Malgré que cette histoire de virus relève de la biologie, sa transmission, elle, relève de la physique : la propagation d’aérosols (mini-gouttelettes en suspension dans l’air éjectées par une personne) ainsi une équation a pu être élaborée.

Ce programme permet de calculer le pourcentage de chance que quelqu’un se fasse contaminer par le Covid-19 dans un espace clos et plus précisément dans une salle de classe (d’environ 125 m³). Le résultat dépend du comportement de l’utilisateur ainsi chaque personne testant ce simulateur se sent un minimum concerné.

Nous demandons donc à l’utilisateur différentes informations sur la conduite d’un groupe de personnes dans un espace fermé notamment s’ils ouvrent beaucoup les fenêtres, si le port du masque est bien respecté, le temps passé dans la salle, le nombre de personne dans la salle et le débit d’air inspiré/expiré.

Le code

Le programme est composé de 5 fonctions et de 3 lignes de code. Les fonctions sont toutes dans le même genre, seuls les « prints », les variables et les valeurs changent.

Analysons une fonction :

La première partie de la fonction concerne les différents cas possibles.

def port_du_masque(): #savoir comment le masque est porté en classe, c'est une proportion
    print("1 - Dans votre classe, tout le monde porte bien le masque sur le nez et tout le temps.")
    print("2 - Il y en a quelques uns qui le mettent sous le nez.")
    print("3 - Tout le monde le porte tout le temps sous le nez.")
    print("4 - Personne ne le porte !")
    print()

Ensuite, nous utilisons une instruction conditionnelle pour permettre à l’utilisateur de choisir parmi les choix proposés et ainsi y associer une valeur correspondante au choix.

    choix = int(input("Veuillez selectionner votre choix:\t"))
    if choix == 1:
        F = 0.1
    elif choix == 2:
        F =  0.2
    elif choix == 3:
        F = 0.80
    elif choix == 4:
        F = 1

Et enfin une petite sécurité qui permet de vous renvoyez au début de la fonction si la réponse de l’utilisateur ne convient pas aux propositions.

    else:
        print()
        print("Votre choix n'est pas valide, veuillez taper 1, 2 ou 3 s'il vous plait.")
        print()
        port_du_masque()
    return F

4 des 5 fonctions sont exécutées dans une fonction globale. Cette fonction fait le plus gros du travail. Elle exécute toutes les autres fonctions, fait le calcul final de probabilité et compare le résultat de l’utilisateur aux normes de l’Etat.

Voici le calcul utilisé pour calculer la probabilité d’infection d’une personne.

print (" Dans votre classe, il y a",(nb_personne*t*Q**2*f**2*quantum)/(L*volume), "% de chance que quelqu'un soit infecté.")#calcul de la probabilité

Problèmes rencontrés

Le premier problème qu’on a pu rencontrer est le suivant : rendre une variable locale globale. La variable calculée dans la fonction était perdue si on ne la sauvegardait pas dans une nouvelle variable globale.

On a trouvé deux moyens de contrer ce problème :

Le premier est d’utiliser la fonction native « global ».

def temps_expo():#savoir le temps passé en classe en heure
    global t
    print("Combien de temps en heures passez-vous en classe en moyenne ? ")
    print()
    print("1 - entre 0 et 3 heures.")
    print("2 - entre 3 et 6 heures.")
    print("3 - entre 6 et 9 heures.")
    print()
    choix = int(input("Veuillez selectionner votre choix:\t"))
    if choix == 1:
        T = 2
    elif choix == 2:
        T = 5
    elif choix == 3:
        T = 8
    else:#permet de renvoyer au début de la fonction si le choix ne convient pas
        print()
        print("Votre choix n'est pas valide, veuillez taper 1, 2 ou 3 s'il vous plait.")
        print()
        temps_expo()
     t = T

Et le deuxième est d’exécuter la fonction directement dans la fonction globale et en même temps, assigner la valeur que la fonction renvoie à une nouvelle variable.

def proba_totale(): #probabilité d'infection
    print("------------------------------------------------------")
    print("|                       COVID                        |")
    print("------------------------------------------------------")
    t = temps_expo()

Le deuxième problème était : le « return » de la fonction qui ne marchait pas.

Pour résoudre ce problème, nous avons tout simplement décidé de remplacer le « return » par un « print ».

	print (" Dans votre classe, il y a",(nb_personne*t*Q**2*f**2*quantum)/(L*volume), "% de chance que quelqu'un soit infecté.")#calcul de la probabilité
    # return (nb_personne*t*Q**2*f**2*quantum)/(L*volume)

Conclusion

Ce simulateur permet de calculer la probabilité d’infection d’une personne dans un espace fermé par conséquent il peut permettre de faire réagir certaines personnes qui ne respectent pas les règles mises en place par le gouvernement : ce programme a aussi un objectif de sensibilisation.

En bas de la page, vous pourrez télécharger le programme.

Crédits

Toutes les informations et la formule utilisées proviennent de la chaine youtube Scienceetonnante tenu par David Louapre, un physicien et la vidéo d’où nous avons tiré toutes nos informations est inspirée des recherches de physiciens du MIT basé aux Etats-Unis : Bazant M. Z., & Bush J. W..

Projets

Machine à sous en python

Vous connaissez le casino non ? Impossible de gagner vous me direz… pour ce projet, ce n’est pas le cas, en effet nous vous garantissions une machine à sous 100% gagnante pour n… pour vous !

Vous possédez 10 000 euros, et vous pouvez misez autant d’argent que vous voulez… si vous gagnez, vous multipliez votre mise par 10 !!!!

Au moins une victoire est GARANTIE, puise que vous pouvez nous faire des crédits à l’ infini*

*bonne chance pour rembourser après

Le fonctionnement du jeu est très simple, on vous demande la somme miser, le jeu se lance, et si 3 symboles identiques s’alignent, vous gagnez (par exemple : ♢♢♢ ou ♠♠♠). Vous pouvez choisir de partir quand vous voulez , et si vous n’avez plus d’argent, vous pouvez demander des crédits pour jouer encore, ceux ci seront a rembourser. En choisissant de miser 0 vous pourrez rembourser vos dette ou choisir d’arrêter les frais.

Fonction mise et jeu :

# mise
def mise_et_jeu():
    porte_monnaie = 10000
    while porte_monnaie > 0:
        print("\nil vous reste :", porte_monnaie, "\n")
        mise=int(input("Choissisez la somme a miser : "))
        if mise > porte_monnaie:
            print("on ne peut pas jouer avec de l'argent imaginaire....\n")
        elif mise == 0:
            print("votre porte monnaie vaut", porte_monnaie)
            fin_2()
            break

        else:
            porte_monnaie -= mise
       
            # Partie jeu
            tirage_cumul = 1
            for i in range(3):          
                tirage_unitaire = choice([2,3,5,7])
                tirage_cumul = tirage_cumul  * tirage_unitaire
            
                if tirage_unitaire == 2:
                    print("♡", end=" ")
                    sleep(pause)
                elif tirage_unitaire == 3:
                    print("♢", end=" ")
                    sleep(pause)
                elif tirage_unitaire == 5:
                    print("♣", end=" ")
                    sleep(pause)
                elif tirage_unitaire == 7:
                    print("♠", end=" ")
                    sleep(pause)
            
           # récompense et affichage du résultat
            if tirage_cumul in [8,27,125,343]:
                porte_monnaie += 10*mise
                print("\nBravo !!!!!!, vous avez gagné dix fois votre mise")
            elif porte_monnaie > 0:
                print("\nVous avez perdu, essayez encore une fois")
            else:
                print("\nVous avez perdu")
    else:
        if porte_monnaie == 0:
            fin()

La fonction mise et jeu est la plus importante de notre script, elle permet a notre script de fonctionner. C’est cette fonction qui demande la mise au joueur et qui tire 3 symboles au hasard, déterminant ainsi la victoire ou la défaite.

Les différentes fins :

    
#fin
def fin():
    # porte monnaie
    global porte_monnaie
    print("Vous êtes à sec")
    sleep (2*pause)
    print("vous pouvez faire des crédits d'un montatnt de 10 000 €, celui-ci", 
          " sera à rembourser dans un an au plus tard")
    sleep(pause)
        
    # demande de prêt
    pret = int(input("Pour faire un crédit taper 1 :"))
    if pret == 1:
        porte_monnaie += 10000
        credit()
    else:
        fin_3()
#fin alternative
def fin_2():
    choix = int(input("Si vous voulez quitter taper 1\n"
                       "\nSi vous voulez rejouer taper 2\n"
                       "\nSi vous voulez rembourser votre dette taper 3\n"
                       "\nVotre réponse:"))
    if choix == 1:
        global porte_monnaie
        print("Merci d'avoir joué, il vous reste:", porte_monnaie, "€")
    elif choix == 2:
        mise_et_jeu()
    elif choix == 3:
        global dette
        if dette > 0:
            remboursement()
        else:
            print("Vous n'avez aucune dette à rembourser")
            mise_et_jeu()
    else:
        print ("Votre choix ne correspond pas\n""Merci d'avoir joué")
    
#fin alternative
def fin_3():          
        global dette
        if dette > 0:
            print("Votre dette s'élève à:", dette, "€",
                  "\nelle sera à rembourser dans un an au plus tard\n")
            print("Merci d'avoir joué et au revoir")
        else:
            print("Merci d'avoir joué et au revoir")

(ainsi que les définitions remboursement et crédit nécessaire aux différentes fins du jeu)

#credit
def credit():
    global dette
    dette += 10000
    print ("Votre dette s'élève à:", dette, "€")
    mise_et_jeu()

#remboursement
def remboursement():
    global dette
    global porte_monnaie
    argent = int(input("Rentrer la somme à rembourser:"))
    if argent > porte_monnaie:
        print("on ne peut pas payer avec de l'argent imaginaire")
    elif argent < dette:
        porte_monnaie -= argent
        dette -= argent
        print("Il vous reste ", dette, "à rembourser et vous avez",
              porte_monnaie, "€")
    elif argent == dette:
        porte_monnaie -= argent
        dette -= argent
        print("Vous n'avez plus de dette à rembourser et vous avez",
              porte_monnaie, "€")
        fin_2()

Les difficultés rencontrées :

  • nous n’avions pas mis de fonctions dans un premiers temps, et il a été dur de les créer pour chaque parties du script et de les relier entres elles
  • Nous ne connaissions pas la fonction global quand nous avons fais le script et par conséquent il était impossible pour nous d’utiliser la même variable dans plusieurs fonctions.

Pour tester notre machine a sous :

Projets

Hexapawn, ou une IA évolutive simple en Python

Comment ça on peut coder des IA qui apprennent en Python en 1ère ? C’est pas censé être un truc ultra pointu ? Eh bien en fait c’est relativement facile à faire pour des jeux aux règles simples comme l’Hexapawn.

Un Hexapawn, quésaco

Il s’agit d’un jeu d’échec miniature, qui se joue sur un plateau de jeu constitué de 9 cases (3×3), et dans lequel chaque joueur possède 3 pions – d’où le nom: hexa, six et pawn, pion en anglais.

Les règles du jeu sont simples: les pions se déplacent comme des pions d’échec:

  • Ils ne se déplacent que d’une case à la fois et uniquement vers l’avant
  • Ils ne peuvent manger qu’en diagonale, là aussi dans un rayon d’une case

Le but est de réussir à amener l’un de ses pions de l’autre côté du plateau ou d’éliminer la totalité des pions adverses.

Dans le cas ou aucun pion ne peut plus bouger, il y a égalité

Ce projet a été inspiré par une vidéo de Vsauce2, une chaîne présentant divers jeux ayant lien avec les mathématiques ou la logique.

Particularités du jeu

Comme les règles de l’Hexapawn sont très simples, il suffit simplement d’empêcher l’ordi de refaire des mouvements qui l’ont amené à perdre afin de le faire s’améliorer au fur et a mesure qu’il joue.

La principale difficulté dans la réalisation de ce projet a été de devoir prendre en compte toutes les possibilités de jeu, ce qui rend au final le script assez long.

En bonus, on s’est dit que ce serait sympa d’ajouter un menu afin de personnaliser les couleurs de l’interface

Commencer le projet : les Libraries nécessaires

Ce jeu a été entièrement codé en Python, et en Python, la première chose à faire lorsqu’on commence quelque chose est d’importer les Libraries (programmes externes) nécessaires pour sa réalisation.

#les différentes libraries nécessaires
from tkinter import *
import tkinter as tk
from functools import partial
from random import *
import webbrowser

Les différentes libraries que nous avons choisi d’utiliser sont les suivantes :

  • tkinter (abrégé de ToolKit Interface) qui permet de créer une interface graphique,
  • la fonction partial de la library functools, qui va nous être utile lors de la création des différents boutons,
  • random, qui va permettre d’ajouter de l’aléatoire dans certaines actions,
  • webbrowser, qui va permettre d’ouvrir des pages web.

Maintenant que l’on a importé tous les modules nécessaires, on va pouvoir commencer à coder le projet en lui-même.

Configuration de la fenêtre

Comme l’on utilise tkinter afin de pouvoir donner une interface graphique à notre jeu, on va commencer par configurer notre fenêtre (taille, titre, couleur de fond etc…)

couleur = "#424242"

#mise en place de la fenêtre
window = Tk()
window.title("♟ Hexapawn ♟")
window.geometry("1080x720")
window.config(bg=couleur)

Ici on a donc une fenêtre de couleur grise, dont le titre est « ♟ Hexapawn ♟ » et dont la taille est de 1080 x 720 pixels

Création des variables

Une fois la fenêtre créée, on configure les variables qui seront utilisées par le script (le nombre de points de chacun, l’état des cases -vides au début-, les différentes variables à afficher…)

#définition de certaines variables
couleur_texte = "#666666"
couleur_selection = "#cccccc"
couleur_ordi = "#000000"
couleur_joueur = "#ffffff"
tour = 0
pions_joueur = 3
pions_ordi = 3
pions_bloques = 0
resultat = ""
coups_perdants = []
coups_gagnants = []
jeu = ""
a1 = ""
a2 = ""
a3 = ""
b1 = ""
b2 = ""
b3 = ""
c1 = ""
c2 = ""
c3 = ""
ordi_gagne = False
joueur_gagne = False
egalite = False
points_ordi = 0
points_joueur = 0

Tkinter ne peut pas afficher des variables classiques dans les fenêtres, c’est pourquoi il est nécessaire de créer des variables spéciales que l’on déclare comme ceci :

#définition des variables qui seront affichées dans l'interface tkinter
a1_display = tk.StringVar()
a2_display = tk.StringVar()
a3_display = tk.StringVar()
b1_display = tk.StringVar()
b2_display = tk.StringVar()
b3_display = tk.StringVar()
c1_display = tk.StringVar()
c2_display = tk.StringVar()
c3_display = tk.StringVar()
resultat_display = tk.StringVar()
score_ordi_display = tk.IntVar()
score_joueur_display = tk.IntVar()
valeur = tk.StringVar()
contour_texte = tk.StringVar()
contour_texte.set('''
⎟
⎟
⎟
⎟
⎟
⎟
⎟
⎟
⎟
⎟
⎟
⎟
''')

Comme la majorité de ces variables tkinter sont associées à des variables classiques, nous avons décidé d’ajouter « _display » à la fin de leur nom pour pouvoir plus facilement les différencier.

Par exemple, la variable a1 sera associée à la variable tkinter a1_display qui sera actualisée dans le script à chaque fois que a1 change de valeur

Configuration des boites

Maintenant on crée les différentes boites. Elles permettront d’afficher les différents éléments qu’elles contiennent quand elles seront appelées (la boite menu, règle etc…) ou de ne plus les afficher lorsqu’elles seront oubliées.

#mise en place des différentes boites
boite_titre = Frame(window, bg=couleur)
boite_menu = Frame(window, bg=couleur)
boite_regles = Frame(window, bg=couleur)
boite_jeu = Frame(window, bg=couleur)
boite_ordi = Frame(window, bg=couleur)
boite_resultat = Frame(window, bg=couleur)
boite_couleurs = Frame(window, bg=couleur)
boite_couleurs2 = Frame(window, bg=couleur)

Mise en place des Labels

Afin d’avoir une interface claire, il est important d’ajouter des éléments textuels: titre, règles du jeu etc.

Dans tkinter, les éléments textuels sont nommés labels. On les déclare comme ceci:

#mise en place des différents éléments textuels
titre = Label(boite_titre, text =
              '''
 .----------------.  .----------------.  .----------------.  .----------------.  .----------------.  .----------------.  .----------------.  .-----------------.
| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
| |  ____  ____  | || |  _________   | || |  ____  ____  | || |      __      | || |   ______     | || |      __      | || | _____  _____ | || | ____  _____  | |
| | |_   ||   _| | || | |_   ___  |  | || | |_  _||_  _| | || |     /  \     | || |  |_   __ \   | || |     /  \     | || ||_   _||_   _|| || ||_   \|_   _| | |
| |   | |__| |   | || |   | |_  \_|  | || |   \ \  / /   | || |    / /\ \    | || |    | |__) |  | || |    / /\ \    | || |  | | /\ | |  | || |  |   \ | |   | |
| |   |  __  |   | || |   |  _|  _   | || |    > `' <    | || |   / ____ \   | || |    |  ___/   | || |   / ____ \   | || |  | |/  \| |  | || |  | |\ \| |   | |
| |  _| |  | |_  | || |  _| |___/ |  | || |  _/ /'`\ \_  | || | _/ /    \ \_ | || |   _| |_      | || | _/ /    \ \_ | || |  |   /\   |  | || | _| |_\   |_  | |
| | |____||____| | || | |_________|  | || | |____||____| | || ||____|  |____|| || |  |_____|     | || ||____|  |____|| || |  |__/  \__|  | || ||_____|\____| | |
| |              | || |              | || |              | || |              | || |              | || |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'  '----------------'  '----------------'  '----------------'  '----------------'  '----------------'

''', font=("consolas",7), bg = couleur, fg = couleur_texte)

sep = Label(boite_titre, text = "."*200, font=("consolas",7), bg = couleur, fg = couleur_texte)
regles_label = Label(boite_regles, text =
                     '''
Regles du jeu:

Vous possédez 3 pions, qui peuvent se déplacer comme des pions aux échecs:

-ils ne peuvent que se déplacer vers l'avant
-ils ne peuvent se déplacer que d'une case à la fois
-ils ne peuvent "manger" un pion adverse qu'en diagonale

2 conditions de victoire possibles:

-l'adversaire ne possède plus aucun pion
-vous parvenez à amener un pion à l'autre bout du plateau

Pour déplacer un pion, cliquez sur lui puis sur la case vers laquelle vous
voulez qu'il aille.
Lorsque vous avez joué, cliquez sur le bouton sous l'échéquier

'''
, font=("consolas",15), bg = couleur, fg = couleur_texte)
resultat_Label = Label(boite_resultat, text = "", font=("consolas",15), bg = couleur, fg = couleur_texte)
scores = Label(boite_resultat, text = "%s à %s" %(score_joueur_display.get(),score_ordi_display.get()), font=("consolas",15), bg = couleur, fg = couleur_texte)
retour_selection = Label(boite_couleurs, text = "", font=("consolas",10), bg = couleur, fg = couleur_texte)
contour1 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour2 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour3 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour4 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour5 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour6 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)

Pour le titre, nous avons décidé de l’écrire en ASCII à l’aide de ce générateur

Chaque Label possède plusieurs attributs: la boîte dans lequel il va apparaître, le texte qu’il contient, la police et la taille d’écriture, la couleur de fond et enfin la couleur de l’écriture.

Comme vous pouvez le constater, certains de ces Labels font appel à des variables tkinter qui nous avons précédemment définies comme celui-ci par exemple:

scores = Label(boite_resultat, text = "%s à %s" %(score_joueur_display.get(),score_ordi_display.get()), font=("consolas",15), bg = couleur, fg = couleur_texte)

Pour appeler ces variables, il suffit d’écrire leur nom suivi de .get()

Maintenant que l’on a défini les éléments texte, on va pouvoir s’attaquer aux différentes fonctions du script.

Premières fonctions: fonctions de navigation

Comme l’on a décidé d’utiliser une ineterface graphique pour ce projet, la plupart des fonctions seront appelées à l’aide de boutons.

#commande permettant d'afficher les règles du jeu
def command_regles():
    boite_menu.pack_forget()
    boite_regles.pack(pady = 25)

Cette fonction par exemple permettra d’afficher les règles du jeu. Il suffit d’ajouter .pack() à la fin du nom d’une boite pour la faire apparaître, et .pack_forget() pour la faire disparaître.

Ainsi, lorsque cette fonction sera appelée, les éléments de la boite_menu disparaîtront pour laisser place à ceux de la boite_regles

Cette fonction sera associée à un bouton de la manière suivante :

b_regles = Button(boite_menu, text = "Règles du jeu", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_regles)

On créé un nouvel élément nommé b_regles: un bouton (Button) à qui on donne différents attributs: une boite, un texte, une police et une taille, une couleur de fond, une couleur de texte, et surtout une fonction (l’attribut command) qui sera appelée en cas de clic.

Lorsque l’on cliquera sur ce bouton, la fonction command_regles sera exécutée, ce qui aura pour effet d’afficher les règles du jeu.

On procède de même avec les autres fonctions qui vont nous permettre de naviguer dans notre fenêtre :

#commande pour retourner au menu depuis les règles
def command_retour_regles():
    boite_menu.pack(pady = 25)
    boite_regles.pack_forget()

#commande pour afficher le menu de personnalisation des couleurs
def command_personnaliser():
    boite_menu.pack_forget()
    boite_couleurs.pack(pady = 25)
    boite_couleurs2.pack()

#commande pour retourner au menu principal depuis celui de personnalisation des couleurs
def command_retour_personnaliser():
    boite_menu.pack(pady = 25)
    boite_couleurs.pack_forget()
    boite_couleurs2.pack_forget()

Ainsi qu’avec leurs boutons respectifs

b_retour_regles = Button(boite_regles, text = "Retour", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_retour_regles)
b_personnaliser = Button(boite_menu, text = "Personnaliser", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_personnaliser)
b_retour_personnaliser = Button(boite_couleurs2, text = "Retour", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_retour_personnaliser)

Personnalisation des couleurs

Grâce au menu de personnalisation des couleurs, les utilisateurs du script pourront choisir les couleurs qui leur plait ainsi créant des mélanges uniques.

Ce menu est constitué de plusieurs boutons :

b_couleur1 = Button(boite_couleurs2, text = "Changer la couleur principale ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,0))
b_couleur2 = Button(boite_couleurs2, text = "Changer la couleur secondaire ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,1))
b_couleur3 = Button(boite_couleurs2, text = "Changer la couleur de selection", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,2))
b_couleur_joueur = Button(boite_couleurs2, text = " Changer la couleur du joueur ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,3))
b_couleur_ordi = Button(boite_couleurs2, text = " Changer la couleur de l'ordi ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,4))
b_personnaliser = Button(boite_menu, text = "Personnaliser", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_personnaliser)

couleur_entry = Entry(boite_couleurs, text = "#", textvariable=valeur, font=("Helvetica",15) , bg="white", fg="black")
b_ok = Button(boite_couleurs, text = "Cliquez pour appliquer", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = rien)

C’est ici que la fonction partial que nous avons importée va nous être utile: en effet, tous les boutons de ce menu vont exécuter la même fonction, mais avec un paramètre différent, ce qui nous permet de n’écrire qu’une seule fonction au lieu de 5 différentes.

def changer_couleur(test):
    b_ok.config(command = partial(appliquer,test))
    if test == 0:
        retour_selection.config(text = "couleur principale")
    elif test == 1:
        retour_selection.config(text = "couleur secondaire")
    elif test == 2:
        retour_selection.config(text = "couleur de sélection")
    elif test == 3:
        retour_selection.config(text = "couleur du joueur")
    elif test == 4:
        retour_selection.config(text = "couleur de l'ordi")

def appliquer(test):
    global couleur, couleur_texte, couleur_selection, couleur_joueur, couleur_ordi
    if test == 0:
        couleur = str(valeur.get())
    elif test == 1:
        couleur_texte = str(valeur.get())
    elif test == 2:
        couleur_selection = str(valeur.get())
    elif test == 3:
        couleur_joueur = str(valeur.get())
    elif test == 4:
        couleur_ordi = str(valeur.get())
    window.config(bg = couleur)
    titre.config(bg = couleur, fg = couleur_texte)
    sep.config(bg = couleur, fg = couleur_texte)
    boite_titre.config(bg = couleur)
    boite_menu.config(bg = couleur)
    boite_regles.config(bg = couleur)
    boite_jeu.config(bg = couleur)
    boite_ordi.config(bg = couleur)
    boite_resultat.config(bg = couleur)
    boite_couleurs.config(bg = couleur)
    boite_couleurs2.config(bg = couleur)
    b_a1.config(bg = couleur_texte)
    b_a2.config(bg = couleur)
    b_a3.config(bg = couleur_texte)
    b_b1.config(bg = couleur)
    b_b2.config(bg = couleur_texte)
    b_b3.config(bg = couleur)
    b_c1.config(bg = couleur_texte)
    b_c2.config(bg = couleur)
    b_c3.config(bg = couleur_texte)
    b_jouer.config(bg = couleur_texte, fg = couleur)
    b_regles.config(bg = couleur_texte, fg = couleur)
    b_retour_regles.config(bg = couleur_texte, fg = couleur)
    b_personnaliser.config(bg = couleur_texte, fg = couleur)
    b_retour_personnaliser.config(bg = couleur_texte, fg = couleur)
    b_couleur1.config(bg = couleur_texte, fg = couleur)
    b_couleur2.config(bg = couleur_texte, fg = couleur)
    b_couleur3.config(bg = couleur_texte, fg = couleur)
    b_couleur_ordi.config(bg = couleur_texte, fg = couleur)
    b_couleur_joueur.config(bg = couleur_texte, fg = couleur)
    b_rejouer.config(bg = couleur_texte, fg = couleur)
    b_ordi.config(bg = couleur_texte, fg = couleur)
    b_trouver_hex.config(bg = couleur_texte, fg = couleur)
    b_ok.config(bg = couleur_texte, fg = couleur)
    regles_label.config(bg = couleur, fg = couleur_texte)
    b_retour_jeu.config(bg = couleur_texte, fg = couleur)
    scores.config(bg = couleur, fg = couleur_texte)
    resultat_Label.config(bg = couleur, fg = couleur_texte)
    retour_selection.config(bg = couleur, fg = couleur_texte)
    contour1.config(bg = couleur, fg = couleur_texte)
    contour2.config(bg = couleur, fg = couleur_texte)
    contour3.config(bg = couleur, fg = couleur_texte)
    contour4.config(bg = couleur, fg = couleur_texte)
    contour5.config(bg = couleur, fg = couleur_texte)
    contour6.config(bg = couleur, fg = couleur_texte)

Lorsque le bouton « Cliquez pour appliquer » est cliqué la fonction appliquer est exécutée avec un paramètre différent en fonction du bouton sélectionné auparavant.

La fonction change la couleur demandée puis rafraîchit tous les éléments différents afin que le changement de couleur apparaisse.

Il est à noter que le script ne comprend que certains noms de couleur en anglais ou les couleurs données en hexadécimal

Ce menu comporte aussi un bouton permettant d’ouvrir une page web avec un panneau pour sélectionner la couleur de son choix et avoir son code en hexadécimal :

b_trouver_hex = Button(boite_couleurs2, text = "    Trouver des couleurs     ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = pick_hex)

L’ouverture de la page depuis le script est faite grâce a la Library webbrowser

def pick_hex():
    webbrowser.open_new("https://www.google.com/search?client=opera-gx&q=color+picker&sourceid=opera&ie=UTF-8&oe=UTF-8")

Mise en place du plateau de jeu

Après avoir lu les règles du jeu et modifié les couleurs si nécessaire on peut enfin jouer.

En cliquant sur le bouton jouer on exécute la commande suivante :

def command_jouer():
    boite_resultat.pack_forget()
    boite_jeu.pack(pady = 25)
    boite_ordi.pack(pady = 25)
    boite_menu.pack_forget()
    global a1 , a2 , a3 , b1 , b2 , b3 , c1 , c2 , c3 , pions_ordi, pions_joueur, pions_bloques, ordi_gagne, egalite, joueur_gagne, tour, couleur_ordi, couleur_joueur, jeu
    jeu = ""
    a1 , a2 , a3 , b1 , b2 , b3 , c1 , c2 , c3 = "♟" , "♟" , "♟" , "  " , "  " , "  " , "♙" , "♙" , "♙"
    a1_display.set(a1)
    a2_display.set(a2)
    a3_display.set(a3)
    b1_display.set(b1)
    b2_display.set(b2)
    b3_display.set(b3)
    c1_display.set(c1)
    c2_display.set(c2)
    c3_display.set(c3)
    b_a1.config(text = a1_display.get(), fg = couleur_ordi)
    b_a2.config(text = a2_display.get(), fg = couleur_ordi )
    b_a3.config(text = a3_display.get(), fg = couleur_ordi )
    b_b1.config(text = b1_display.get() )
    b_b2.config(text = b2_display.get() )
    b_b3.config(text = b3_display.get() )
    b_c1.config(text = c1_display.get(), fg = couleur_joueur )
    b_c2.config(text = c2_display.get(), fg = couleur_joueur )
    b_c3.config(text = c3_display.get(), fg = couleur_joueur )
    pions_ordi = 3
    pions_joueur = 3
    pions_bloques = 0
    joueur_gagne = False
    ordi_gagne = False
    egalite = False
    tour = 0
    tester_cases_selectionnables()

Elle permet de mettre en place le plateau de jeu en faisant apparaître les boites boite_jeu et boite_ordi et en faisant disparaître les autres.

Ensuite les pions sont placés sur le plateau et le compteur de tours, et ceux des pions sont mis à leurs valurs initiales

Enfin, le script teste les cases à partir desquelles l’on peut bouger nos pions à l’aide de la fonction tester_cases_selectionnables().

Les possibilités de déplacement

La fonction « tester_cases_selectionnables() » teste les cases sur lesquels se trouve les pions du joueur et permet au joueur de cliquer le bouton si jamais un de ses pions y est présent.

def tester_cases_selectionnables():
    if c1 == "♙":
        b_c1.config(command = partial(selected,"c1"), fg = couleur_joueur )

    if c2 == "♙":
        b_c2.config(command = partial(selected,"c2"), fg = couleur_joueur  )

    if c3 == "♙":
        b_c3.config(command = partial(selected,"c3"), fg = couleur_joueur  )

    if b1 == "♙":
        b_b1.config(command = partial(selected,"b1"), fg = couleur_joueur  )

    if b2 == "♙":
        b_b2.config(command = partial(selected,"b2"), fg = couleur_joueur  )

    if b3 == "♙":
        b_b3.config(command = partial(selected,"b3"), fg = couleur_joueur  )

Ensuite, selon la case sélectionnée le script étudie les mouvements possibles et modifie les commandes éxécutées en cas de clic sur la case en conséquence :

def selected(case):
    global a1, a2, a3, b1, b2, b3, c1, c2, c3
    global tour

    if tour == 0 :

        if case == "c1":
            b_b1.config(command = partial(jouer_vers,"c1","b1"))
            b_b2.config( command = rien)
            b_b3.config(command = rien)
            b_c1.config(fg=couleur_selection)
            b_c2.config(fg=couleur_joueur)
            b_c3.config(fg=couleur_joueur)
            b_b2.config(command = rien)
            b_b3.config(command = rien)

        elif case == "c2":
            b_b2.config(command = partial(jouer_vers,"c2","b2"))
            b_c2.config(fg=couleur_selection)
            b_c1.config(fg=couleur_joueur)
            b_c3.config(fg=couleur_joueur)
            b_b1.config(command = rien)
            b_b3.config(command = rien)
#et ainsi de suite avec les autres cases
    elif tour >= 2:

        if case == "c1":
            reset_commandes()
            tester_cases_selectionnables()
            b_c1.config(fg=couleur_selection)
            if b1 == "  ":
                b_b1.config(command = partial(jouer_vers,"c1","b1"))
            if b2 == "♟":
                b_b2.config(command = partial(jouer_vers,"c1","b2"))

        elif case == "c2":
            reset_commandes()
            tester_cases_selectionnables()
            b_c2.config(fg=couleur_selection)
            if b2 == "  ":
                b_b2.config(command = partial(jouer_vers,"c2","b2"))
            if b1 == "♟":
                b_b1.config(command = partial(jouer_vers,"c2","b1"))
            if b3 == "♟":
                b_b3.config(command = partial(jouer_vers,"c2","b3"))
#etc...

Après avoir choisi le pion qu’il souhaitait déplacer, le joueur va cliquer sur la case vers laquelle il veut que le pion se déplace.

La fonction jouer_vers va alors être exécutée avec en paramètres la case de départ et la case d’arrivée du pion.

La fonction va rendre vide la case de départ du pion et va mettre un pion blanc dans la case d’arrivée

def jouer_vers(case1, case2):
    global tour, jeu
    global a1, a2, a3, b1, b2, b3, c1, c2, c3
    global pions_ordi, ordi_gagne

    if tour / 2 == tour // 2 and not ordi_gagne:

        if case1 == "c1":
            c1 = "  "
            c1_display.set(c1)
            b_c1.config(text = c1_display.get())

        elif case1 == "c2":
            c2 = "  "
            c2_display.set(c2)
            b_c2.config(text = c2_display.get())
#etc...
        if case2 == "b1":
            if b1 == "♟":
                pions_ordi -= 1
            b1 = "♙"
            b1_display.set(b1)
            b_b1.config(text = b1_display.get(), fg = couleur_joueur)
            jeu += case2

        elif case2 == "b2":
            if b2 == "♟":
                pions_ordi -= 1
            b2 = "♙"
            b2_display.set(b2)
            b_b2.config(text = b2_display.get(), fg = couleur_joueur)
            jeu += case2
#etc...

Si le joueur a réussi à amener l’un de ses pions de l’autre côté, il gagne un point et le résultat de la partie est affiché avec les scores.

Sinon, c’est à l’ordi de jouer.

        elif case2 == "a3":
            a3 = "♙"
            a3_display.set(a3)
            b_a3.config(text = a3_display.get(), fg = couleur_joueur)
            joueur_gagne = True
            coups_perdants.append(jeu)

        tour += 1

    if pions_joueur == 0:
        ordi_gagne = True

    if ordi_gagne :
        boite_jeu.pack_forget()
        resultat = "Défaite"
        resultat_display.set(resultat)
        resultat_Label.config(text = resultat_display.get())
        boite_resultat.pack()

    else:
        pass

L’IA

Les mouvements possible de l’ordinateur sont étudiés par la fonction « ordi() ».

#début de la fonction ordi()
def ordi():
    global tour
    global a1, a2, a3, b1, b2, b3, c1, c2, c3
    global pions_joueur, points_joueur, ordi_gagne, points_ordi, pions_ordi, joueur_gagne, pions_bloques, resultat, egalite, coups_gagnants, coups_perdants, jeu, couleur_ordi

Elle étudie tout d’abord si il y a un vainqueur ou une égalité ( grâce à la fonction « tester_tie() » expliquée un peu plus plus loin ) .

    if pions_ordi == 0:
        joueur_gagne = True
    if pions_joueur == 0:
        ordi_gagne = True
    tester_tie()


    if pions_bloques == pions_ordi:
        egalite = Tr

Si il n’y a pas de vainqueur ou d’égalité et que c’est au tour de l’ordi de jouer, le script analyse les mouvements possibles de l’ordinateur. si il s’aperçoit qu’un mouvement l’a amené à perdre dans une configuration similaire, il ne l’inclura pas dans la liste des mouvements possibles.

Si, au contraire un des mouvements l’a fait gagner précédemment, il le mettra dans une liste spéciale

 elif tour/2 != tour//2 and not joueur_gagne and not ordi_gagne :
            mvt_possibles = []
            mvt_gagnants = []
            if a1 == "♟":
                if b1 == "  " and jeu + "a1b1" not in coups_perdants :
                    mvt_possibles.append("a1b1")
                    if jeu + "a1b1" in coups_gagnants:
                        mvt_gagnants.append("a1b1")

                if b2 == "♙" and jeu + "a1b2" not in coups_perdants:
                    mvt_possibles.append("a1b2")
                    if jeu + "a1b2" in coups_gagnants:
                        mvt_gagnants.append("a1b2")


            if a2 == "♟":
                if b1 == "♙" and jeu + "a2b1" not in coups_perdants :
                    mvt_possibles.append("a2b1")
                    if jeu + "a2b1" in coups_gagnants:
                        mvt_gagnants.append("a2b1")

                if b2 == "  " and jeu + "a2b2" not in coups_perdants:
                    mvt_possibles.append("a2b2")
                    if jeu + "a2b2" in coups_gagnants:
                        mvt_gagnants.append("a2b2")

                if b3 == "♙" and jeu + "a2b3" not in coups_perdants:
                    mvt_possibles.append("a2b3")
                    if jeu + "a2b3" in coups_gagnants:
                        mvt_gagnants.append("a2b3")
#et ainsi de suite avec toutes les cases...

Ensuite, la fonction teste si des mouvements possibles peuvent amener l’ordi à gagner à coup sûr. Si c’est le cas, un mouvement aléatoire est pioché parmi la liste mvt_gagnants.

Sinon, l’ordi choisit un mouvement aléatoire parmi les mouvements possibles.

            if mvt_gagnants != []:
                mvt_ordi = mvt_gagnants[randint(0,len(mvt_gagnants)-1)]
            else:
                mvt_ordi = mvt_possibles[randint(0,len(mvt_possibles)-1)]

Le mouvement choisi est ensuite « joué »

            if mvt_ordi == "a1b1":
                a1 = "  "
                a1_display.set(a1)
                b_a1.config(text = a1_display.get())
                b1 = "♟"
                b1_display.set(b1)
                b_b1.config(text = b1_display.get(), fg = couleur_ordi)

            elif mvt_ordi == "a1b2":
                a1 = "  "
                a1_display.set(a1)
                b_a1.config(text = a1_display.get())
                b2 = "♟"
                b2_display.set(b2)
                b_b2.config(text = b2_display.get(), fg = couleur_ordi)
                pions_joueur -= 1
#etc...
            elif mvt_ordi == "b1c1":
                b1 = "  "
                b1_display.set(b1)
                b_b1.config(text = b1_display.get())
                c1 = "♟"
                c1_display.set(c1)
                b_c1.config(text = c1_display.get(), fg = couleur_ordi)
                ordi_gagne = True

Le coup joué est ensuite ajouté à la variable jeu.

Si le mouvement amène l’ordi à prendre un pion, le nombre de pions du joueur est décrémenté de 1

Si l’ordi a amené l’un de ses pions de l’autre côté, la variable ordi_gagne devient « vraie » (True)

            jeu += mvt_ordi

Si l’ordi a gagné, c’est à dire si ordi_gagne est True, son score est incrémenté, la variable « jeu » est ajouté à la liste des coups gagnants et le score ainsi que le résultat de la partie sont affichés

            if ordi_gagne:
                coups_gagnants.append(jeu)
                reset_commandes()
                boite_ordi.pack_forget()
                points_ordi += 1
                resultat = "Défaite"
                resultat_display.set(resultat)
                resultat_Label.config(text = resultat_display.get())
                score_ordi_display.set(points_ordi)
                score_joueur_display.set(points_joueur)
                scores.config(text = "%s à %s" %(score_joueur_display.get(), score_ordi_display.get()) )
                boite_resultat.pack()

Ensuite, on passe au tour suivant.

Si le joueur avait déjà gagné au début du tour (l’ordi n’a donc pas joué) ou s’il y a égalité le score est incrémenté en conséquence et l’issue de la partie est affichée

Si aucune de ces conditions n’est vérifiées, c’est au tour du joueur de jouer.

            tour +=1
            reset_commandes()
            tester_cases_selectionnables()
            tester_tie()




    if pions_bloques == pions_ordi:
        egalite = True


    if egalite:
        reset_commandes()
        boite_ordi.pack_forget()
        resultat = "Egalité"
        resultat_display.set(resultat)
        resultat_Label.config(text = resultat_display.get())
        boite_resultat.pack()

    elif joueur_gagne:
        coups_perdants.append(jeu)
        reset_commandes()
        boite_ordi.pack_forget()
        points_joueur += 1
        resultat = "Victoire"
        resultat_display.set(resultat)
        resultat_Label.config(text = resultat_display.get())
        score_ordi_display.set(points_ordi)
        score_joueur_display.set(points_joueur)
        scores.config(text = "%s à %s" %(score_joueur_display.get(), score_ordi_display.get()) )
        boite_resultat.pack()

    else:
        pass

Gagnant, perdant ou ex æquo

Plisieurs conditions peuvent mettre fin à la partie

  • Le joueur ou l’ordi amène l’un de ses pions de l’autre côté du plateau
  • le joueur ou l’ordi ne possèdent plus de pions
  • Tous les pions sont bloqués

Les deux premières conditions sont facilement vérifiables et sont déjà testées directement dans les fonctions ordi() et jouer_vers()

On teste donc s’il y a égalité à l’aide de la fonction tester_tie(), appelée à l’interieur de la fonction ordi() comme vu précédemment.

Cette fonction teste tout simplement pour chaque case si le pion présent n’a plus de possibilités de mouvement, et ajoute au compteur de pions bloqués 1 si jamais le pion ne peut plus bouger.

def tester_tie():
    global a1, a2, a3, b1, b2, b3, c1, c2, c3, pions_bloques
    pions_bloques = 0
    if a1 == "♟":
        if b1 == "♙":
            if b2 == "♟" or b2 == "  ":
                pions_bloques += 1
            else:
                pass
        else:
            pass

    if a2 == "♟":
        if b2 == "♙":
            if b1 == "♟" or b1 == "  ":
                if b3 == "♟" or b3 == "  ":
                    pions_bloques += 1
                else:
                    pass
            else:
                pass
        else:
            pass

    if a3 == "♟":
        if b3 == "♙":
            if b2 == "♟" or b2 == "  ":
                pions_bloques += 1
            else:
                pass
        else:
            pass

    if b1 == "♟":
        if c1 == "♙":
            if c2 == "♟" or c2 == "  ":
                pions_bloques += 1
            else:
                pass
        else:
            pass


    if b2 == "♟":
        if c2 == "♙":
            if c1 == "♟" or c1 == "  ":
                if c3 == "♟" or c3 == "  ":
                    pions_bloques += 1
                else:
                    pass
            else:
                pass
        else:
            pass


    if b3 == "♟":
        if c3 == "♙":
            if c2 == "♟" or c2 == "  ":
                pions_bloques += 1
            else:
                pass
        else:
            pass

Si jamais tous les pions de l’ordi sont bloqués il y a égalité

if pions_bloques == pions_ordi:
        egalite = True

if egalite:
        reset_commandes()
        boite_ordi.pack_forget()
        resultat = "Egalité"
        resultat_display.set(resultat)
        resultat_Label.config(text = resultat_display.get())
        boite_resultat.pack()

L’affichage

Maintenant que toutes les fonction sont définies, il faut afficher tous les différents éléments de la fenêtre:

titre.pack()
sep.pack()
contour1.grid(row = 0, column = 1 , sticky = W, padx = 100, pady = 0)
contour2.grid(row = 1, column = 1 , sticky = W, padx = 100, pady = 0)
contour3.grid(row = 2, column = 1 , sticky = W, padx = 100, pady = 0)
b_jouer.grid(row = 0, column = 2 , sticky = W, pady = 0)
b_regles.grid(row = 1, column = 2 , sticky = W, pady = 0)
b_personnaliser.grid(row = 2, column = 2 , sticky = W, pady = 0)
contour4.grid(row = 0, column = 3 , sticky = W, padx = 100, pady = 0)
contour5.grid(row = 1, column = 3 , sticky = W, padx = 100, pady = 0)
contour6.grid(row = 2, column = 3 , sticky = W, padx = 100, pady = 0)
regles_label.pack()
b_retour_regles.pack()
b_a1.grid(row = 0, column = 0, sticky = W)
b_a2.grid(row = 0, column = 1, sticky = W)
b_a3.grid(row = 0, column = 2, sticky = W)
b_b1.grid(row = 1, column = 0, sticky = W)
b_b2.grid(row = 1, column = 1, sticky = W)
b_b3.grid(row = 1, column = 2, sticky = W)
b_c1.grid(row = 2, column = 0, sticky = W)
b_c2.grid(row = 2, column = 1, sticky = W)
b_c3.grid(row = 2, column = 2, sticky = W)
b_ordi.pack(pady = 15)
b_retour_jeu.pack(pady = 15)
resultat_Label.pack(pady = 15)
scores.pack(pady = 15)
b_rejouer.pack(pady = 15)
boite_titre.pack()
boite_menu.pack(pady = 25)
retour_selection.pack(pady = 10)
couleur_entry.pack(pady = 15)
b_ok.pack(pady = 10)
b_couleur1.grid(row = 0, column = 0, sticky = W, pady = 5, padx = 5)
b_couleur2.grid(row = 0, column = 1, sticky = W, pady = 5, padx = 5)
b_couleur3.grid(row = 0, column = 2, sticky = W, pady = 5, padx = 5)
b_couleur_joueur.grid(row = 1, column = 0, sticky = W, pady = 5, padx = 5)
b_couleur_ordi.grid(row = 1, column = 1, sticky = W, pady = 5, padx = 5)
b_trouver_hex.grid(row = 1, column = 2, sticky = N, pady = 5, padx = 5)
b_retour_personnaliser.grid(row = 2, column = 1, sticky = N, pady = 10, padx = 5)

Et surtout ne pas oublier d’ouvrir la fenêtre en cas d’exéction du script

window.mainloop()

Captures d’écran

Si vous souhaitez vous mesurer à cette IA et vérifier qu’elle apprend bel et bien de ses erreurs, vous pourrez télécharger le script du projet (défi : dépasser un score de 17!).

Projets

Le jeu du plus ou moins en python

Le principe du jeu est de trouver le nombre de l’ordinateur en un certains nombres de tentatives. Si le joueur ne trouve pas ce nombre en ce certains nombres de tentatives, la partie prend fin mais aussi lorsque le joueur trouve le nombre généré aléatoirement par l’ordinateur.

Introduction

Ce jeu a été réalisé par un élève en première et spécialité NSI.

Jouez au jeu du plus ou moins sur ordinateur ou sur un émulateur qui soit compatible avec le module tkinter !

Dans le cadre de mon projet, le jeu a été codé en python sous 2 formes différentes :

La première qui permet au joueur de jouer directement via la console d’exécution de son application :

La seconde qui permet au joueur de jouer dans un terminal appart soit dans une nouvelle fenêtre :

Évolution

Jeu dans la console d’exécution

  • L’importation des modules et variables

Le module randint est un module aléatoire donne accès à diverses fonctions utiles et l’une d’elles est capable de générer des nombres aléatoires. Elle s’écrit de cette façon : randint(start, end)

J’ai crée 5 variables nombres : La 1ère définit notre nombre d’essais maximum, la 2nde notre nombre d’essais au départ, la 3ème le nombre du joueur, la 4ème et la 5ème sont liée car ici nous faisons appel a la variable nombre_max_ordi dans la fonction randit().

from random import randint

essais_max= 5  # nombre d'essais maximum
essais = 1   # nombre essais
nombre_joueur = 0   # nombre du joueur au départ
nombre_max_ordi = 25  # nombre maximum généré par l'ordinateur
nombre_ordi = randint(1,nombre_max_ordi)   # nombre choisi par l'ordinateur
  • Affichage

La fonction print permet d’afficher a l’écran du texte.

print("L'ordinateur a choisi un nombre entre 1 et",nombre_max_ordi, ".")
print("Vous devez le trouver en moins de 5 tentatives !")
  • Boucle while

En anglais  » while  » signifie « Tant que ». Pour créer une boucle , il faut donc utiliser ce mot clé suivi d’une indication qui dit quand la boucle s’arrête.

Ici notre boucle ne s’arrêtera pas tant que quand le nombre de l’ordinateur ne sera pas égal au nombre du joueur et que son nombre d’essais soit inférieur ou égal au nombre d’essais maximum.

if, elif et else sont des conditions incrémenté dans notre boucle while.

if signifie « si ». Ici, elle marchera si le nombre du joueur est inférieur a celui de l’ordinateur.

elif est contraction de « else » et « if », qu’on pourrait traduire par « sinon ». Ici elle marchera si le nombre du joueur est supérieur a celui de l’ordinateur.

else signifie « autre ». Elle marchera si les conditions if et elif ne sont pas respectés. Entre autre le joueur aura gagné.

while nombre_ordi  != nombre_joueur and essais <= essais_max:
    print("vous êtes au", essais, "essai.")
    nombre_joueur = int(input("Choisissez un nombre :"))
    if nombre_joueur < nombre_ordi:
        print("Le nombre que vous avez choisi est trop petit")
    elif nombre_joueur > nombre_ordi:
        print("Le nombre que vous avez choisi est trop grand")
    else:
        print("Félicitations ! Vous avez trouvé le nombre de l'ordinateur ","en",essais,"essai(s)")
    essais += 1
  • Condition if

Si le joueur dépasse le nombre d’essais maximum et que si son nombre n’est pas le même que celui de l’ordinateur alors il aura perdu.

if essais>essais_max and nombre_joueur != nombre_ordi :
    print("Désolé, vous avez utilisé tous vos essais.")
    print("Vous êtes vraiment nul, réessayer jusqu'a que vous gagnez!")
    print("L'ordinateur avais choisi le nombre",nombre_ordi,".")

Jeu avec interface graphique

  • L’importation des modules et variables

Tkinter (de l’anglais Tool kit interface) est la bibliothèque graphique libre d’origine pour le langage Python, permettant la création d’interfaces graphiques.

Pour créer mon interface graphique, j’ai d’abord créer une fenêtre dont j’ai préciser sa dimension dans laquelle on y retrouva le titre, puis la couleur de fond (qui sera ici du bleu cyan), ainsi que le texte de présentation.

from random import randint
from tkinter import *

fenetre = Tk()#creation fenetre
fenetre.title("Devine le nombre")#titre
fenetre.config(bg = "#87AEAB")# couleur de fond
fenetre.geometry("1080x720") # dimension
texte = Label (fenetre, text = "Bienvenue sur le jeu du + OU -")# texte
texte.pack()

Du coté des variables une seule chose a changé : leurs valeurs ( je vous expliquerai pourquoi plus tard).

essais_max= 4 # nombre d'essais maximum
essais = 1   # nombre essais
nombre_joueur = 0   # nombre proposé par le joueur
nombre_max_ordi = 9  # nombre maximum généré par l'ordinateur
nombre_ordi = randint(0,nombre_max_ordi)   # nombre choisi par l'ordinateur
  • Affichage

Le widget Label est un widget Tkinter standard utilisé pour afficher un texte ou une image à l’écran. Ici il va afficher du texte.

La fonction str() convertit les valeurs en forme de chaîne afin qu’elles puissent être combinées avec d’autres chaînes. Elle est utilisé dans mon programme car on ne peut écrire un texte avec des valeurs autres que des lettres alors que ma variable est un chiffre.

La méthode .pack place les widgets les uns en dessous des autres et ajuste la taille de la fenêtre. On verra plus bas que l’on peut passer des arguments à cette méthode pour placer les widgets différemment (en haut, à droite, à gauche).

Pour résumer si la méthode .pack() n’est pas utilisé a chaque fin de variables, celles-ci ne s’afficheront pas lors de l’exécution du programme.

texte2 = Label (fenetre, text = "L'ordinateur a choisi un nombre entre 1 et " +str(nombre_max_ordi))
texte2.pack()

Label (fenetre, text = "Tu as 4 essais pour le trouver ").pack()
Label (fenetre, text = "A toi de jouer !").pack()
  • Le cerveau du programme

La fonction chekInput représente la boucle principale, c’est elle qui contient les conditions de notre programme.

En Python, le mot clé global permet de modifier la variable en dehors de la portée courante. Il est utilisé pour créer une variable globale et apporter des modifications à la variable dans un contexte local ( donc ici dans notre fonction).

Puisque c’est une boucle qui tourne à toutes les actions du joueur, c’est l’endroit idéal pour mettre à jour les infos du joueur, comme le nombre d’essais.

Cette fonction ne change pas vraiment de celle du 1er programme appart le texte.

def checkInput(nombre_joueur):
    global essais, essais_max, nombre_ordi
    Label (fenetre, text = "Vous avez choisi " + str(nombre_joueur) + " :").pack()

    print(essais , essais_max)
    if nombre_ordi  != nombre_joueur and essais <= essais_max:
        Label (fenetre, text = "vous êtes au " + str(essais) + " essai.").pack()
        essais += 1
        nombre_joueur = int(nombre_joueur)
        if nombre_joueur < nombre_ordi:
            Label (fenetre, text = "Le nombre que vous avez choisi est trop petit").pack()
        elif nombre_joueur > nombre_ordi:
            Label (fenetre, text = "Le nombre que vous avez choisi est trop grand").pack()
        
    elif nombre_ordi == nombre_joueur:
        Label (fenetre, text = "Bien joué, le chiffre était bien : " + str(nombre_ordi)).pack()
    elif  essais>essais_max and nombre_joueur != nombre_ordi :
        Label (fenetre, text = "Désolé, vous avez utilisé tous vos essais. Le chiffre était " + str(nombre_ordi)).pack()
  • Problème rencontré

Le moment est venu de vous expliquer pourquoi les valeurs de mes variables ont changé.

Tout simplement puisque j’ai crée des boutons de 0 à 9 et je n’avais pas la place d’en mettre plus sinon on aurait pas vu la fin de notre programme.

Voici une photo pour mieux comprendre.

Si il y avait eu plus de bouton le texte qui apparait après chaque clic sur un bouton aurait dépassé de ma fenêtre.

  • Interaction homme/machine

Voici les 10 boutons allant de 0 a 9.

Pour lier un événement à un widget, on utilise la méthode bind() sur ce widget.

Le premier argument, ‘<Button-1>’, est un «descripteur de séquence» qui indique à tkinter que lorsque le bouton gauche de la souris est pressé, il faut qu’il appelle la fonction  chekInput fourni comme deuxième argument.

Une fonction lambda est une petite fonction anonyme qui peut prendre n’importe quel nombre d’arguments, mais ne peut avoir qu’une seule expression.

Ici elle va prendre le chiffre qui lui est associé et le joué dans la fonction chekInput.

btn0 = Label (fenetre, text = str(0))
btn0.bind("<Button-1>", lambda e: checkInput(0))
btn0.pack()

btn1 = Label (fenetre, text = str(1))
btn1.bind("<Button-1>", lambda e: checkInput(1))
btn1.pack()

btn2 = Label (fenetre, text = str(2))
btn2.bind("<Button-1>", lambda e: checkInput(2))
btn2.pack()

btn3 = Label (fenetre, text = str(3))
btn3.bind("<Button-1>", lambda e: checkInput(3))
btn3.pack()

btn4 = Label (fenetre, text = str(4))
btn4.bind("<Button-1>", lambda e: checkInput(4))
btn4.pack()

btn5 = Label (fenetre, text = str(5))
btn5.bind("<Button-1>", lambda e: checkInput(5))
btn5.pack()

btn6 = Label (fenetre, text = str(6))
btn6.bind("<Button-1>", lambda e: checkInput(6))
btn6.pack()

btn7 = Label (fenetre, text = str(7))
btn7.bind("<Button-1>", lambda e: checkInput(7))
btn7.pack()

btn8 = Label (fenetre, text = str(8))
btn8.bind("<Button-1>", lambda e: checkInput(8))
btn8.pack()

btn9 = Label (fenetre, text = str(9))
btn9.bind("<Button-1>", lambda e: checkInput(9))
btn9.pack()
  • Fin de la fenêtre

La méthode mainloop() permet d’afficher la fenêtre qui vient d’être créée. Pour ceux qui ne l’avais pas deviné, elle marque la fin de notre programme.

fenetre.mainloop()

Anecdote

A la base j’étais dans un groupe de 3 personnes et ont voulais créer un space invaders mais ont s’est vite rendu compte de la difficulté alors ont s’est orienté sur le jeu du morpion. Puis je décida de quitter le groupe et de me mettre en solo car ils ne travaillait pas et c’est ainsi que j’ai codé le jeu du plus ou moins.

Conclusion

Pour pouvoir jouer à mes des versions du jeu, téléchargez le code par l’intermédiaire du lien ci-dessous. Pour la 1ère version il vous faut écrire le nombre dans la console d’exécution et pour la 2nde il vous suffit juste de cliquer sur les boutons.
Amusez-vous bien !

Téléchargement

Projets

Multi Gaming – Old School, en python

Vous aimer les jeux old school ? Ou plus simplement les jeux vidéos ? Alors vous êtes au bon endroit ! Bienvenue sur notre projet Multi Gaming / Old School !

Introduction :

Projet réalisé par R.Moreno, N.Ducatez, M.Leclerc de la classe de première en spécialité NSI.

Jouez à plusieurs jeux tels que : Un lovemetter pour savoir QUI est votre prétendant idéal ! Un jeu du mémory pour faire fonctionner les méninges ! Et pour finir le classique jeu du : pierre, papier, ciseaux ! Avec un menu réaliser en Tkinter.

Commençons donc par le commencement :

Les jeux
Tout d’abor mon équipe s’est penché sur le lovemeter qui était plutôt simple a réaliser :

#Le programme du lovemeter
def love():
    a = input("Entrer le prénom du premier prétendant : ")
    b = input("Entrer le prénom du deuxieme prétendant : ")
    love_calcul(a, b)
    
#Le calcul de l'amour <3
def love_calcul(a, b):
    amour=randint(1, 100)
    print("Laisser moi réfléchir...")
    time.sleep(2)
    print("Hmmmmmmm")
    time.sleep(1)

print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais ", amour,"% d'amour <3")
    

Voici notre code, il est assez simple, mais on ne voulais pas le laisser de la sorte ! C’est pour cela que l’on a ajouter des eastereggs.

#Le programme du lovemeter
def love():
    a = input("Entrer le prénom du premier prétendant : ")
    b = input("Entrer le prénom du deuxieme prétendant : ")
    love_calcul(a, b)
    
#Le calcul de l'amour <3
def love_calcul(a, b):
    amour=randint(1, 100)
    print("Laisser moi réfléchir...")
    time.sleep(2)
    print("Hmmmmmmm")
    time.sleep(1)
    
    #Un petit secret bien sur :)
    if a == "Rick":
        webbrowser.open('https://www.youtube.com/watch?v=xvFZjo5PgG0')
    
    elif b == "Rick":
        webbrowser.open('https://www.youtube.com/watch?v=xvFZjo5PgG0')
    
    if a == "rick":
        webbrowser.open('https://www.youtube.com/watch?v=xvFZjo5PgG0')
    
    elif b == "rick":
        webbrowser.open('https://www.youtube.com/watch?v=xvFZjo5PgG0')
        
    #Si un des prétendants se nomme Robert
    elif a == "Robert":
        print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 42% d'amour quel drôle de nombre quand même ! ")
    
    elif b == "Robert":
        print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 42% d'amour quel drôle de nombre quand même ! ")
        
    elif a == "robert":
        print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 42% d'amour quel drôle de nombre quand même ! ")
        
    elif b == "robert":
        print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 42% d'amour quel drôle de nombre quand même ! ")
        
    #Si un des prétendants se nomme Clemente
    elif a == "Clemente":
        print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 76% d'amour quel drôle de nombre quand même ! ")
    
    elif b == "Clemente":
        print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 76% d'amour quel drôle de nombre quand même ! ")
        
    elif a == "clemente":
        print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 76% d'amour quel drôle de nombre quand même ! ")
    
    elif b == "clemente":
        print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais 76% d'amour quel drôle de nombre quand même ! ")
    
    #Si aucun des prétendants ne corresponds
    else:
        print("Entre ", a ," et ", b,"j'ai remarqué qu'il y avais ", amour,"% d'amour <3")

Après l’ajout de quelque easter egg, on s’est dit que il nous fallait au moins 3 jeux. Alors on a crée un pierre papier ciseaux.

#Le programme du pierre Papier Ciseaux
def pierre_papier_ciseaux():
    choix= ("Pierre", "Papier", "Ciseaux")
    Score_J = 0
    Score_O = 0

    # Création de la boucle
    a = "Oui"
    while a == "Oui":
        time.sleep(2)
        Choix = input("Taper Pierre , Papier , ou Ciseaux :")

        # Si le choix été Pierre
        if Choix == "Pierre":
            print("Vous avez choisie Pierre")
            time.sleep(1)

            # Choix de l'ordinateur aléatoirement
            print("L'ordinateur choisie ...")
            time.sleep(1)
            ordi = random.choice(choix)
            print("l'ordinateur a choisie :", ordi)
            time.sleep(1)
    
            # Si le choix de l'ordinateur est Ciseaux
            if ordi == "Ciseaux":
                print("Bravo vous avez gagnez")
                time.sleep(1)
                Score_J += 1
                print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
                time.sleep(1)
                a = input("Voulez-vous rejouer ? :")

            # Si le choix de l'ordinateur est Pierre
            if ordi == "Pierre":
                print("Dommage il y a égalité")
                time.sleep(1)
                print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
                time.sleep(1)
                a = input("Voulez-vous rejouer ? :")

            # Si le choix de l'ordinateur est Papier
            if ordi == "Papier":
                print("Dommage vous avez perdu")
                time.sleep(1)
                Score_O += 1
                print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
                time.sleep(1)
                a = input("Voulez-vous rejouer ? :")

        elif Choix == "Papier":
            print("Vous avez choisie Papier")
            time.sleep(1)

            # Choix de l'ordinateur aléatoirement
            print("L'ordinateur choisie ...")
            time.sleep(1)
            ordi = random.choice(choix)
            print("l'ordinateur a choisie :", ordi)
            time.sleep(1)

            # Si le choix de l'ordinateur est ciseaux
            if ordi == "Ciseaux":
                print("Dommage vous avez perdu")
                time.sleep(1)
                Score_O += 1
                print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
                time.sleep(1)
                a = input("Voulez-vous rejouer ? :")

            # Si le choix de l'ordinateur est pierre
            if ordi == "Pierre":
                print("Bravo vous avez gagnez")
                time.sleep(1)
                Score_J += 1
                print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
                time.sleep(1)
                a = input("Voulez-vous rejouer ? :")

            # Si le choix de l'ordinateur est Papier
            if ordi == "Papier":
                print("Dommage il y a égalité")
                time.sleep(1)
                print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
                time.sleep(1)
                a = input("Voulez-vous rejouer ? :")

        elif Choix == "Ciseaux":
            print("Vous avez choisie Ciseaux")
            time.sleep(1)

            # Choix de l'ordinateur aléatoirement
            print("L'ordinateur choisie ...")
            time.sleep(1)
            ordi = random.choice(choix)
            print("l'ordinateur a choisie :", ordi)
            time.sleep(1)

            # Si le choix de l'ordinateur est ciseaux
            if ordi == "Ciseaux":
                print("Dommage il y a égalité")
                time.sleep(1)
                print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
                time.sleep(1)
                a = input("Voulez-vous rejouer ? :")

            # Si le choix de l'ordinateur est pierre
            if ordi == "Pierre":
                print("Dommage vous avez perdu")
                time.sleep(1)
                Score_O += 1
                print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
                time.sleep(1)
                a = input("Voulez-vous rejouer ? :")

            # Si le choix de l'ordinateur est Papier
            if ordi == "Papier":
                print("Bravo vous avez gagnez")
                time.sleep(1)
                Score_J += 1
                print("Nombre de victoire : ", Score_J, "Nombre de défaite", Score_O)
                time.sleep(1)
                a = input("Voulez-vous rejouer ? :")

C’est un long programme qui peux faire peur a première vues mais en faite il est plutôt simple et répétitif !

Une fois le pierre papier ciseaux fait, nous nous sommes attaqué à notre dernier jeu, le memory bien plus rapide à faire.

def memoire():
    reponse = "Oui" or "oui"
    points = 0
    while reponse == "Oui" or "oui":
        chiffre = randint(10000,99999)
        print(chiffre)
        time.sleep(1)
        clear()
        chiffre2 = int(input("Noter le nombre qui vient d'apparaitre :"))
        #Si la réponses est juste
        if chiffre == chiffre2:
            print("Bravo !")
            points = points + 1
            print("Vous avez ", points , "points")
        #Si la réponses est fausse
        else:
            print("Dommage ! Tu as eu faux")
            print("Vous avez",points , "points")
        
        #On continue ?
        reponse = input("Veux tu continuer ? : ")
        if reponse == "Non" or "non":
            break
        
        
def clear():
    for i in range(80):
        print(" ")

Le menu
En fin, il nous a fallu créer notre menu, pour pouvoir sélectionner le jeux que l’on souhaite !

Pour cela nous avons insérer une image créée sur Canva en guise de menu

#Affiche l'image qui permet de choisir ce que l'on veux faire

TKI_Principal = tkinter.Tk ( )

IMG_Origine = tkinter.PhotoImage ( file = "image.png" )

BUT_Quitter = tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy )
LAB_Logo = tkinter.Label ( TKI_Principal , image = IMG_Origine , relief = "solid" , bg = "white" )

LAB_Logo.pack ( )
BUT_Quitter.pack  ( )

TKI_Principal.bind("l", lambda event: love())
TKI_Principal.bind("m", lambda event: memoire())
TKI_Principal.bind("g", lambda event: pierre_papier_ciseaux())

TKI_Principal.mainloop ( )

Et pour mieux coller à l’univers multi gaming, nous avons ajouter une petit musique qui correspond parfaitement à cet univers.

import winsound
winsound.PlaySound('music.wav', winsound.SND_FILENAME|winsound.SND_ASYNC)

Mention spéciale

Problème rencontré
Nous avons rencontré des problèmes avec le menu en tkinter mais aussi avec le module python Keyboard.

Solution
Pour le menu en tkinter notre équipe a suivie un tuto sur Youtube et nous avons aussi commencer a lire la documentation qui est très complexe et complète ! Et c’est comme cela que nous avons réussi notre objectif de création d’un menu. Quant au module Keyboard notre équipe a donc étudier comment l’importer sur un ordinateur que n’a pas installé le module keybord depuis le terminal de commande (powersheel). La solution était simplement de télécharger le package de code python dans le projet directement.

Conclusion

Pour pouvoir jouer à notre projet, téléchargez le code par l’intermédiaire du lien ci-dessous. Le menu est intuitif et dans le thème du multi gaming, de plus les petites surprises, les eastereggs, ajoutent une touche comique à ces jeux aléatoires .

Amusez-vous bien !

Téléchargement

Non classé

Une machine à sous en Python

Jouez à une machine à sous et jeu du nombre inconnu sur python avec de l’argent virtuel ! Obtenez 2 ou 3 fois le même signe et trouvez le nombre inconnu ! Moins de chance de se ruiner !

Présentation du projet

Projet réalisé sur Thonny en Python par COULIBALY Rayan, GARCIA Florian et BRYCKAERT Aurélien de la classe de première 2021-2022 en spécialité NSI.

Nous avons eu l’idée de reconstituer une machine à sous où le but est d’obtenir 2 ou 3 fois le même signe pour ainsi recevoir une somme d’argent variante selon l’argent misé. Nous n’avons mis que 4 symboles différents dans la machine, contrairement à une vraie machine à sous qui en comporte 16 en moyenne.

Nous avons aussi décidé de crée un deuxième mini-jeu : le nombre inconnu. Ce jeu est également connecté au même système d’argent virtuel. Le but est de trouver un nombre caché entre 1 et 1000, la limite est de 10 tentatives mais il faut juste un peu de réflexion pour gagner. L’argent misé sera multiplié par deux et pourra être utilisé dans le jeu de la machine à sous ou dans la boutique.

Style

Pour ce projet, nous avons décidé de créer une machine à sous en style art ASCII. Ce dernier consiste à réaliser une image avec tout type de lettres et de caractères spéciaux. Ceci est totalement esthétique et ne change pas vraiment l’expérience du jeu. Pour le jeu du nombre inconnu, nous n’avons pas pu faire créer un objet en ASCII car il n’y a pas vraiment de moyen pour représenter ce jeu autrement qu’avec du texte. Pour le menu et la boutique, nous avons décidé de faire quelque chose de classique, facile à comprendre. Pour les articles du shop, nous avons décidé de les montrer en art ASCII uniquement quand ils sont achetés par le joueur. C’est comme une récompense pour celui-ci pour d’avoir joué et gagné à nos jeux. Nous n’avons pas fait ces 3 objets en ASCII nous même, voici le lien du site où nous les avions trouvé https://www.asciiart.eu/.

Capture d’écrans

Évolution

La création du projet à commencé en plusieurs parties :

Le design de la machine à sous (visuellement) :

Le groupe à d’abord pensé à comment la machine sera construite, les différents symboles que la machine possèdera ainsi que le nombre de cases qu’elle comportera. Un modèle d’une machine à 6 cases, comportant 7 symboles différents.

Finalement, ça sera un modèle d’une machine à sous contenant 3 cases ainsi que 4 symboles diffèrent qui sera choisie.

                         .-------.
                         |Jackpot|
                  _______|_______|_______
                 |        _       _      |
                 |       | |     | |     |
                 |    ___| | ___ | |_    |
                 |   / __| |/ _ \| __|   | ___
                 |   \__ \ | (_) | |_    |(   )
                 |   |___/_|\___/ \__|   | | |
                 |    ___   ___   ___    | | |
                 | ===___===___===___=== | | |
                 | |*|   |*|   |*|   |*| | | |
                 | |*|   |*|   |*|   |*| |_| |
                 | |*|___|*|___|*|___|*| |___|
                 | ===* *===* *===* *=== |
                 |    /_____________\    |
                 |     |           |     |
                _|     \___________/     |_
               (___________________________)

Symbole: ♥, ♠, 7, ♣

La programmation de la machine à sous :

Nous devions pour la réalisation du fonctionnement de la machine à sous, créer un script qui prendrait 3 valeurs choisissant aléatoirement un des quatre symboles. Pour que l’aléatoire fonctionne, nous devions importer la fonction random au script (Random signifiant aléatoire en anglais). Nous avions ensuite créé trois valeurs, qui correspondent aux trois symboles qui seront dans les cases de la machine à sous.

import random
signe1 = ("♥", "♠", "7", "♣")
num1 = random.randrange(0,4)
signe2 = ("♥", "♠", "7", "♣")
num2 = random.randrange(0,4)
signe3 = ("♥", "♠", "7", "♣")
num3 = random.randrange(0,4)

Le système d’argent est aussi nécessaire à la réalisation d’une machine à sous. Nous avions décidé que le joueur aurait en début de jeu, une somme de 5000€. Nous avons aussi décidé que le joueur ne pourrait pas miser une somme inférieure ou égale à 10€ dans la machine.

money = [5000]

mise = int(input("Combien veux tu miser ? "))
        if mise > money[0]:
            print("tu n'as pas assez d'argent pour miser cette somme")
            slot()           
        if mise >= 10:
            money[0] = money[0] - mise
            print("")
            print("          -",mise,"€")

Nous avons ensuite créé les scritps qui récompensent ou non le joueur lorsqu’il gagne ou perd. La mise est multipliée par 5 puis mise au carré lorsque le joueur obtient 3 symboles identiques, et par 4 lorsqu’il obtient 2 symboles identiques et rien si il obtient aucun symboles identiques.

if signe1[num1] == signe2[num2] == signe3[num3]:
	gagne = 5*mise**2 
	money[0] = money[0] + gagne
	print("Bravo! tu as gagné ",gagne,"€")
elif signe1[num1] == signe2[num2]:
	gagne2 = mise * 4
	money[0] = money[0] + gagne2
	print("Bravo! tu as gagné ",gagne2,"€")
elif signe2[num2] == signe3[num3]:
	gagne3 = mise * 4
	money[0] = money[0] + gagne3
	print("Bravo! tu as gagné ",gagne3,"€")
elif signe1[num1] == signe3[num3]:
	gagne4 = mise * 4
	money[0] = money[0] + gagne4
	print("Bravo! tu as gagné ",gagne4,"€")
elif signe1[num1] != signe2[num2] != signe3[num3]:
	perd = mise*0
	money[0] = money[0] + perd
	print("Dommage tu as perdu cette fois-ci !")

La programmation du jeu du nombre inconnu :

Pour ce deuxième mini-jeu, nous avions aussi eu besoin de l’aléatoire, en effet le nombre que le joueur doit trouver est compris en 1 et 1000. Nous devions aussi faire en sorte que le joueur possède 10 essais pour trouver le nombre inconnu. Pour faire cela nous avions entré une valeur nommé « nb_coup » égale à 10 qui correspond donc aux nombres d’essais restants du joueur. A chaque réponse, « nb_coup » sera soustraite de 1 et quand cette valeur sera à 0, le joueur aura perdu. La valeur « nb_test » est la nombre écrit par le joueur, cette valeur sera utilisée pour annoncer si le nombre inconnu est supérieur ou inférieur au nombre choisi ou si elle correspond au nombre inconnu.

mise2 = int(input("Combien d'argent jouez vous ?\t"))
        if mise2 > money[0]:
            print("Tu n'as pas assez d'argent pour miser cette somme")
            le_nombre_inconnu()
        nb_inconnu = random.randint(1,1000)
        nb_coup=10
        while nb_coup>0:
            print("\n")
            nb_test = input("Entrez un nombre : ")
            nb_coup = nb_coup - 1
            nb_test = int(nb_test)
            if nb_test < nb_inconnu :
                print("\n")
                print(nb_test, ": Plus haut\n")
                print("Il te reste", nb_coup, "essai(s)\n")
            if nb_test > nb_inconnu :
                print("\n")
                print(nb_test, ": Plus bas\n")
                print("Il te reste", nb_coup, "essai(s)\n")
            if nb_test == nb_inconnu :
                print(nb_test, ": Trop fort\n")
            	money[0] = money[0] - mise2
                mise2 = mise2 + mise2
                mise3 = mise2 + money[0]
                print("Bravo, tu as maintenant", mise3," € \n")

La programmation du menu :

Un menu était nécessaire pour choisir à quel jeu le joueur veut-il jouer, soit la machine à sous, soit le jeu du nombre inconnu. C’est un script assez simple à réaliser et est majoritairement composé de « print ». Dans ce menu nous avons 3 choix. Tout d’abord, le choix des deux jeux (machine à sous et nombre inconnu) et le choix pour la boutique. La boutique étant du contenue ajouté en dernier. slot() correspond au script de la machine à sous, le_nombre_inconnu() correspond au jeu du nombre inconnu et shop() correspond à la boutique.

    time.sleep(1)
    print("\n")
    print("|------------------------------------|")
    print("|---------- MENU PRINCIPAL ----------|")
    print("|------------------------------------|\n")
    print("Tu as",money[0],"€\n")
    print("|-- A quel jeu voulez vous jouer ? --|\t")
    print("\n")
    print("1. Machine à sous\n")
    print("2. Le nombre inconnu\n")
    print("|------------------------------------|\n")
    print("3. Shop\n")
    choix=int(input("Veuillez selectionner votre choix:\t"))
    print("\n")
    if choix==1:
        slot()
    if choix==2:
        le_nombre_inconnu()
    elif choix==3:
        shop()
    else:
        print("Choix non valide\n")

Pour retourner au menu depuis les jeux, nous avons créé un script proposant au joueur un choix, s’il veut retourner au menu ou continuer à jouer. game() correspond au script du menu, et slot() correspond au script de la machine à sous, comme dit précédemment.

def continuer():
    print("Voulez-vous continuer?\n")
    print("1.Oui\n")
    print("2.Non (retour au menu)\n")
    choix2=int(input("Veuillez selectionner votre choix:\t"))
    if choix2==1:
        slot()
    elif choix2==2:
        game()
    else:
        print("Choix non valide\n")

La programmation de la boutique :

L’ajout d’une boutique sert à donné une sorte de but dans notre programme. Les jeux nous faisant gagner ou perdre de l’argent sans réel but n’ont pas vraiment d’intérêts à être joué. La programmation de la boutique est très similaire à celle du menu, en effet plusieurs choix nous sont proposés, comme au menu. Ce script est divisé en deux car on ne voulait pas que la phrase d’accueil de la boutique se répète à chaque fois.

def shop():
    print("   _____ _                 ")
    print("  / ____| |                ")
    print(" | (___ | |__   ___  _ __  ")
    print("  \___ \| '_ \ / _ \| '_ \ ")
    print("  ____) | | | | (_) | |_) |")
    print(" |_____/|_| |_|\___/| .__/ ")
    print("                    | |    ")
    print("                    |_| ")
    time.sleep(1)
    print("\n")
    print("Bienvenue dans la boutique!\n")
    shop2()
    
def shop2():
    print("Tu as",money[0],"€\n")
    time.sleep(0.5)
    print("|------------------------------------|\n")
    time.sleep(0.5)
    print("1.Bouteille d'eau (5001€)\n")
    time.sleep(0.5)
    print("2.Peluche ours (6000€)\n")
    time.sleep(0.5)
    print("3.Voiture neuve (10000€)\n")
    time.sleep(0.5)
    print("|------------------------------------|\n")
    time.sleep(0.5)
    print("4.retour au menu\n")
    time.sleep(0.5)
    choix3=int(input("Que souhaitez vous acheter ?:\t"))

L’importation du temps et du son :

Pour rendre le script plus sympathique et moins agressif, nous avions importer des son de victoire ou de défaite ainsi que durant les apparitions de texte, du temps entre chaque texte pour ne pas rendre le joueur confus à cause d’une surabondance de texte.

import winsound
import time

winsound.PlaySound("", winsound.SND_ASYNC)
time.sleep()

Problèmes rencontrés

Nous n’avons pas vraiment rencontré beaucoup de problèmes durant ce projet, le seul problème était de rassembler tout les scripts dans un seul et même script. Nous avions commencé à programmer chacun dans notre coin en tapant des valeurs se nommant différemment alors qu’elles sont les même.

Heureusement nous avons réussi à tout rassembler, sinon nous n’aurions aurait pas pu finir le projet!

Conclusion

Ainsi, ce projet était vraiment intéressant, nous avions pris plaisir à y travailler dessus. Cela fut enrichissant, car par la pratique, nous avions beaucoup appris !

Voici notre script :

Gameplay SardJump Projets

SardJump un DoodleJump en python

DoodleJump est un jeu intemporel datant d’une dizaine d’années. Sardoche est un streamer professionnel. On a décidé de relier les deux en un seul et unique jeu extraordinaire.

Introduction

La création du jeu se fait en trois grandes étapes :

  1. Création de la fenêtre
  2. Création des objets
  3. Lancement du jeu

Création de la fenêtre

Initialisation des modules et du jeu

import pygame
from pygame.locals import *
import sys
import random

WHITE = (255, 255, 255)

class SardJump (object):
    def __init__(self):
      return

On importe le module pygame ainsi que d’autres modules basiques tels que random et sys, puis on défini la class SardJump dans laquelle on définira les fonctions.

Création de la fenêtre et choix des dimensions.

 def __init__(self):
        self.screen = pygame.display.set_mode((800, 600))
 def run(self):
        global score
        clock = pygame.time.Clock()
        self.generatePlatforms()
        while True:
            self.screen.fill(WHITE)
            self.screen.blit(self.background,(0,0))
            FONT = pygame.font.Font('assets/fonts/Optimus.otf', 30)
            text = FONT.render("Score : " + str(score),False,(255,255,255)).convert_alpha()
            clock.tick(60)

            for event in pygame.event.get():
                if event.type == QUIT:
                    sys.exit()

On gère l’affichage et la taille de l’écran avec « self.screen = pygame.display.set_mode((800, 600)) », on gère ce qui est affiché tant que l’écran et actif et on utilise la fonction « pygame.event.get() » pour fermer l’écran.

Création des objets

Charger les images dans le jeu

def __init__(self):
        pygame.font.init()
        self.screen = pygame.display.set_mode((800, 600))
        self.playerRight_1 = pygame.image.load("assets/right_1.png").convert_alpha()
        self.playerRight = pygame.image.load("assets/right.png").convert_alpha()
        self.playerLeft = pygame.image.load("assets/left.png").convert_alpha()
        self.playerLeft_1 = pygame.image.load("assets/left_1.png").convert_alpha()
        self.plateform = pygame.image.load("assets/plateform.png").convert_alpha()
        self.background = pygame.image.load("assets/bg.png").convert()

Tout d’abord, pour commencer on importe les images en indiquant leur chemin d’accès.

Définition des variables nécessaires au bon fonctionnement du jeu

        self.cameray = 0
        self.playerx = 400
        self.playery = 400
        self.xmovement = 0
        self.jump = 0
        self.direction = 0
        self.gravity = 0
        
        self.platforms = [[400, 500]]
        self.score = 0

On crée dans la fonction __init__ les variables nécessaires au fonctionnement du jeu, donc, le suivi de la caméra, les positions du joueur, les sauts automatiques, la gravité, la position des plateformes et enfin le score.

Système de mouvement.

def updatePlayer(self):
        global score
        if self.playerx > 850:
            self.playerx = -50
        elif self.playerx < -50:
            self.playerx = 850
        self.playerx += self.xmovement
        if self.playery - self.cameray <= 200:
            self.cameray -= 10

On crée la fonction « updatePlayer(self) » dans laquelle seront mises toutes les modifications sur le personnage comme la téléportation de droite à gauche.

key = pygame.key.get_pressed()
        if key[K_RIGHT]:
            if self.xmovement < 10:
                self.xmovement += 1
                self.direction = 0
        elif key[K_LEFT]:
            if self.xmovement > -10:
                self.xmovement -= 1
                self.direction = 1

On attribue les touches droite et gauche aux mouvements du personnage.

if not self.jump:
            self.playery += self.gravity
            self.gravity += 1
        elif self.jump:
            self.playery -= self.jump
            self.jump -= 1

Cette partie de la fonction updatePlayer(self) permet de créer une gravité donc lorsque le personnage ne saute pas il tombe, mais le problème et qu’il faut qu’il y ai un point de collision pour sauter dessus. C’est la qu’on va créer les fonctions en lien avec les plateformes.

Création des plateformes

def generatePlatforms(self):
y = 700
        while y > -100:
            x = random.randint(0, 900)
            self.platforms.append((x, y))
            y -= 50

def drawPlatforms(self):
        for plat in self.platforms:
            regenerate = self.platforms[1][1] - self.cameray
            if regenerate > 600:
                self.platforms.append(
                    (random.randint(0, 700), self.platforms[-1][1] - 50))
                self.platforms.pop(0)
            self.screen.blit(
                    self.plateform, (plat[0], plat[1] - self.cameray))

On génère aléatoirement les plateformes avant de les afficher.

def updatePlatforms(self):
        for p in self.platforms:
            rect = pygame.Rect( p[0], p[1], self.plateform.get_width() - 10, self.plateform.get_height())
            player = pygame.Rect(self.playerx, self.playery, self.playerRight.get_width() - 10, self.playerRight.get_height())
            if rect.colliderect(player) and self.gravity and self.playery < (p[1] - self . cameray):
                self.jump = 15
                self.gravity = 0

On crée un effet collision avec le personnage et les plateformes qui lui permettra de sauter dessus sans tomber.

Système de score et mort

        if self.playery - self.cameray <= 200:
            self.cameray -= 10
            score += 1

Le score est calculé en fonction de l’avancement dans la partie. Lorsque la caméra monte, le score augmente également.

            FONT = pygame.font.Font('assets/fonts/Optimus.otf', 30)
            text = FONT.render("Score : " + str(score),False,(255,255,255)).convert_alpha()
    		
      		self.screen.blit(text, (550, 50))

On crée le texte du score dans la boucle du jeu et on ne l’affiche qu’après la création et l’affichage des autres éléments (fond, plateformes et personnage) afin que celui-ci soit au premier plan.

Lancement du jeu

self.drawPlatforms()
self.updatePlatforms()
self.updatePlayer()
self.screen.blit(text, (550, 50))
pygame.display.flip()
pygame.display.set_caption("SardJump")

On appelle toutes les fonctions dans la fonction run puis on lance le jeu avec SardJump().run().

Conclusion 

Pour pouvoir jouer à cette version du jeu SardJump, téléchargez le code par l’intermédiaire du lien ci-dessous. Les commandes sont assez intuitives : les flèches gauche/droite pour se déplacer, et les flèches haut/bas pour changer de skin de plateforme. Les paliers de skins de personnage sont à 1.000 et 10.000 points.
Amusez-vous bien !

Projets

Un Mastermind en python

Avez-vous déjà rêvé de pouvoir jouer à un jeu stratégique sur votre calculatrice ? Grâce à cet article vous allez découvrir notre jeu du Mastermind revisité… Aurez-vous la bonne stratégie pour réussir à battre l’ordinateur ?

Introduction

Le projet a été réalisé par Justine, Andreas et Neila en classe de première au Lycée Louis Pasteur d’Avignon dans le cadre de leur enseignement de spécialité NSI (numérique et sciences de l’informatique).
Comme matériel, un ordinateur équipé du logiciel Thonny.

L’histoire du jeu d’origine

Le Mastermind ou Master Mind est un jeu de société pour deux joueurs. Le but est de trouver un code en 10 ou 12 coups. La partie s’arrête lorsque l’un des deux joueurs à trouver le code caché. C’est un jeu de réflexion, et de déduction, inventé par Mordecai Meirowitz, dans les années 1970. Mais nous l’avons modifié à notre façon.

Descriptif du projet

Dans le cadre de notre projet, le jeu codé en python a été revisité et mixé avec le jeu du plus ou moins : le joueur essaie de deviner la composition de l’ordinateur qui a été générée aléatoirement, c’est un code à 9 chiffres, le joueur doit le trouver en 5 coups et de plus l’ordinateur nous dit pour chacune des valeurs recherchées si elle est plus grande ou pas. Le jeu ne se joue que dans un seul sens. C’est-à-dire que le joueur ne peut que gagner ! Incroyable non ? ( sauf si il dépasse les 5 coups )

Vous pouvez jouer contre l’ordinateur avec vos amis et tenter de gagner en le moins de coup possible ! 

Notre programme

import random


liste1 = [1,2,3,4,5,6,7,8,9]

random.shuffle(liste1)

liste2 = [0,0,0,0,0,0,0,0,0]

nb_try = 5

n = 0

def choix():
    global n
    global nb_try
    n = 0
    nb_try -= 1
    var = input("Entrez votre combinaison  : ")
    for i in range(9):
        liste2[i] = int(var[i])

def regle():
    print("-----------------------------------\n")
    print("Bienvenue dans le jeu du Mastermind !\n")
    print("Les règles sont simple, l'ordinateur choisis une combinaison de 9 chiffres allant de 1 à 9 inclu, à vous de trouver la bonne combinaison grâce aux indications qui vous seront fournis.\n")
    print("Bonne chance !")

def regle_n(n):
    if liste1[n] == liste2[n]:
        print(liste2[n],"est juste")
    elif liste1[n] < liste2[n]:
        print(liste2[n],"est plus grand que celui que tu cherches")
    else:
        print(liste2[n],"est plus petit que celui que tu cherches")

 
def play():
    global nb_try
    global n
    regle()
    while liste1 != liste2 and nb_try > 0:
        print("-------------------\n")
        choix()
        for i in range(9):
            regle_n(n)
            n += 1
    if liste1 == liste2:
        print(" -------------------------\n Bravo ! Vous avez gagné ! Vous pouvez ainsi nous mettre un 20/20 !\n-------------------------\n")
    else: 
        print(" ----------------\n Vous avez perdu !  Mais vous pouvez qaund mettre un 20/20...\n ----------------")
        print("La bonne combinaison était,",liste1,".")
        nb_try = 5
        menu()



def menu():
    print("-----MENU PRINCIPAL-----")
    print("------------------------")
    print("1 - Je veux jouer\n")
    print("2 - Je veux arrêter de jouer\n")
    choix_m=int(input("Sélectionnez votre choix : "))
    if choix_m==1:
        random.shuffle(liste1)
        play()
    else :
        menu()


menu()

Fonctionnement du programme

1- Menu
2- Choix de combinaison
3- Indices
4- Gagné / perdu

Évolution du programme

Le processus de création s’est divisé en différentes parties.

Définir les listes
Tout d’abord nous avons définies la liste de l’ordinateur liste1 et la liste du joueur liste2 .

liste1 = [1,2,3,4,5,6,7,8,9]

random.shuffle(liste1)

liste2 = [0,0,0,0,0,0,0,0,0]

nb_try = 5

n = 0

def choix():
    global n
    global nb_try
    n = 0
    nb_try -= 1
    var = input("Entrez votre combinaison  : ")
    for i in range(9):
        liste2[i] = int(var[i])

La fonction random.shuffle(liste1) sert à mélanger aléatoirement la liste. La fonction choix permet au joueur de composer sa nouvelle combinaison de chiffre, tout en enlevant 1 essai à chaque nouvelles combinaisons.

L’esthétique du jeu
Nous avons ensuite écrit les règles du jeu :

def regle():
    print("-----------------------------------\n")
    print("Bienvenue dans le jeu du Mastermind !\n")
    print("Les règles sont simple, l'ordinateur choisis une combinaison de 9 chiffres allant de 1 à 9 inclu, à vous de trouver la bonne combinaison grâce aux indications qui vous seront fournis.\n")
    print("Bonne chance !")

Les indices
Pour cela nous avons utilisé des signes mathématiques pour créer des conditions avec les fonctions if , elif , else .

def regle_n(n):
    if liste1[n] == liste2[n]:
        print(liste2[n],"est juste")
    elif liste1[n] < liste2[n]:
        print(liste2[n],"est plus grand que celui que tu cherches")
    else:
        print(liste2[n],"est plus petit que celui que tu cherches")

Réunir tout les éléments
Pour réunir toutes ces fonctions, nous avons créé la fonction play() qui appelle d’autres fonctions. Une boucle while est indispensable pour que la fonction choix() et regle_n() se répète jusqu’à ce que la boucle while se casse grâce à deux cas de figure.

def play():
    global nb_try
    global n
    regle()
    while liste1 != liste2 and nb_try > 0:
        print("-------------------\n")
        choix()
        for i in range(9):
            regle_n(n)
            n += 1
    if liste1 == liste2:
        print(" -------------------------\n Bravo ! Vous avez gagné ! Vous pouvez ainsi nous mettre un 20/20 ! \n-------------------------\n")
    else:
        print(" ----------------\n Vous avez perdu ! Mais vous pouvez qaund mettre un 20/20...\n ----------------")
        print("La bonne combinaison était,",liste1,".")
        nb_try = 5
        menu()

Les deux cas de figure qui cassent la boucle sont gagner ou perdre. Pour cela on utilise les conditions if et else.

Menu
Pour finir ce programme python, nous avons tous réunis dans la fonction menu() , la fonction est intégrée d’un menu qui permet à l’utilisation de jouer ou non, c’est purement esthétique.

def menu():
    print("-----MENU PRINCIPAL-----")
    print("------------------------")
    print("1 - Je veux jouer\n")
    print("2 - Je veux arrêter de jouer\n")
    choix_m=int(input("Sélectionnez votre choix : "))
    if choix_m==1:
        random.shuffle(liste1)
        play()
    else :
        menu()

Problèmes rencontrés

A la fin du processus de création nous nous sommes heurtés à de nombreux problèmes, le premier étant la taille du code, mais on a réussi à le réduire grâce à la variable [n] lors de la fonction regle_n .

Deuxièmement, Nous avons voulu faire une interface graphique mais on a revisité le jeu du Mastermind avec une combinaison de chiffre au lieu d’une combinaison de couleur, donc le rendu n’allait pas être très jolie, nous avons donc oublié l’idée de faire une interface graphique.

Anecdote

Pour l’anecdote, il faut savoir que nous voulions originellement créer un jeu uno ! Mais suite à de nombreuses difficultés, notamment la gestion de la pioche pour deux joueurs, nous nous sommes réorientés vers un mastermind.

Conclusion 

j’espère que notre projet vous a intéressé !
Amusez-vous bien !

Crédits / Remerciements 

Un grand merci à nos deux professeurs de NSI en première qui nous ont appris a se servir du langage Python.

Téléchargement

Projets

Simulation d’une roulette de casino en python

Nous n’avons peut être pas l’âge de se rendre dans un casino, mais se n’est pas pour autant que nous ne pouvons pas nous amuser à notre échelle. C’est donc grâce à ce mini-jeu qu’on découvre assez rapidement le but d’une roulette de casino. Il ne vous reste qu’à mesuré votre chance à la roulette.

Présentation du projet

Notre projet a pour but de vous faire découvrir de façon simple le monde du casino, plus précisément grace l’un des jeux d’argent les plus connues qui est la roulette de casino.

Règles du jeu:

  • Le but du jeu est de deviner la case sur laquelle la bille lancée dans le cylindre qui contient 37 numéros va s’arrêter. 
  • Le jeu est encadré par un croupier qui annonce en début de partie « Faites vos jeux », ce qui nous laisse le droit de poser nos jetons sur les cases désirées. Vous pouvez les déplacer jusqu’à ce qu’il dise « rien ne va plus »
  •  La bille tourne encore dans le cylindre et quand elle s’arrête, le numéro gagnant est dévoilé.

Supports nécessaire pour le bon fonctionnement du projet

  • Un ordinateur avec un logiciel tel que Thonny pouvant effectuer des manipulations en langage python.

Difficultés rencontrées

Nous avons rencontrés quelque difficulté tout au long de notre programme :

Nous avons eu une grosse difficulté qui nous a fait réfléchir pendant plusieurs heures.

Cette difficulté venait de la définition aléatoire de notre programme qui nous sert pour tirer aléatoirement un nombre entre 0 et 36.

def aléatoire():# permet de tirer un nombre aléatoirement dans la roulette
    global N
    n = randint(0,36)
    N = n
    #print (n)

Notre problème était d’utiliser la variable « n » dans une autre définition du programme et donc on a dû utiliser le mot-clé « global » qui rend accessible la variable « n » dans tout le programme. 

De plus nous nous sommes servis de la fonction « print(n) » pour nous confirmer que le jeu étais bel est bien juste et qu’il relançait bien le numéro de la roulette a chaque tout. C’est donc après cette vérification qu’on a mis le « # » devant la fonction pour plus qu’elle soit prise en compte lorsque le programme est lancé mais aussi pour montrer que l’on a bien vérifier le programme.

Explication du programme

Avant de commencer l’analyse nous vous précisons que le langage python est très exigeant dans l’écriture et dans son indentation.

from random import *

Tout d’abord nous avons commencé par la fonction « From random import » qu’il ne faut surtout pas négliger car c’est cette fonction qui va permettre que la définition aléatoire génère des nombres entre 0 et 36.

Nous avons continué notre programme avec la première définition qui nous sert d’affichage de bienvenue lorsque le jeu est démarré.

def bienvenue():# phrase de bienvenue et présentation du jeu
    print("\n")
    print ("-----[JEU DE LA ROULETTE]-----")
    print ("    Bienvenue au casino !     ")
    print ("    Cree par Paul et Alexis   ")
    print ("           Jouons !           ")
    print ("------------------------------")

Ainsi grâce à la fonction d’affichage « print » nous avons pu reproduire comme une pancarte de bienvenue.

Nous arrivons maintenant à l’une des parties qui caractérisent au mieux notre jeu en question, c’est la définition qui gère le programme aléatoire. C’est ici même que notre toute première fonction « from random import » prend tout son sens.

def aléatoire():# permet de tirer un nombre aléatoirement dans la roulette
    global N
    n = randint(0,36)
    N = n
    #print (n)

Un peut plus haut dans les difficultés rencontrées nous nous somme intéressé à cette partie du programme notamment sur le « global N ». Nous avons utilisé la fonction randint qui génère un nombre aléatoirement entre les valeurs à l’intérieur des parenthèses: (0,36). De plus nous avons dû créer une autre valeur N qui possède la même valeur que n pour pouvoir l’utiliser dans la définition suivante.

Nous avons décidé de regrouper nos deux premières définitions(bienvenue et aléatoire) à l’intérieur de la troisième qui est la définition game. Elle regroupe l’ensemble du jeu que ce soit l’argent de départ mais aussi la mise ainsi que la gestion de la victoire et de la défaite. Ce système facilite le lancement des définitions car il y en a qu’une seule a lancer, ce qui provoque toujours les mêmes actions dans l’ordre voulu.

def game():# permet la composition du jeu avec la mise, l'argent de départ, sa victoire ou sa défaite, et combien lui reste t'il dans son portefeuille
    bienvenue()
    argent_de_depart = 200
    print("Votre porte-monnaie contient une valeur de 200€, bon jeux\n")
    

Ainsi dès que la définition « game » est lancée celle-ci génère immédiatement la définition « bienvenue() » qui exécute les premières lignes de code de la fonction d’affichage. De plus dans cette partie de la troisième définition on définit la valeur de l’argent de départ qui ne change pas. Ainsi grâce à la fonction d’affichage « print » on affiche la phrase qui nous indique la valeur totale de notre porte-monnaie.

La partie suivante du programme est celle qui gère la quantité d’argent qui nous reste avec le « while ».

while argent_de_depart >=0:

        if argent_de_depart == 0:# lorsque nous n'avons plus d'argent une phrase automatique nous l'indique
            print("Malheureusement vous n'avez plus d'argent et le casino ne fait pas crédit")
        else:# le croupier annonce le début du jeu
            print("Faites vos jeux")

La fonction de condition « if » calcule combien d’argent nous reste-t-il est quand notre porte-monnaie est à 0€ la fonction d’affichage « print » affiche la phrase qui nous informe que notre solde d’argent est de 0€. S’il y a encore de l’argent dans le porte-monnaie alors la fonction « else » intervient pour nous annoncer le droit de continuer misé.

La partie de programme ci-dessous contrôle la mise du joueur mais aussi sa défaite et le lancement de la définition aléatoire.

 mise = int(input("Combien voulez-vous miser? : \n")) # qu'elle est la mise que le joueur veut mettre en jeu
        if mise <= 0 or mise > argent_de_depart: # indique lorsque le joueur met une mise plus basse que 0 et/ou plus élevé que ce qu'il possède
            print("Votre mise doit etre superieur à 0 et votre mise ne doit pas etre plus eleve que votre argent restant\n")
        else:# ici nous devons choisir un nombre entre 0 et 36 et si le nombre choisi ne correspond pas à celui sur lequel la bille s'arrête alors on soustrait son argent de départ par la mise
            argent_de_depart = argent_de_depart - mise
            num = int(input("Choisir un nombre entre 0 et 36 : \n"))
            
        aléatoire()

La mise est composée de deux parties, la première est pour la mise d’argent et la deuxième pour le choix du nombre sur lequel on place la mise. C’est la fonction « int(input()) » qui nous demande la mise que l’on souhaite effectuer et grâce a la fonction « if » elle analyse que notre mise soit supérieure à 0€ mais aussi inférieur a notre somme d’argent totale dans le porte-monnaie. Si l’une de ses conditions n’est pas respectée alors la fonction « print » intervient et une phrase nous rappelle quelles sont les bonnes conditions de mise. Ainsi la structure conditionnelle « else » définit l’argent de départ, autrement dit la structure s’occupe de soustraire ou d’ajouter les valeurs misées à la somme d’argent de départ. Mais cette opération est possible seulement grâce à la valeur « num » qui récupère le nombre choisi par le joueur sur lequel il choisit de miser. C’est donc à ce moment-là qu’on a décidé de faire exécuter la fonction aléatoire qui tire aléatoirement le nombre sur lequel la bille s’arrête.

La fin de notre programme contrôle donc le faite de gagner ou de perdre.

if num == N :
            print("La bille s'arrête sur",N )
            print("Félicitations vous avez trouvé le bon numéro\n")
            argent_de_depart = argent_de_depart + (mise * 2)
            print("Votre porte-monnaie a maintenant une valeur de", argent_de_depart, "€")
        else:# ici on affiche notre défaite et combien nous reste-t-il d'argent sur notre porte monnaie
            print("La bille s'arrête sur", N )
            print("Malheureusement vous n'êtes pas tombé sur le bon numéro, retentez votre chance\n")
            print("Votre porte-monnaie a maintenant une valeur de", argent_de_depart, "€")
            

game()

La fonction conditionnelle « if » contrôle la partie gagnante du jeu en affichant sur quel nombre s’est arrêtée la bille avec le premier « print », avec le second elle lance une phrase qui nous félicite d’avoir gagné et troisième « print » nous annonce à combien est la valeur totale de notre porte-monnaie.

La deuxième partie de la fonction se déroule avec « else » sur le même schéma vue auparavant avec les trois « print » mais pour seule différence le second « print » qui vous annonce que vous n’êtes pas tombé sur le bon numéro.

Conclusion

Pour conclure, ce projet qu’on aurait pu croire facile au premier coup d’oeil fut plus complexe que prévu mais avec de la persévérance et de l’aide de nos professeurs nous avons réussi à atteindre notre but final. Ce projet n’est pas non seulement une réussite au niveau technique mais surtout une réussite au niveau personnel avec la création de son propre jeu. J’espère qu’il vous plaira et n’hésiter pas à l’essayer.