Catégorie : Projets

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

Projets

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.

Projets

Le jeu Plateforme sur la NumWorks en python

Le but du jeu est simple, se déplacer de plateformes en plateformes en essayant d’atteindre la plateforme finale située a la fin du niveau.

Ce jeu est uniquement jouable sur numworks car nous avons utilisé des fonctions uniquement disponible sur numworks.

Pour réaliser notre projet sur Numworks , nous avons eu besoin de plusieurs modules . Nous avons eu en premier temps besoin du module kandinsky qui nous a permis de réaliser les graphismes du jeu. Ensuite nous avons utilisé le module random pour permettre la génération aléatoire des placements des plateformes et de leur taille . Nous avons aussi utilisé les modules ion et time pour définir les touches qui vont nous permettre de jouer et pour définir le temps d’affichage des cinématiques lors de la mort et la victoire.

Le jeu :

Lorsque l’on lance le jeu sur numworks, des plateformes se génèrent aléatoirement et il faut utiliser les flèches pour sauter de plateformes en plateformes jusqu’à atteindre la dernière plateforme d’un niveau.

L’image si dessous correspond a la fin du niveau, avant de sauter sur la plateforme verte, dernière plateforme du niveau.

Les animations :

Une fois sauté sur la plateforme verte, une rideau va descendre et afficher le texte suivant :

Le code ci dessous correspond a l’animation de la victoire. Un rideau vert va s’abaisser. Nous avons créé un rectangle d’un pixel de hauteur et de 32O pixels de large (largeur de l’écran de la calculatrice). Ce rectangle va se répéter 222 fois (hauteur de l’écran de la calculatrice) avec un écart de 0,01 seconde entre chaque rectangle pour faire un effet d’animation.

Mais attention ! Si vous tombez avant la plateformes verte, dans les piques situés en bas de l’écran, un rideau gris apparaitra et une animation aura lieu a :

Le code ci dessous correspond a l’animation lorsque l’on meurt. C’est le même principe que pour l’animation de la victoire mais ici on a codé la tête de mort en plus. Elle se créée avec le module kandinsky en créant des carrés et rectangles. Nous avons également placé une pause de 0,3 seconde entre chaque carré ou rectangle pour accentuer l’animation.

Pour se deplacer de plateformes en plateformes nous avons décidé de créer un personnage. Cette création s’est faite en plusieurs étapes

Les personnages :

personnage statique :

Ce dessin est celui qui a été fait avant de réaliser le personnage sur kandinsky . Nous avons mis en évidence un des rectangles composant le dessin , je l’ai mis en coordonnées 1 et 3 sur le tableau présent sur le croquis pour déterminer les coordonnées à mettre dans le script . Sur la feuille , un carreau représente un carré de 1 par 1 . Le rectangle dessiné à gauche est fait de 2 carrés côte à côte donc le rectangle aura une longueur de 2 pour une hauteur de 1 . Donc si je veux que ce rectangle soit noir , en kandinsky cela donnera :

personnage en mouvement :

Ainsi de même pour le personnage qui cours nous avons mis un autre rectangle en évidence qui sera formé à partir de :

personnage qui saute :

Enfin pour le personnage qui saute , la même règle s’applique et le premier rectangle composant le personnage est fait grâce à : 

Les bases du jeu :

Maintenant la question que vous vous posez surement est: « Comment le niveau se génère aléatoirement ? ».

D’abord, voici le code permettant de réaliser une telle action :

Dans ce code, on peut d’abord remarquer que nous avons décidé de nommer la fonction de génération « randomlevel ». Cette fonction prend en compte 3 listes : « x », « y » et « l ». A titre d’exemple, la première plateforme du jeu aura comme coordonné en x la première variable de la liste « x », aura comme coordonné en y la première variable de la liste « y » et aura comme longueur la première variable de la liste « l ». La première boucle « for » permet de faire répéter la génération aléatoire 15 fois pour obtenir 15 plateformes vu que levell = 15. La première ligne dans cette boucle permet d’insérer la longueur aléatoire se comprenant entre 10 et 80 pixels dans « l ». Ensuite, on a fait en sorte que la première plateforme apparait toujours à une hauteur comprise entre limitup (31) et limitdown (191) et qu’elle apparaisse à une distance de 100 pixels du bord. Pour ne pas rentrer trop dans les détails, on peut dire que le reste du code permet de générer les plateformes a des distances raisonnables les unes des autres pour que les sauts ne soient pas trop long donc impossibles.

Enfin vous vous demandez peut être comment le jeu fonctionne en général ? Ce passage montre bien comment il fonctionne:

Ici on remarque d’abord le « while game == 0: » . Cela permet de faire répéter le programme ci dessus indéfiniment tant que le joueur n’a pas gagné ou n’est pas mort. En effet « break » nous permet de sortir de cette boucle quand le joueur gagne ou perd. Les mouvements pour avancer et reculer sont coder grâce à la logique « if » qui permet à la troisième ligne et à la huitième ligne de réaliser une action quand une touche spécifique de cette dernière est pressée. Dans notre jeu le personnage n’avance pas vraiment. En fait ce sont les plateformes qui bougent mais on a l’impression que c’est le personnage. Cette illusion est utilisée dans presque tout les jeux de plateforme en 2D connus. Ensuite nous avons créer un système de gravité qui fait que le personnage tombe et retombe après un saut. Ce système a été nommé gravityleft et gravityright. Ces deux lignes récupèrent la couleur au pied du personnage. Si la couleur est la couleur d’une plateforme, le personnage ne tombe pas. Si la couleur est la couleur du vide, le personnage tombe. Si la couleur est couleur des piques, le personnage meurt. Si la couleur est la couleur de l’arrivée, le joueur gagne.

Nous pensons que vous avez compris l’idée globale du code maintenant et qu’il est très peu utile de s’intéresser à tous les petits détails. C’est pour cela que c’est à vous de teste le jeux maintenant. Bonne cession !

Conclusion :

Nous espérons que ce jeu vous aura plus et qu’il vous aura donné du fil à retordre !! Nous avons cependant un bug qui ne peut se résoudre car le bug vient de numwork. 

Liens vers le jeu :

https://my.numworks.com/python/charlie18-coquel/jeu_de_platforme

Image mise en avant de notre projet Projets

Un jeu terrifiant revisité en python

Un projet basé sur le jeu de billes de Squid Game

Jeu des billes Squid Game

Présentation

Notre projet repose sur les consignes et conseils que nos professeurs de spécialité NSI nous ont donnés. Nous avons fait le choix du jeu des billes dans Squid Game puisque nous avons adoré cette série et que c’est un jeu qui nous semblait intéressant à développer en python.

Règles du Jeu

Pour cela nous allons tout d’abord faire une brève explication des règles du jeu : Les joueurs doivent deviner combien l’autre joueur à de billes dans la main, si le nombre est pair ou impair. Ils misent un nombre de billes de leur choix. S’il gagne, il remporte une partie des billes de l’adversaire, alors que s’il perd il doit lui donner une partie des siennes, que la personne a misé. Le premier qui n’a plus de billes a perdu la partie.

Extrait de l’épisode

Petite représentation du jeu dans la série

Explication des lignes de code

L’importation du module random

from random import randint

Le module random est un module qui regroupe des fonctions permettant de simuler le hasard. Si nous avons fait le choix de ce module c’est qu’il est indispensable dans notre jeu car l’ordinateur doit faire diffèrent choix. Grâce à ce module il est fait donc au hasard.

Définition du nombre de bille de l’ordinateur et du joueur

nb_bille = [10, 10]

Création d’un tuple dans le but de définir les nombres de billes du joueur et de l’ordinateur

Le choix du jeu et de la mise de l’ordinateur

def choix_mise_ordi():  # Definie la mise de l'ordinateur
    print("A l'ordinateur de miser\nIl a miser")
    return randint(1, nb_bille[0])


def choix_jeu_ordi(): # Definie le choix du jeu de l'ordinateur
     print("A L'ordinateur de choisir\nIl a fait ses jeu")
     choix_jeu_comp = randint(1, nb_bille[0])
     if choix_jeu_comp % 2 == 0:
        nb_comp = "pair"
     else:
        nb_comp = "impair"

Ici nous pouvons voir deux fonctions qui définissent la mise et le jeu de l’ordinateur qui se repose sur le module random.

Le choix du jeu et de la mise du joueur

def choix_mise_joueur(): # Definie le choix de la mise du joueur
    choix_mise = int(input("A vous de miser\nCombien voulez vous miser : "),nb_bille[1])
    return choix_mise


def choix_jeu_joueur():
    choix_jeu = int(input("A vous de jouer\nCombien de bille voulez vous jouez : "),nb_bille[1])
    return choix_jeu

Contrairement au script du dessus ici on va demander au joueur de rentrer sa mise et son jeu donc le module random n’est pas nécessaire.

Déduction du joueur et de l’ordinateur

ef deduction_joueur(): # Definie si le joueur pense que l'ordinateur a choisi un nombre pair ou impair
     choix_deduction = int(input("--- Selon vous l'ordinateur a choisi un nombre paire ou impaire ---\n""Tapez 0 si vous pensez que c'est un nombre pair et tapez 1 si vous penser que c'est un nombre impair\n""Votre choix : "))
     if choix_deduction  % 2 == 0:
        print("Vous avez tapé {0}, tu penses donc que l'ordinateur a choisi un nombre de bille pair".format(choix_deduction))
        nb_gamer = "paire"
     else:
        print("{0} est Impair, donc tu penses qu'il a un nombre de bille impair".format(choix_deduction))
        nb_gamer = "impair"
        return nb_gamer


def deduction_ordi(): # Definie si l'ordinateur pense que le joueur a choisi un nombre pair ou impair
     choix_deduction = randint(1, nb_bille[0])
     if choix_deduction % 2 == 0:
        nb_comp = "pair"
     else:
        nb_comp = "impair"
        return nb_comp

Ces fonctions nous permettent de définir les déductions du joueur et de l’ordinateur en fonction du jeu qu’ont fait ses derniers.

Résultat des jeux et incrémentation des points

def resultat_joueur():
    deduction_gamer = deduction_joueur()
    choix_mise_gamer = choix_mise_joueur()
    choix_jeu_computer = choix_jeu_ordi()
    
    if   deduction_gamer == choix_jeu_computer:# incrementation des billes de l'ordinateur vers le joueur
            print("Vous avez gagné, vous avez",nb_bille[1],"billes")
            nb_bille[1] += choix_mise_gamer
            nb_bille[0] -= choix_mise_gamer
    else:                                    # incrementation des billes du joueur vers l'ordinateur
        print("Vous avez perdu, il vous reste",nb_bille[1],"billes")
        nb_bille[1] -= choix_mise_gamer
        nb_bille[0] += choix_mise_gamer


def resultat_ordi():
    deduction_comp = deduction_ordi()
    choix_mise_comp = choix_mise_ordi()
    choix_jeu_gamer = choix_jeu_joueur()
     
    if   deduction_comp == choix_jeu_gamer: # incrementation des billes de l'ordinateur vers le joueur
            print("Vous avez perdu, il vous reste",nb_bille[1],"billes")
            nb_bille[0] += choix_jeu_gamer
            nb_bille[1] -= choix_jeu_gamer
    else:                                    # incrementation des billes du joueur vers l'ordinateur
        print("Vous avez gagné, vous avez",nb_bille[1],"billes")
        nb_bille[0] -= choix_mise_comp
        nb_bille[1] += choix_mise_comp   

Ces fonctions sont les fonctions finales de notre jeu, elles reprennent toutes les fonctions précédentes. De plus il y a l’incrémentation des points.

Les erreurs qu’on a pu faire

  • Un mauvais choix de jeu dans un premier temps car nous voulons faire à la base le 1, 2, 3 soleil de Squid Game
  • Une interface graphique Tkinter impossible à notre niveau et pas forcément utile pour notre jeu

Les changements qu’on a dû réaliser

  • Changement de jeu pour un plus réalisable
  • abandonner idée de l’interface avec Tkinter
  • Se donner des rôles avec son binôme

Nos astuces

Notre première astuce est celle de regarder des vidéos sur YouTube dans le but de s’améliorer en python puisque nous ne sommes pas très fort.

La seconde est celle de rechercher quelques informations sur internet

Conclusion

Ce projet nous a permis d’apprendre beaucoup de choses dans des domaines différents, que l’on ne savait pas au préalable donc un grand merci a nos professeurs.

Projets

Une partie de Blackjack en Python

Les jeux d’argent ont beau être peu recommandables, il n’empêche qu’ils restent assez divertissants ; et afin de pouvoir y participer depuis chez soi, sans la moindre répercussion sur son compte en banque, je vous propose une partie de Blackjack grâce à un script en Python ! Vous pouvez miser de la fausse monnaie à votre guise ou simplement jouer pour le plaisir. Serez-vous capable de battre le croupier à plat de couture ?

Un dilemme vite résolu

Ma première idée pour ce projet était entièrement différente ; et, à vrai dire, j’avais véritablement l’intention d’opter pour elle. Seulement, l’intitulé de ce devoir était « Une programmation fonctionnelle en Python ». Mon plan initial s’est avéré très peu adapté à cette problématique ; par conséquent, j’ai préféré me rabattre sur mon second choix : le jeu du Blackjack.

De toute manière, mon idée de base était un tantinet trop ambitieuse pour le type de projet qui était à réaliser : je ne regrette pas ma décision de la changer.

Quelques recherches avant de débuter

Je ne pouvais guère me lancer dans l’écriture de mon script avant d’être certain de connaître les règles du Blackjack. Quelques recherches en ligne m’ont permis rapidement de déterminer les points importants à intégrer :

Les tours :

Le joueur commence. Il débute son tour en tirant deux cartes dont les points constituent son score de base. Ensuite, il a le choix de piocher ou non une nouvelle carte. S’il décide de le faire, les points de la carte sont ajoutés à son score ; sinon, il termine son tour. Son but est d’obtenir le score le plus élevé possible sans jamais dépasser vingt-et-un. Si c’est le cas, son tour s’arrête directement.

Ensuite, c’est au croupier de jouer. Dans un véritable casino, ses règles diffèrent légèrement de celles du joueur ; mais par souci de simplicité, j’ai préféré lui donner les mêmes. Son but est d’obtenir un score supérieur à celui du joueur, ou, au moins, de faire égalité.

Lorsque les deux tours touchent à leur fin, on compte les points. Celui qui en possède le plus sans dépasser vingt-et-un est déclaré vainqueur. Il est possible de faire égalité.

Les points :

Chaque carte possède son propre nombre de points :
– de deux à neuf : autant de points que le nombre affiché sur la carte.
– de dix à roi : 10 points.
– As : 1 ou 11 points (au choix du joueur).

Les mises :

Le joueur mise en début de partie une somme ne pouvant dépasser un certain montant. Ce dernier différant de casino en casino, je l’ai réglé à cent-cinquante euros.

Dans un véritable casino, le joueur a la possibilité de doubler sa mise , ou bien d’abandonner et d’en perdre la moitié, en pleine partie ; toutefois, j’ai pris la liberté de ne pas intégrer cette fonctionnalité afin de ne pas compliquer le jeu.

Si le joueur gagne, il récupère le double de sa mise ; en revanche, s’il perd, il ne la recouvre pas. En cas d’égalité, rien ne se passe.

J’ai consigné toutes ces règles dans mon script, affichées au gré du joueur.

Les premiers tests

Je n’ai pas voulu plonger tête première dans l’écriture de mon code sans avant tout faire quelques essais.

Je n’ai intégré que trois cartes au départ : l’as, le deux et le trois, respectivement à un, deux et trois points.

paquet = ("as","deux","trois")
points = (1, 2, 3)
score_joueur = 0

En créant deux n-uplets et en faisant correspondre le nom des cartes avec leur nombre de points, je pouvais aisément créer un système de pioche grâce au module random et donner le nom et les points de la carte tirée.

carte = randint(0,2) # piochage d'une carte au hasard
print("Votre première carte est un", paquet[carte])
score_joueur += points[carte] # points de la carte ajoutés au score du joueur

carte = randint(0,2)
print("Votre seconde carte est un", paquet[carte])
score_joueur += points[carte]

print("Votre score de base est de", score_joueur)

Lorsque la variable « carte » est égale à 0, par exemple, elle prend le premier item du n-uplet « paquet » et « points » qui correspondent respectivement à « as » et « 1 ». En revanche, si, pour la seconde carte, la variable « carte » vaut 2, elle prend le troisième item des deux n-uplets qui est « trois » et « 3 ». Une autre variable « score_joueur » récupère les points gagnés afin de constituer le score.

Dans cette situation, le script afficherait :

J’ai ainsi codé le début du tour du joueur.

Afin de respecter l’intitulé du projet (« Une programmation fonctionnelle en Python »), j’ai placé cette partie de code dans une fonction que j’ai nommée « base() ». J’ai également rendu la variable « score_joueur » globale de sorte qu’elle soit utilisable dans toutes les fonctions.

paquet = ("as","deux","trois")
points = (1, 2, 3)
score_joueur = [0]

def base():
    carte = randint(0,2) # piochage d'une carte au hasard
    print("Votre première carte est un", paquet[carte])
    score_joueur[0] += points[carte] # points de la carte ajoutés au score du joueur
    carte = randint(0,2)
    print("Votre seconde carte est un", paquet[carte])
    score_joueur[0] += points[carte]
    print("Votre score de base est de", score_joueur[0])
    
base()

Et, à partir de cette base, j’ai codé la partie « joueur » du jeu.

La partie « joueur »

Puisque le système qui met en place le score de base était déjà intégré, je me suis ensuite attelé au codage du reste du tour.

Selon les règles du Blackjack, le joueur décide s’il souhaite piocher une nouvelle carte ou non tant que son score est inférieur à vingt-et-un. Subséquemment, j’ai repris le code de la fonction « base() » dans une nouvelle fonction nommée « choix_joueur() » et ajouté une condition pour qu’il soit exécuté :

def choix_joueur():
    while score_joueur[0] < 21: # tant que le score du joueur est strictement inférieur à 21, il peut continuer de piocher
        ch = input("[Voulez-vous piocher ?] " )
        if ch == "o": # si le joueur continue de piocher
            carte = randint(0,2) # piochage d'une carte au hasard
            print("Vous piochez un", paquet[carte])
            score_joueur[0] += points[carte] # points de la carte ajoutés au score du joueur
            print("Votre score est de", score_joueur[0], "\n")
        elif ch == "n": # si le joueur cesse de piocher
            print("Vous décidez de vous arrêter.")
            break

Ce script peut, par exemple, afficher :

Afin que cette fonction se lance, je l’ai appelée à la fin de « base() » :

def base():
    carte = randint(0,2) # piochage d'une carte au hasard
    print("Votre première carte est un", paquet[carte])
    score_joueur[0] += points[carte] # points de la carte ajoutés au score du joueur
    carte = randint(0,2)
    print("Votre seconde carte est un", paquet[carte])
    score_joueur[0] += points[carte]
    print("Votre score de base est de", score_joueur[0])
    score_joueur() # suite du tour

Si le joueur dépasse le score de vingt-et-un, il perd automatiquement. J’ai, de ce fait, défini une fonction « defaite() » qui est appelée si le joueur va trop loin :

def choix_joueur():
    while score_joueur[0] < 21: # tant que le score du joueur est strictement inférieur à 21, il peut continuer de piocher
        # [...]
    if score_joueur[0] > 21:
    	defaite()

def defaite(): # lorsque le joueur perd
    print("Vous avez perdu...")

En revanche, si le joueur tombe pile sur vingt-et-un, il ne gagne pas automatiquement puisque le croupier pourrait faire égalité ; à la place, le jeu passe directement au tour du croupier et ne laisse pas le choix de tirer ou non une nouvelle carte. Étant donné que cesser de piocher et atteindre le score de vingt-et-un ont les mêmes conséquences, j’ai regroupé ces deux conditions en une seule :

    if score_joueur[0] > 21:
    	defaite()
    else:
        choix_ordi()

(La fonction « choix_ordi() » sera détaillée dans la prochaine partie : elle correspond au tour du croupier.)

Avec le codage du tour du joueur terminé, je pouvais désormais m’affairer à celui du croupier.

La partie « croupier »

Une fois la partie « joueur » créée, il ne suffisait que de recopier son code et de lui retirer son interactivité afin de programmer la partie « croupier ».

Ainsi, j’ai définie la fonction « choix_ordi » (montrée dans la partie précédente) et ajouté une nouvelle variable globale que j’ai nommée « score_ordi ». Le croupier continue de piocher tant qu’il n’a pas dépassé le score du joueur.

paquet = ("as","deux","trois")
points = (1, 2, 3)
score_joueur = [0]
score_ordi = [0]

def base():
	#[...]

def choix_joueur():
	#[...]

def choix_ordi():
    carte = randint(0,2) # piochage d'une carte au hasard
    print("La première carte du croupier est", paquet[carte])
    score_ordi[0] += points[carte] # points de la carte ajoutés au score du croupier
    carte = randint(0,2)
    print("La seconde carte du croupier est", paquet[carte])
    score_ordi[0] += points[carte]
    print("Le score de base du croupier est de", score_ordi[0], "\n")
    while score_ordi[0] < score_joueur[0]: # le croupier ne cessera pas de piocher tant que son score est inférieur à celui du joueur
        carte = randint(0,2)
        print("Le croupier pioche", paquet[carte])
        score_ordi[0] += points[carte]
        print("Le score du croupier est de", score_ordi[0], "\n")
    if score_ordi[0] > 21: # si le score du croupier dépasse 21, le joueur gagne automatiquement
      	reussite()
    else:
        print("Le croupier décide de s'arrêter.")
        defaite()

def defaite(): # lorsque le joueur perd
    print("Vous avez perdu...")

def reussite(): # lorsque le joueur gagne
  	print("Vous avez gagné !")

J’ai également créé la fonction « reussite() » qui est appelée lorsque le joueur gagne la partie.

La partie « croupier » m’a amené à réfléchir à l’intelligence artificielle de mon ordi. Oui, il est logique qu’il cesse de piocher lorsque son score est supérieur à celui du joueur et qu’il ne le fasse pas avant ; mais s’il tombe pile sur son score ? Devrait-il continuer et peut-être dépasser vingt-et-un où devrait-il s’arrêter ? En prenant en compte le système de mise d’argent, je me suis rendu à l’évidence qu’il valait mieux que, à un certain stage, si les deux scores sont identiques, le croupier ne tente pas sa chance.

J’ai donc complété la boucle while de la fonction afin qu’elle corresponde à mes attentes et est défini une nouvelle fonction : « egalite() ».

def choix_ordi():
    # [...]
    while score_ordi[0] <= score_joueur[0]:
        if score_ordi[0] == score_joueur[0]:
            if score_joueur[0] >= 15:
                break # si le score du croupier est égal à celui du joueur et est supérieur ou égal à 15, il cesse de piocher automatiquement
       # [...]
    if score_ordi[0] > 21:
    	reussite()
    else:
      	print("Le croupier décide de s'arrêter.")
      	if score_ordi[0] > score_joueur[0]:
      		defaite()
      	else:
      		egalite()

def egalite():
  	print("Vous avez fait égalité.")

Désormais, si le croupier fait un score identique à celui du joueur, il arrête de piocher s’il est au minimum à quinze ; sinon, il continue. Mon résonnement est simple : lorsque j’implémenterai le reste des cartes (partie suivante), il y aura plus de chances de dépasser vingt-et-un en piochant une carte à partir de quinze que non. Le croupier ne préfère pas tenter le diable.

Par ailleurs, un problème assez flagrant est visible à l’affichage de ce code, dans la console : tout le texte qui décrit le tour du croupier est imprimé en une fois, sans laisser le temps au joueur de lire.

(Texte imprimé en un coup.)

Le rythme d’affichage sera réglé plus tard, dans la partie « Les finitions ».

Le reste des cartes

Une fois la structure du jeu quasiment terminée (ne manquant que le système de mises et de banque qui sera traité dans la prochaine partie), je me suis décidé à ajouter le reste des cartes.

paquet = ("as","deux","trois","quatre","cinq","six","sept","huit","neuf","dix","valet","dame","roi")
points = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10)

Bien entendu, je ne me suis pas soucié de la couleur de chacune étant donné que seule la valeur importe dans le jeu du Blackjack.

D’autre part, j’ai changé le système de pioche en écrivant :

carte = randint(0,12)

Une fois le paquet entier codé, j’ai constaté un problème avec la carte « dame ». Lorsque cette dernière était piochée, il était affiché :

« Vous piochez un dame ». Quand bien même cette erreur est anodine, j’ai préféré la régler directement. De ce fait, j’ai modifié le n-uplet contenant le nom des cartes en ajoutant le bon article :

paquet = ("un as","un deux","un trois","un quatre","un cinq","un six","un sept","un huit","un neuf","un dix","un valet","une dame","un roi")

Ensuite, j’ai retiré les mots qui compromettaient cette nouvelle organisation :

print("Vous piochez", paquet[carte]) # au lieu de "print("Vous piochez un", paquet[carte])"

Le cas de l’as

Selon les règles du Blackjack, lorsqu’un as est tiré, le joueur peut choisir entre un et onze points. Par souci de fidélité au vrai jeu, j’ai décidé d’intégrer cette fonction. Cela signifiait deux choses : je devais donner la possibilité au joueur de prendre la décision et je devais programmer une intelligence artificielle qui choisirais la meilleure tactique.

Pour la première problématique, j’ai implémenté une condition qui vérifie si un as est tiré ou non. Si c’est le cas, un choix est donné au joueur :

def base():
    carte = randint(0,12)
    print("Votre première carte est", paquet[carte])
    if carte == 0: # si la carte est un as (choix entre 1 et 11 points)
        As = int(input("Préférez-vous qu'elle vaille 1 ou 11 points ? "))
        if As == 1:
            carte = 0
            print()
        elif As == 11:
            carte = 13
            print()
    score_joueur[0] += points[carte]
    carte = randint(0,12)
    print("Votre seconde carte est", paquet[carte])
    if carte == 0:
        As = int(input("Préférez-vous qu'elle vaille 1 ou 11 points ? "))
        if As == 1:
            carte = 0
            print()
        elif As == 11:
            carte = 13
            print()
    score_joueur[0] += points[carte]
    print("Votre score de base est de", score_joueur[0], "\n")
    choix_joueur()

Ici, si la variable « carte » prend la valeur 0, elle correspond au premier item du n-uplet « paquet » qui se trouve être as. Dans ce cas, le script donne le choix au joueur. S’il opte pour un point, on donne à la variable « carte » la valeur 0 ; en revanche, s’il opte pour onze points, on lui donne la valeur 13, soit le douzième item du n-uplet « points ».

Cela nous donne :

On applique ce processus à la fonction « choix_joueur() » :

def choix_joueur():
    while score_joueur[0] < 21:
        ch = input("[Voulez-vous piocher ?] " )
        if ch == "o":
            carte = randint(0,12)
            print("Vous piochez", paquet[carte])
            if carte == 0: # si la carte est un as (choix entre 1 et 11 points)
                As = int(input("Préférez-vous qu'il vaille 1 ou 11 points ? "))
                if As == 1:
                    carte = 0
                    print()
                elif As == 11:
                    carte = 13
                    print()
            score_joueur[0] += points[carte]
            print("Votre score est de", score_joueur[0], "\n")
        elif ch == "n":
            print("Vous décidez de vous arrêter.")
            break
    if score_joueur[0] > 21:
        defaite()
    else:
        choix_ordi()

Dès lors que la partie « joueur » est complétée, je pouvais m’atteler au processus de décision de l’ordi en commençant avec les deux cartes piochées au début de son tour.

Que la première carte piochée vaille un ou onze points, cela n’importe guère. Par conséquent, j’ai décidé de laisser le hasard faire les choses :

def choix_ordi():
    carte = randint(0,12)
    print("La première carte du croupier est", paquet[carte])
    if carte == 0: # si la carte du croupier est un as
        As = randint(1,2) # le croupier choisi au hasard entre 1 et 11 points
        if As == 1:
            print("Le croupier préfère que la carte vaille 1 point.")
            carte = 0
        else:
            print("Le croupier préfère que la carte vaille 11 points.")
            carte = 13        
    score_ordi[0] += points[carte]

Par contre, pour la deuxième carte, le processus est légèrement plus complexe.

Tout d’abord, si la première carte était un as à onze points, il est impératif que le croupier opte pour un point pour sa deuxième carte afin de ne pas dépasser vingt-et-un. Ce cas de figure, quand bien même plutôt rare, reste tout de même important à prendre en compte.

Sinon, il faut vérifier si ajouter onze au score du croupier le fait dépasser celui du joueur. Si c’est le cas, le deuxième as devrait correspondre automatiquement à onze points.

Si aucun de ces deux conditions n’est vraie, le croupier choisit au hasard.

carte = randint(0,12)
    print("La seconde carte du croupier est", paquet[carte])
    if carte == 0:
        if score_ordi[0] + 11 > 21: # si ajouter 11 points au score actuel du croupier le fait dépasser 21, l'as vaut 1 point
            print("Le croupier préfère que la carte vaille 1 point.")
            carte = 0
        elif score_ordi[0] + 11 >= score_joueur[0]: # si ajouter 11 points au score actuel du croupier le fait atteindre le score du jouer, l'as vaut 11 points 
            print("Le croupier préfère que la carte vaille 11 points.")
            carte = 13
        else:
            As = randint(1,2) # sinon, le croupier choisi au hasard entre 1 et 11 points
            if As == 1:
                print("Le croupier préfère que la carte vaille 1 point.")
                carte = 0
            else:
                print("Le croupier préfère que la carte vaille 11 points.")
                carte = 13
    score_ordi[0] += points[carte]

La même logique est appliquée pour le reste du tour.

Maintenant que toutes les cartes sont programmées, le projet ne semble plus très loin de sa fin. Encore quelques efforts !

Le système de mises et de banque

Un jeu d’argent ne serait rien sans l’argent lui-même.

La « banque » correspond à la quantité d’argent détenu par le joueur. Dans le code, elle est représentée par une variable globale :

banque = [300]

Par défaut, elle contient trois-cents euros (ce montant sera expliqué plus tard).

J’ajoute au système de banque la possibilité de miser en début de partie grâce à la fonction « miser() » :

mise = [0]

def miser():
    euro = int(input("Combien d'euros souhaitez-vous miser ? "))
    mise[0] = euro
    print()
    base()

La fonction globale « mise » sert à récupérer le montant versé par le joueur pour ensuite, lorsque la partie touche à sa fin, modifier la banque.

Dans la partie « Quelques recherches avant de débuter », j’ai expliqué que les casinos mettent en place un montant maximum pour les mises. J’ai élevé le mien à cent-cinquante euros. Une condition doit être implémentée dans la fonction afin de respecter ce choix.

def miser():
    while True:
    	euro = int(input("Combien d'euros souhaitez-vous miser ? (150 maximum) "))
    	if euro > 150: # si la mise est supérieure à 150
        	print("Vous devez miser en-dessous de 150 €.\n")
    	else:
        	break
    mise[0] = euro
    print()
    base()

Outre le montant de cent-cinquante euros, la mise du joueur ne peut pas dépasser le contenu de sa banque. Par exemple, si la banque du joueur contient cent euros, il ne peut pas en miser cent-cinquante.

def miser():
    while True:
    	euro = int(input("Combien d'euros souhaitez-vous miser ? (150 maximum) "))
    	if euro > 150: # si la mise est supérieure à 150
        	print("Vous devez miser en-dessous de 150 €.\n")
        elif euro > banque[0]: # si la mise est supérieure au contenu de la banque
        	print("Vous ne pouvez pas miser davantage que vous possédez (Votre banque contient", banque[0], "€)\n")
    	else:
        	break
    mise[0] = euro
    print()
    base()

Enfin, une mise négative ou nulle ne peut être acceptée : elle doit valoir au minimum un euro.

def miser():
    while True:
    	euro = int(input("Combien d'euros souhaitez-vous miser ? (150 maximum) "))
    	if euro > 150: # si la mise est supérieure à 150
        	print("Vous devez miser en-dessous de 150 €.\n")
        elif euro > banque[0]: # si la mise est supérieure au contenu de la banque
        	print("Vous ne pouvez pas miser davantage que vous possédez (Votre banque contient", banque[0], "€)\n")
    	elif euro <= 0: # si la mise vaut 0 ou moins
        	print("Vous devez miser davantage afin de pouvoir participer.\n")
        else:
        	break
    mise[0] = euro
    print()
    base()

La fonction est affichée de cette manière dans la console :

Désormais, il ne reste qu’à programmer les conséquences qui viennent modifier la banque lors d’une réussite ou défaite.

Lors d’une défaite, le joueur perd simplement la mise.

def defaite():
    print("Vous avez perdu...")
    banque[0] -= mise[0] # on soustrait à la banque la mise
    print("Votre banque contient", banque[0], "€") # affichage du contenu de la banque
	nouvelle_partie()

def nouvelle_partie():
    rejouer = input("Désirez-vous refaire une partie ? (\"o\" ou \"n\") ")
    if rejouer == "o": # si le joueur veut refaire une partie, son score ainsi que celui du croupier sont réinitialisés
        score_joueur[0] = 0
        score_ordi[0] = 0
        print()
        miser()
    elif rejouer == "n":
        fin()

def fin(): # lorsque le joueur ne veut pas refaire une partie
    print()
    print("À la prochaine !")

Entre autre, j’ai défini deux autres fonctions : « nouvelle_partie() » qui propose au joueur de rejouer et réinitialise les scores, et « fin() » si le joueur veut finir la partie.

Le processus est similaire pour la fonction « reussite() » :

def reussite():
  	print("Vous avez gagné !")
	banque[0] += 2 * mise[0] # on ajoute à la banque le double de la mise
    print("Votre banque contient", banque[0], "€")
    nouvelle_partie()

Une fois ces fonctionnalités programmées, un problème m’a sauté aux yeux : à quoi sert ce système de banque et de mise si, au final, cela n’a pas de conséquences ? Afin de donner un but précis au jeu, j’ai programmé la possibilité de perdre la partie si le contenu de la banque descend à zéro ou moins, ou de la gagner si le contenu atteint les mille euros.

def defaite():
    print("Vous avez perdu...")
    banque[0] -= mise[0]
    print("Votre banque contient", banque[0], "€")
    if banque[0] <= 0: # si la banque est vide, le joueur perd la partie
        print("Vous ne possédez plus assez d'argent pour pouvoir participer.")
        print("Vous êtes complétement ruiné !")
        rejouer = input("Désirez-vous rejouer ? (\"o\" ou \"n\") ")
        if rejouer == "o": # réinitialisation des paramètres
            banque[0] = 300
            score_joueur[0] = 0
            score_ordi[0] = 0
            print()
            miser()
        elif rejouer == "n":
            fin()
    else:
        nouvelle_partie()

Cette partie de code affiche :

def reussite():
  	print("Vous avez gagné !")
	banque[0] += 2 * mise[0]
    print("Votre banque contient", banque[0], "€")
    nouvelle_partie()
	if banque[0] >= 1000: # si le contenu de la banque atteint les 1000 €, le joueur gagne la partie
    	print("Votre banque contient", banque[0], "€ : vous avez atteint les 1000 € !\n")
    	print("Vous gagnez la partie !")
    	fin()
    else:
      	nouvelle_partie()
      

Implémenter ces fonctionnalités m’a également fait prend conscience d’une chose : peut-être que le joueur n’aimerait pas mettre de l’argent en jeu et désirerait simplement faire une partie pour le plaisir. De ce fait, je lui ai donné la possibilité de choisir entre deux modes : le mode « libre », sans mises, ou le mode « casino ».

mode = ["libre"]

mode[0] = input("Quel mode de jeu voulez-vous : libre ou casino ? ")

Ce morceau de code sera intégré à la fonction « menu() » dont je parlerai dans la prochaine partie.

Les modifications causées par le choix du mode sont assez nombreuses ; il est conseillé d’aller vérifier le code lui même donné à la fin de l’article.

Les finitions

Je touchait presque la fin de mon projet, seulement quelques bricoles restaient à régler.

Premièrement, il fallait intégrer les règles du Blackjack au début afin d’informer le joueur. Elles sont affichées grâce à la fonction « menu() », la première à être appelée dans le code.

def menu(): # première chose affichée
    print("Bienvenue au jeu du Blackjack !")
    regles = input("Souhaitez-vous lire les règles ? (\"o\" ou \"n\") ")
    if regles == "o": # affichage des règles
        # [...]
    print()
    mode[0] = input("Quel mode de jeu voulez-vous : libre ou casino ? ")
    if mode[0] == "libre":
        base()
    elif mode[0] == "casino": # contenu de la banque donné pour la première mise, inutile après la première partie
        print()
        print("Votre banque contient", banque[0], "€")
        miser()

Cela nous donne :

(L’entièreté des règles est affichée dans le script donné à la fin de cet article.)

Un autre problème à régler était le rythme du jeu : le texte était affiché en une seule fois, rendant l’expérience de jeu bien laborieuse. Grâce au module time et à sa fonction « sleep() », j’ai pu rendre l’affichage plus lent, imitant presque le chargement d’un vrai jeu vidéo !

Le dernière point le plus complexe à régler était l’espacement entre certaines lignes : afin que l’affichage soit cohérent, les sauts à la ligne doivent conserver la même logique. Je vous épargne toutes les modifications faites, hormis une que je trouve particulièrement pratique :

print()
print("------------------------------------\n")
sleep(1)

Cette barre de séparation aide vraiment à discerner les différentes parties du jeu à l’affichage, ce qui permet au joueur de mieux se repérer dans la partie.

Pour terminer, j’ai quelque peu modifié les choix qui sont présentés au fil d’une partie afin que le joueur ne puisse pas entrer n’importe quoi, grâce à une boucle while :

while True: # choix du mode
	mode[0] = input("Quel mode de jeu voulez-vous : libre ou casino ? ")
    if mode[0] != "libre" and mode[0] != "casino":
    	print("Désolé, mais ce n'est pas un choix proposé.\n")
        sleep(2)
    else:
        break

Et enfin, après quelques ajouts esthétiques, le script est enfin achevé !

Conclusion

Malgré la taille du projet et mon niveau peu haut en matière d’écriture de script, coder ce jeu a été plutôt plaisant, et chaque problème rencontré m’a paru comme une énigme à résoudre. Oui, quelquefois, j’ai été frustré par les bugs qui semblaient impossibles à régler ; mais à force de patience et persévérance, je suis parvenu à un script satisfaisant à mon goût ainsi qu’un jeu qui fonctionne !

Le script à télécharger

Projets

Générateur leet speak en python

ParL32 v0U2 l3 1337 5p3aK ? C3 pr0j37 357 un 9ÉNÉrA73ur 3n py7h0N d3 1337 5p3ak…

Présentation

Ce projet a été réalisé par Lena G. en classe de première G5 dans le cadre de leur enseignement de spécialité NSI (numérique et sciences de l’informatique), au lycée Louis Pasteur à Avignon.
Avec comme matériel un ordinateur équipé du logiciel Thonny.

Le leet speak

Le leet speak et un langage qui remplace les caractères d’un mot ou d’une phrase par un caractère voisin visuellement, il est créé à la fin des années 80 par des programmeurs informatiques. Il existe plusieurs niveaux de codage :

  • Codage simple Leet Speak = LeeT 5Pe4k
  • Codage simple Leet Speak = |_337 $|>34|<

Description du programme

Les listes

J’ai d’abord créé 3 listes avec tous les caractères utilisables, la première correspond au langage naturel que va entrer l’utilisateur, la seconde sera la traduction du caractère dans un langage simple à traduire et la troisième dans un langage complique à déduire.

liste_1 = ("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", " ","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","é","è","à","'",".")
liste_2 = ("4", "8", "C", "D", "e", "F", "9", "H", "1", "j", "k", "L", "m", "N", "0", "P", "Q", "R", "5", "T", "u", "V", "W", "X", "Y", "2", " ", "4", "8", "C", "D", "e", "F", "9", "H", "1", "j", "k", "L", "m", "N", "0", "P", "Q", "R", "5", "T", "u", "V", "W", "X", "Y", "2","é","è","À","'",".")
liste_3 = ("4", "8", "(", "|)", "3", "|=", "9", "}{", "1", "_|", "|<", "|_", "|\/|", "N", "0", "|>", "().", ".-", "$", "7", "|_|", "\/", "\|/", "><", "`/", "2", " ", "4", "8", "(", "|)", "3", "|=", "9", "}{", "1", "_|", "|<", "|_", "|\/|", "N", "0", "|>", "().", ".-", "$", "7", "|_|", "\/", "\|/", "><", "`/", "2","⋷","ē","ἀ","ノ","•")

Les fonctions de traduction

J’ai créé 2 fonction quasi-identique, elle consiste toutes deux à prendre chaque caractère (que l’utilisateur aura entre) qui se trouve dans « liste 1 » et en parcourent une des 2 autres listes, ressortir le caractère correspondent dans « liste 2 » pour la première fonction « code_1(mot) » et « liste 3 » pour la deuxième fonction « code_2(mot) ». Soit une boucle ou tant que le caractère de « liste 1 » n’a pas atteint le caractère correspondant dans l’autre liste, on continue à parcourir la liste en question. Une fois le caractère atteint, il remplace le caractère de la première liste.

def code_1(mot):
    mot_traduit = ""
    for i in mot:
        k = 0
        while liste_1[k] != i:
            k += 1
        mot_traduit += liste_2[k] 
    return mot_traduit

def code_2(mot):
    mot_traduit = ""
    for i in mot:
        k = 0
        while liste_1[k] != i:
            k += 1
        mot_traduit += liste_3[k] 
    return mot_traduit

Fonction menu

La fonction « menu » laisse l’utilisateur choisir s’il souhaite changer ce qu’il veut entrer, en langage simple ou compliquer en entrant soit 1 pour simple soit 2 pour compliquer. S’il choisit 1, l’utilisateur entrera ses caractères et il se lancera la fonction « code_1(mot) ». S’il choisit 2, l’utilisateur entrera ses caractères et il se lancera la fonction « code_2(mot) ». S’il ne choisit un autre chiffre que 1 ou 2, il s’affichera « Choix non-valide » est relancera le menu.

def menu():
    print("Langage simple:\t 1")
    print("Langage compliqué:\t 2")
    choix = int(input("Choisissez le langage de départ:\t"))
    if choix == 1:
        mot_origine = input("Veuillez rentre le mot d'origine :")
        print(code_1(mot_origine))
        print("\n")
        menu()
    elif choix == 2:
        mot_origine = input("Veuillez rentre le mot d'origine :")
        print(code_2(mot_origine))
        print("\n")
        menu()
    else :
        print("Choix non-valide\n")
        menu()

Conclusion

J’espère que mon programme vous sera utile.
Vous pouvez le récupérer si vous voulez l’améliorer.

Projets

Une bataille navale codée en python sur NumWorks

Jouez contre une composition aléatoire au grand classique du jeu de société : la bataille navale ! Devinez ou sont cachés les bateaux en un minimum de temps.

Introduction

Projet réalisé par A. Juge, P. Moucadeau et B. Kerneïs de la classe de première en spécialité NSI. Nous sommes également les auteurs de ce compte rendu. Pour en savoir plus : Les projets en spécialité NSI

Lien court vers ce document : https://nsi.xyz/battleship

Jouez à l’incontournable jeu de la bataille navale directement sur votre calculatrice NumWorks ou sur un émulateur compatible avec le module kandinsky (Omega – IDE) !

La bataille navale ou touché-coulé est un jeu de société commercialisé en 1831 qui se joue à deux joueurs. Le principe du jeu, si vous ne le connaissez pas, est de placer des « navires » sur une grille tenue secrète et de tenter de couler les navires adverses. La partie s’arrête lorsque l’un des deux joueur a réussi à couler tous les navires de l’autre joueur.

Dans le cadre de notre projet, le jeu codé en python a été simplifié : le joueur essaie de deviner la composition de l’ordinateur qui a été générée aléatoirement et ainsi, le jeu ne se joue que dans un seul sens. C’est à dire que le joueur ne peut que gagner ! Incroyable non ?

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

Évolution

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

La première grille
Avec le module kandinsky, nous avons commencé par reprendre et améliorer le code de Schraf : Maths-info qui nous a permit de construire une grille de 10*10

def grille():
    '''
   Tracé de la grille
   '''
    for i in range(11):
        if i<11:fr(50,10+20*i,200,1,N)
        fr(50+20*i,10,1,200,N)

Interaction homme/machine
Ensuite, nous avons crée un « curseur » qui peut se déplacer dans cette grille en récupérant les touches pressées par le joueur grâce au module ion.

Cette portion de code sert à attendre que l’utilisateur appuie sur une touche et la récupérer.

def wait(b):
    while Partie:
        for i in b:
            if keydown(i):
                while keydown(i):True
                return i

code inspiré de Arthur Jacquin

La classe bateau
La création d’une classe bateau nous a permit de simplifier le code, notamment pour ce qui est de détecter si un bateau est touché et/ou couléuniquement avec les coordonnées du début et de la fin

bateaux1,y1x2,y2état
11,21,4touché
26,49,4safe
38,28,5coulé

Les méthodes is_touche et is_coule sont la pour repérer si un bateau est touché ou coulé lorsque le joueur décide de tirer sur une case. Elles utilisent la liste des cases composant le bateau.

def is_touch(self,x,y):
        ''''Méthode revoyant Vrai si le bateau est touché 
       et Faux si il ne l'est pas
       '''
        l = [x,y]
        for i,elt in enumerate(self.LC):
            if elt == l:
                self.etat = 1
                self.L_etats[i] = 1
                return True
      
        return False
    
    def is_coule(self):
        '''Méthode revoyant Vrai si le bateau est coulé 
       et Faux si il ne l'est pas
       '''
        if self.etat == 2:
            return True
 
        for i in self.L_etats:
            if i != 1:
                return False
 
        for j in self.LC:
            ca(j[0],j[1],N)
 
        self.L_etats = []
        for i in range(len(self.LC)):
            self.L_etats.append(2)
 
        self.etat=2
        print(self, "est coulé")
        return True

Le cerveau du programme
La fonction Main représente la boucle principale, c’est elle qui récupère les boutons pressés par les joueurs pour appeler les autres fonctions. La boucle s’arrête lorsque tous les bateaux sont dans l’état coulé.
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 de coups.

def Main(n):
    '''Boucle principale'''
    global X,Y,Partie,NBcoups,NBtouches,LB
    LB = compo(n)
    grille()
    ca(X,Y,G)
    print(Partie)
    while Partie:
        t = wait([0,1,2,3,4,])
        if t == 3 and X+1<10:
            majcase(X,Y,X+1,Y)
            X+=1
        elif t == 0 and X>0:
            majcase(X,Y,X-1,Y)
            X-=1
        elif t == 1 and Y>0:
            majcase(X,Y,X,Y-1)
            Y-=1
        elif t == 2 and Y+1<10:
            majcase(X,Y,X,Y+1)
            Y+=1
        elif t == 4:
            touche(X,Y)
        ds("Coups",255,10,Bl)
        ds(str(NBcoups),255,30)
        ds("Touches",251,50,R)
        ds(str(NBtouches),255,70)

Le tirage aléatoire de la composition
Il a fallu ensuite générer aléatoirement la composition des bateaux de l’adversaire. Le module random nous a été très utile. La difficulté principale a été de faire que les bateaux ne dépassent pas de la grille. Nous avons donc décalés les bateaux étant dans cette situation en modifiant les coordonnées x1, y1 de ce dernier.

def compo(n):
    '''Générateur de composition aléatoire'''
    L= []
 
    for i in range(n):
        ori = randint(0,1)
        sens = randrange(-1,2,2)
        longueur = randint(2,4)
        x1 = randint(0,10)
        y1 = randint(0,10)
 
        if ori == 0:
            x2 = x1
            y2 = y1+(longueur*sens)
            c1 = y1
            c2 = y2
        else :
            x2 = x1+(longueur*sens)
            y2 = y1
            c1 = x1
            c2 = x2
        
        if c2 > 9:
            c1 = c1 - (c2-9)
            c2 = c1+(longueur*sens)
        elif c2 < 0:
            c1 = c1 - c2
            c2 = c1+(longueur*sens)
        
        if ori == 0:
            L.append(bateau(x1,c1,x2,c2))
        else :
            L.append(bateau(c1,y1,c2,y2))
    
    return L

Interface graphique
Puisque les conditions de jeu ne changent pas (mode de jeu, nombre de bateaux…), la présence d’un menu augmente inutilement la taille du fichier. Nous avons alors opté pour insérer une image d’accueil qui s’efface au bout de 2 secondes. Le jeu se lance lorsque les 2 secondes sont écoulées.

def play():
    fill_rect(0,0,320,222,(255,255,255))
    texte_center("Battleship", 160, 20, col_os())
    texte_center("nsi.xyz/battleship ", 160, 50, N)
    texte_center("par", 160, 80, (101,101,101))
    texte_center("Alexandre Juge", 160, 100, (42,42,42))
    texte_center("Pierre Moucadeau", 160, 120, (42,42,42))    
    texte_center("Baptiste Kerneis ", 160, 140, (42,42,42))
    sleep(2)
    fill_rect(0,0,320,222,(255,255,255))
    Main(5)
Résultat des crédits

Par la suite nous avons rajouté 2 compteurs, un comptant le nombre de coup et l’autre le nombre de bateau touché.

Lorsque le nombre de bateau touché est égale au nombre de bateau il lance un menu de fin.

def end():
    global NBcoups
    fill_rect(0,0,320,222,B)
    texte_center("Battleship", 160, 20, col_os())
    texte_center("Vous avez fait un score de :", 160, 50, N)
    texte_center(str(NBcoups), 160, 80, col_os())
    texte_center("Vous pouvez faire mieux !", 160, 100, (42,42,42))

Mention spéciale

Mention spéciale à la toute petite fonction ca qui malgré ses 2 lignes est la fonction la plus utile puisque elle permet de remplir un case. Et oui, tout simplement

Ce n’est pas la taille qui compte , « Un grand sage »

def ca(x,y,c=G):
    ''' Remplis la case x,y avec la couleur c '''
    fr(51+20*x,11+20*y,19,19,c)

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 fichier, supérieur à 8ko donc inutilisable sur la calculatrice, ont a alors dut supprimer le mode multijoueur car prenant trop de place.

Deuxièmement les bateaux généré étaient magnifique mais complètement en dehors de la grille.

Certains bateaux étaient générés en dehors de la grille

Pour régler ce problème nous avons rajouter une condition à la formation des bateaux qui fait ,que lorsqu’ils se trouvent en dehors de l’intervalle de la grille ,ils sont décalés à l’intérieur de la grille .

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 la bataille navale et rabattu sur une parti en solo.

Conclusion 

Pour pouvoir jouer à cette version du jeu bataille navale, téléchargez le code par l’intermédiaire du lien ci-dessous. Les commandes sont assez intuitives : les flèches pour se déplacer, et le bouton OK pour interagir.
Amusez-vous bien !

Crédits / Remerciements 

Tout d’abord un grand merci aux fragments de codes de Arthur Jacquin, notamment son menu (réalisé avec @cent20). 
Ainsi que M.Schraf pour ses tutos très utiles sur la couche graphique de Python

Téléchargement