Author: Bilal L.

Projets

Le jeu du morpion en python

Nous avons réalisé ce projet dans le cadre d’un travail demandé par nos professeurs de NSI, nous avions le choix entre différents projets mais avons choisi le morpion car nous voulions réaliser un jeu pour finir l’année en beauté.

Introduction

Cet article vous présentera le dernier projet de la spécialité NSI que nous avons réalisé avec Bilal L., Corentin K. et Joseph A.

Pour ce dernier projet nous avons décidé de faire le jeu du Morpion sur la calculatrice Numworks en python. Pour cela nous avons dû utiliser différents modules et faire des recherches variées pour savoir comment coder ce jeu. C’est ce que nous allons vous expliquer dans ce compte rendu.

Bonne lecture !

Quelques fonctions basiques mais importantes

Premièrement, nous avons regardé quelques vidéos et sites web pour savoir par où commencer, nous sommes finalement tombés sur la vidéo de « Schraf : Maths-info” (une chaîne YouTube spécialisée en informatique) : “Python – Jeu du type Morpion avec la tortue (Part 1)”.

Dans cette vidéo, il commence par faire la grille donc nous l’avons suivi et avons récupéré le script de celle-ci après l’avoir compris :

H, L =320 , 222
def grille(nb):
      case = min(H,L) // nb
      H_m, L_m = -nb * case / 2, -nb * case /2
      for i in range(1,nb):
        trait(L_m, H_m + case * i, 0, nb * case)
        trait(L_m + case * i, H_m, 90, nb * case)
      return case, H_m, L_m
    grille(3)

La 1ère ligne permet, en fonction de la taille de l’écran de faire les différentes cases demandées par le joueur.

La seconde ligne, elle, permet de tracer les différentes cases avec le bon écart.


Ensuite, grâce à la fonction trait : la grille est tracée.

Une fois la fonction achevée, on l’appelle avec le nombre de case que l’on veut, ici, il est de 3.

Puis, il nous faut le cercle et la croix pour les placer sur la grille, on a donc fait une fonction pour chaque :

def cercle():
        pensize(2)
        setheading(0)
        pendown()
        penup()
        forward(30)
        pendown()
        left(90)
        circle(25)
        setheading(0)
        penup()
        backward(25)
        left(90)
 def croix():
        pensize(2)
        right(45)
        pendown()
        for i in range(4):
            right(90)
            forward(40)
            penup()
            backward(40)
            pendown()
        setheading(90)
        penup()

Au début, nous avons eu un problème avec le cercle car il ne se crée pas directement au centre mais sur les côtés, on a donc dû rajouter à la fonction un forward pour que le centre du cercle se place au centre de la colonne.


Pour que les joueurs puissent comprendre les règles du jeu pour ce qu’il ne connaissent pas ou ne savent pas appuyer sur quelles touches de la calculatrice pour jouer, nous avons décidé de faire deux pages d’accueil pour tout expliquer.

draw_string("Appuyez sur EXE pour continuer",20,4
0,(255,128,0))draw_string("Règles du jeu : \n\n  ·Chaque joueur possèdent un \n  symbole différent.\n  ·Le premier avec 3 symboles\n  sur une ligne gagne.",0,75,(0, 0,0))
while not (keydown(KEY_EXE)):True

Nous avons fait la première page d’accueil qui indique les règles du jeu en utilisant la fonction draw_string qui permet d’écrire du texte de la façon demandée. Ensuite avec le module Ion, il nous suffit d’appuyer sur la touche “EXE” de la calculatrice pour passer à la seconde page d’explication.


Le cœur du morpion

Le déplacement entre les cases

Cela fait, il nous fallait pouvoir déplacer naviguer entre les différentes cases.

On a donc utilisé le module Ion qui est sur la calculatrice Numworks, il permet d’utiliser les touches de la calculatrice pour y relier des actions, ici : se déplacer ou dessiner les croix et cercles.

Nous avons eu beaucoup de mal à utiliser ce module au début mais c’est en regardant un autre code de “Schraf : Maths-info” sur le jeu de la vie que nous avons compris comment il fonctionnait.

Dans un premier temps, il faut utiliser keydown puis mettre la touche que l’on veut utiliser en paramètre.

Par exemple:

if keydown(KEY_ONE):
      goto(-75,-74)
      croix()

Ici, quand la touche 1 de la calculatrice est enfoncée, la tortue se déplace aux coordonnées demandées et se met à dessiner la croix.

Dans l’ordre des choses, il suffit donc que chaque case soit assignée à une touche.

Et à partir de là, on peut dessiner toutes les croix ou des cercles à n’importe quelle case.

Cela nous a permis de voir le début d’un jeu fonctionnel et nous a largement motivés quant à la suite de ce projet !


La vérification de victoire

La vérification permet de vérifier si un des joueurs a gagné, et si oui, lequel. C’est sûrement ce qu’il nous a le plus posé de problème au cours du projet.

D’abord, nous avons dû apprendre à savoir ce qu’est une matrice (une liste de liste) : 

matrice = [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']]

On peut la percevoir comme une grille en 3×3, comme celle du morpion pour faciliter l’explication : 

matrice = [[' ', ' ', ' '],
           [' ', ' ', ' '],
           [' ', ' ', ' ']]

C’est une liste de listes où chaque liste contient 3 éléments, ici vides.

Comme dit plus haut, on doit percevoir cette matrice comme la grille du morpion, pour en quelque sorte les “relier” : 

if j == 1:
      if keydown(KEY_ONE) and matrice[0][0] == " ":
            indice = 0
            goto(-75,-74)
            croix()
            matrice[0][0] = j
            j = 2
            verification_croix()

Dans la ligne « matrice[0][0] = j », on associe le 1er emplacement de la 1ère liste de la matrice à j, donc à 1 (ce même nombre renvoie à l’utilisation de la croix).

On associe alors indirectement la case en haut à gauche à la croix, puis on lance la fonction verification_croix.

def verification_croix():
    for i in range (3):
        if matrice[i][0] == matrice[i][1] == matrice[i][2] == 1:
            victoire_croix()
    for i in range(3):
        if matrice[0][i] == matrice[1][i] == matrice[2][i] == 1:
            victoire_croix()
    if matrice[0][0] == matrice[1][1] == matrice[2][2] == 1:
        victoire_croix()
    if matrice[0][2] == matrice[1][1] == matrice[2][0] == 1:
        victoire_croix()

Dans cette fonction qui vérifie si le joueur croix a gagné, on vérifie pour les 8 combinaisons gagnantes du morpion si les emplacements de listes de la matrice correspondants (donc de la grille) sont égaux à 1 (donc à la croix).

Si c’est effectivement le cas, on lance la fonction victoire_croix qui affiche un écran de victoire bien mérité pour le joueur croix.


Difficultés rencontrées

Lors de la conception du jeu, nous sommes tombés sur plusieurs pépins.

Bien sûr, nous avons dû les surmonter, cependant, il y a eu de l’apprentissage mais également du bricolage.

On peut prendre l’exemple de la 1ère tentative de vérification qui était quelque peu fatiguée : 

def verification_cercle():
    if get_pixel(-75,-74) and get_pixel(0,-74) and get_pixel(75,-74) = (254, 254, 254):
        victoire_cercle()
    elif get_pixel(-75,-0) and get_pixel(0,0) and get_pixel(75,0) = (254, 254, 254):
        victoire_cercle()
    elif get_pixel(-75,-74) and get_pixel(0,74) and get_pixel(75,74) = (254, 254, 254):
        victoire_cercle()

On utilise la couleur du milieu de la croix et du cercle pour vérifier si la combinaison est gagnante.

La croix possède un pixel noir en son milieu et le cercle fait quelques aller-retours en son milieu en une couleur quasi-blanche (en RBG) afin de la différencier du fond blanc.

À l’aide de la méthode get_pixel(), on récupère la couleur d’un pixel à une coordonnée précise et on la compare à une valeur fixe, ici (254,254,254), du quasi-blanc. 

Si 3 pixels de la même et de cases à combinaison gagnante sont alignés, l’écran de victoire du joueur concerné s’affiche.
Cependant, rien ne se passait quand une combinaison gagnante apparaissait, on a donc décidé de changer d’approche malgré la tristesse de ne pas pouvoir exploiter cette méthode de pure ingéniosité…

Ensuite l’un des autres problèmes majeurs était de lier la matrice à la grille.


En effet, lors de la conception du jeu, nous voulions au début faire déplacement libre sur la matrice avant d’appuyer sur un 2ème bouton pour valider la case dans laquelle on veut jouer.


Nous avons donc décidé d’enlever le déplacement libre, c’est-à-dire que dès que l’on clique sur un chiffre, une croix ou un rond se met directement à l’emplacement voulu, cela nous a permis de pouvoir relier la matrice à la grille plus facilement:

if keydown(KEY_ONE) and matrice[0][0] == " ":
  goto(-75,-74)
  croix()
  matrice[0][0] = j
  j = 2
  verification_croix()
if keydown(KEY_TWO) and matrice[0][1] == " ":
  goto(0,-74)
  croix()
  matrice[0][1] = j
  j = 2
  verification_croix()

Comme on peut le voir sur le script ci-dessus, la matrice et la grille sont constamment liées.

Conclusion

Ainsi, nous avons l’immense fierté d’avoir conçu ce jeu vidéo sur la calculatrice, nous avons pu en apprendre plus sur le python et les différents modules qu’il possède qui nous étaient alors inconnus jusqu’à présent.

Au début de la conception de ce jeu vidéo, le travail nous paraissait immense et nous n’avions aucune idée d’où commencer ni de quoi faire, des problèmes ont été rencontrés mais nous avons pu trouver des solutions en codant, testant, en faisant des erreurs, nous corrigeant et en s’améliorant.


Le jeu

Avec relancement de partie (cliquer sur EXE à la fin d’une partie) mais avec un bug : lamhassni-bilal/morpion.py — Python — NumWorks

Sans relancement : corentin-katic84/morpion.py — Python — NumWorks

Sources

Chaîne YouTube de Schraf : Maths-info : https://youtube.com/@Schraf

Article Calculatrice Numworks : https://nsi.xyz/tutoriels/programmer-en-python-et-porter-son-code-sur-la-numworks/

Aide à la programmation : https://nsi.xyz/projets/un-menu-en-python-pour-les-jeux-sur-la-numworks/ ; https://www.codingame.com/playgrounds/48392etteur

Tutoriels

Comment utiliser le logiciel d’enregistrement OBS ?

  • par

Le logiciel OBS est un célèbre logiciel qui permet l’enregistrement d’un ou plusieurs écrans sur PC, nous verrons à travers cet article pourquoi et comment l’utiliser !


Pourquoi utiliser ce logiciel au lieu d’un autre ? Quels sont ses atouts ?


Tout d’abord, OBS est un logiciel d’enregistrement gratuit et open source : c’est-à-dire qu’il est possible de retrouver son code très facilement afin de le réutiliser.
On le retrouve sur la grande majorité des plateformes softwares, incluant Windows, macOS et Linux (pour les plus aventuriers).
De plus, il intègre une option de streaming en direct pour des plateformes comme Twitch,.. mais nous resterons ici sur le simple enregistrement. 🤫


Comment utiliser OBS ?

  • Installer OBS


Il est nécessaire d’installer le logiciel avant de pouvoir s’en servir tout comme il est nécessaire d’avoir de la nourriture pour manger ! 👨‍🏫
Se rendre à l’adresse suivante : Téléchargement | OBS (obsproject.com), et bien sûr choisir la plateforme adéquate.


Une fois ceci fait, il suffit simplement d’exécuter l’installateur (ce qui a été téléchargé) et procéder à l’installation du logiciel en suivant les instructions.
On se retrouve alors avec cet écran avec un fond noir.


  • Quelques préréglages nécessaires


Se rendre dans les paramètres, puis dans la section « Sortie ».
Dans la partie « Enregistrement » : modifier à sa guise le chemin d’accès s’il ne convient pas en cliquant sur l’icône « Parcourir », la vidéo sera stockée à cet emplacement ; vérifier si le format vidéo est en mp4, ce format est considéré comme universel et peut donc être utilisé partout ! 😱


Facultativement, il peut être nécessaire de modifier le débit d’images dans la section « Vidéo » à 60, ce qui enregistrera une vidéo à 60 images chaque seconde, créant alors une vidéo plus fluide (utile pour les jeux-vidéos).
Il est également recommandé d’associer des raccourcis claviers dans la section du même nom, notamment pour le démarrage de l’enregistrement, son arrêt, sa pause et sa reprise (pour les coupures).


  • Les scènes et sources


Afin d’enregistrer l’écran, on doit donner au logiciel une scène à laquelle on associe une source, celle-ci peut être une fenêtre de navigateur, de logiciel ou même l’écran entier de l’ordinateur. 😵
Ici, la scène sélectionnée est associée à une source de l’écran entier de l’ordinateur.


À noter que l’on peut créer une liste de scènes pour chaque source récurremment enregistrée, par exemple : la scène « Écran » associée à la source « Capture d’écran » ; la scène « Minecraft » associée à la fenêtre du jeu Minecraft par la source « Capture de fenêtre » ; …


Il ne reste plus qu’à lancer le logiciel, sélectionner la scène adéquate à l’usage et à user des raccourcis clavier pour maîtriser l’enregistrement dès que l’on veut enregistrer une vidéo ! 🤗

Art

Astronomie : Un semblant de liberté

« C’est dur, oui, il a tant cherché sa place dans l’univers : société, nature sauvage, vie luxueuse,… mais rien de tout ça ne lui convenait. Se tournant vers le ciel, c’était peut-être parmi les étoiles que se trouvait sa place… »


Introduction

À l’aide du module Turtle, on va pouvoir créer une image en python, animée ou non.
Aujourd’hui, ce sera alors plutôt un dessin que nous générerons par notre code, de plus, celle-ci sera différente à chaque exécution !
Nous allons alors décortiquer des parties de celui-ci afin de le comprendre, si ce n’est pas déjà le cas ! 😉


Une mise en bouche qui nous prépare

colormode(255)
color(5,9,44)
goto(-640,0)
pensize(1000)
forward(1000)

Ce bloc de code permet de préparer le dessin en y installant un fond bleu nuit rappelant l’espace.
La couleur est définie dans les 2 premières lignes, ensuite on se rend à des coordonnées hors du champ de vision puis on trace un trait très épais.


Des fonctions par-ci, des fonctions par-là

def etoile():
    pensize(2)
    couleur = randint(0,3)
    if couleur == 0:
        color(250, 137, 25)
    else:
        color(247,247,36)
    for _ in range(5):
        forward(10)
        right(144)

Le bloc de code suivant est une fonction, elle nous permet de définir une suite d’instructions qu’on peut utiliser par la suite.
Elle dessine une étoile tout en utilisant un autre module permettant d’utiliser l’aléatoire, à l’aide de celui-ci et de structure conditionnelles, on choisit aléatoirement entre 2 couleurs pour l’étoile.
Puis, on la trace à l’aide d’une boucle bornée. 😵

def position_aleatoire():
    penup()
    x = randint(-640,640)
    y = randint(-320,320)
    goto(x,y)
    pendown()

Cette seconde fonction diffère de la 1ère par son utilité-même : elle permet de choisir une position aléatoire.
La fonction génère aléatoirement des coordonnées dans un intervalle défini, ici, celle de la fenêtre puis elle s’y rend.

for _ in range(42):
    position_aleatoire()
    type_etoile = randint(0,2)
    if type_etoile == 0:
        etoile_2()
    else:
        etoile()

C’est alors que la magie entre en scène, on manipule les fonctions précédemment créées afin de produire un splendide ciel étoilé !
On se rend à un endroit aléatoire grâce à la 2ème fonction puis on dessine une étoile grâce à la 1ère fonction (et une autre produisant un autre type d’étoile), et ceci 42 fois !! 😱


Des éléments de décoration


D’autres éléments constituant l’image proviennent de fonctions, prenons ici l’exemple de la fusée :

def fusee():
    left(55)
    penup()
    goto(-100,-40)
    pendown()
    corps_fusee()
    for i in range(2):
        penup()
        goto(-125+i*275/100*25,-50-i*5/2*20)
        pendown()
        moteur()
    for i in range(2):
        penup()
        goto(-15+i*35*135/100,-65/2+i*50*135/100)
        pendown()
        hublot()
    right(30)
    penup()
    goto(15,125)
    pendown()
    toit()


On peut voir une différence notable avec les fonctions précédentes, cette fonction est elle-même constituée de fonctions : « corps_fusee » ; « moteur » ; « hublot » et « toit ».
Et comme dit plus tôt, on utilise et manipule ces fonctions, par exemple en les utilisant plusieurs fois dans une boucle, en définissant un angle au préalable,… et ça ne s’arrête pas là ! on pourrait très bien utiliser la fonction définissant la fusée afin de lui donner une autre utilité !

C’est alors en usant de fonctions, de boucles et de structures conditionnelles qu’on peut facilement produire une œuvre avec le module Turtle, mais tout cela ne peut se réaliser qu’avec de la pratique, car comme j’ai dit : « C’est en programmant que l’on devient programmeur ».

L’image finale

Télécharger le .py

script_imageTélécharger