Sécuriser votre connexion Wi-Fi est essentiel pour protéger vos données personnelles pour empêcher l’accès a des personnes tiers. Ce tutoriel vous guidera à travers les étapes essentielles pour renforcer la sécurité de votre Wi-Fi. De plus, certaines parties de ce tutoriel ne s’appliquent que pour Windows.
Première étape : Changer le mot de passe de votre routeur
Accédez à l’interface de votre routeur :
Ouvrez une fenêtre de commande en entrant « cmd » dans la boîte de dialogue.
Entrez « ipconfig » dans la fenêtre de commande.
Trouvez l’adresse IP de votre routeur, généralement sous la forme de chiffres tels que 192.168.1.1.
Dans la barre d’adresse du navigateur, entrez l’adresse IP de votre routeur pour accéder à l’interface de gestion de ce dernier. Vous devrez vous connecter en utilisant les identifiants appropriés (consultez le manuel de votre routeur pour les détails).
Dans la barre d’adresse du navigateur, entrez l’adresse IP de votre routeur pour accéder à l’interface de gestion de ce dernier. Vous devrez vous connecter en utilisant les identifiants appropriés (consultez le manuel de votre routeur pour les détails).
Changez le mot de passe :
Remplacez le mot de passe par défaut par un mot de passe robuste, mélangeant majuscules, minuscules, chiffres et caractères spéciaux, empêchant pratiquement toutes attaques.
Deuxième étape : Activer le chiffrement WPA3
Vérifiez le type de chiffrement :
Accédez aux paramètres de sécurité de votre routeur, généralement sous une section appelée « Chiffrement » ou « Sécurité sans fil ».
Assurez-vous que le chiffrement utilisé est « WPA3 » (ou alors WPA2 si WPA3 n’est pas disponible). Cela renforcera la protection de votre réseau WIFI car la version est plus récente, et donc supérieurement sécurisée que les anciennes version (type WEP) .
Troisième étape : Filtrer les adresses MAC autorisées
Collectez les adresses MAC :
Trouvez l’adresse MAC de chaque appareil que vous souhaitez autoriser à se connecter à votre Wi-Fi. Vous la trouvez généralement dans les paramètres réseau de chacun de ces derniers.
Ajoutez les adresses MAC autorisées :
Accédez aux paramètres du routeur, comme expliqué a la première étape, et cherchez un paramètre comme: « Filtrage des adresses MAC ».
Entrez les adresses MAC des appareils que vous avez collectées dans la liste autorisée de votre routeur.
Activez le filtrage des adresses MAC :
Trouvez l’option pour activer le filtrage des adresses MAC dans les paramètres du routeur.
En l’activant, seuls les appareils dont les adresses MAC sont sur votre liste pourront se connecter à votre Wi-Fi.
Conclusion
En suivant ces étapes, vous renforcez significativement la sécurité de votre connexion Wi-Fi à la maison. N’oubliez pas de mettre à jour régulièrement votre mot de passe et de surveiller les appareils connectés pour maintenir un niveau de sécurité optimal.
Étudiant en spécialité NSI en classe de 1ère, promotion 2021 – 2024 « Brèche, Brèche, j’ai pris un servo de tes bras pour mon tripwire. Ne sois pas en colère. Brèche … »
Qui n’a jamais rêvé d’avoir un robot en LEGO qui lui annonce la météo ? Et bien même si ce n’est pas le cas, nous l’avons fait pour vous ! Venez découvrir un robot capable de comprendre son environnement pour vous donner la météo.
Fonctionnalités du robot
Notre robot au doux nom de ROBKEY est capable de :
déplacer ses bras et son bassin ;
reconnaitre l’endroit où il se trouve pour donner précisément la météo ;
afficher l’heure, la météo et la température ambiante ;
d’avoir quelques réactions faciales ;
et bien plus.
La conception du robot
Pour concevoir notre robot, nous avons dû prendre en compte plusieurs choses. Tout d’abord, les moteurs n’ont pas été particulièrement dur à installer car il ne font que la moitié de la taille de l’esp 32. Il nous a donc paru évident de mettre les moteurs des bras dans le torse du robot et le moteur du bassin dans le châssis de ses chenilles.
Ensuite il a fallu installer planche de test qui a eu plusieurs positions possibles. Premièrement dans son dos car cela aurait permis de pouvoir faire tourner le bassin du robot à 360°, mais les câbles auraient difficilement bien tenu à l’esp 32 et au robot lui-même. Nous nous sommes finalement entendu à l’idée de mettre la planche sur la batterie des chenilles bien que cela empêche le robot de faire des tours sur lui même.
Maintenant, le plus important : le placement de l’ESP32. Nous avions deux idées, l’une le plaçait dans le torse du robot, l’autre faisait en sorte qu’il soit la tête légèrement rentrée dans les épaules. Nous avons opté pour la seconde option car celle-ci nous permet d’afficher un petit visage sur l’écran du microcontrôleur.
Pour conceptualiser l’apparence de notre robot, nous avons donc réalisé un schéma en 3D très simple sur Paint 3D en regroupant nos idées pour imaginer ce à quoi il ressemblera.
Construction de la structure du robot
Pour construire le robot, j’ai (Sylvain) commencé par regarder les constructions Lego que j’avais précédemment réalisées et qui pouvaient être détruite pour commencer à récupérer leurs pièces. Avec toutes ses matières premières je me suis laissé porter par mon imagination pour construire le LEGO le plus ressemblant à un robot en essayant de faire en sorte qu’il soit plutôt résistant (bon d’accord j’ai peut-être failli à cette tâche).
C’est grâce aux joies de la maladie que j’ai pu entamer la construction. Pour commencer, j’ai récupéré le châssis d’une autochenille radiocommandée en la modifiant pour la rendre plus compacte et en laissant un espace pour le moteur du bassin.
Entouré en blanc : Le moteur du bassin
Ensuite j’ai commencé à faire ledit bassin, que j’élargis à la fin de la construction car je l’avais fait trop fin. Suivi du torse, le plus simple car il devait être creux pour laisser la places aux câbles et aux moteurs. Il fallait aussi préparer les trous pour les axes des bras.
Après j’ai fait les bras qui sont vraiment très simplistes mais à ce moment je commençais sérieusement à manquer de pièces plus techniques et même des plus simples pour faire quelque chose de plus sympathique. Mais quoi qu’il en est l’un des deux bras représente un soleil pour quand il fait beau, tandis que l’autre représente un ciel nuageux.
Pour finir j’ai réalisé la cage de la planche de test et solidifié les éléments les moins solides et résolu les quelques problèmes mécaniques rencontrés lors des premiers tests des moteurs.
L’électronique du robot
En parallèle de la construction du LEGO, je (Thomas) me suis lancé dans la conception électronique de celui-ci.
Pour cela, j’ai d’abord listé tout ce que je voulais intégrer à l’électronique :
2 boutons,
1 capteur de température,
3 moteurs.
Pour m’aider dans la réalisation électronique, je me suis aidé de tous ces sites :
Les câbles blancs (entourés en rouge) récupèrent l’information de la pression du bouton et les câbles noirs (entourés en vert) s’occupe de fermer le circuit (de l’électricité passent dans le bouton, et il faut que l’électricité puisse faire une boucle). Si vous voulez, les boutons reçoivent de l’énergie par les câbles blancs et l’expulsent par les câbles noirs.
Concernant le branchement du capteur :
A droite à quoi ressemble le capteur de température de face et à gauche son branchement. La câble de gauche, en blanc récupère les mesures du capteur, celui du milieu en marron, alimente positivement le capteur (le capteur reçoit de l’énergie par ce câble) et le câble noir à droite du câble marron lui ferme la boucle (le capteur expulse l’énergie par ce câble.)
Et pour finir, les moteurs ont 3 câbles :
Le câble orange sert à contrôler le moteur, le rouge à l’alimenter et le marron à fermer la boucle. On refait ça 3 fois puisqu’on a 3 moteurs.
On branche tout ceci à la planche de test puis à l’ESP32, et voilà montage terminé :
Programmation du robot
Maintenant que le robot est construit et le montage électronique assemblé, il faut passer à la programmation de l’ESP32. Veuillez noter que depuis l’écriture de ce qui suit, le code a bénéficié de quelques mises à jours. Vous retrouverez l’archive en fin d’article avec les fichiers à jours.
Tout d’abord, il faut coder les briques de bases, qui vont nous permettre de manipuler différents outils, capteurs, actionneurs, api, etc.
C’est pour cela que nous créons un fichier buttons.py qui contient une classe Button dans laquelle nous initialisons 4 boutons : les 2 du microcontrôleur et les deux boutons ajoutés. Dans cette classe, vous verrez que chaque boutons a des caractéristiques supplémentaires. En effet il est possible de rendre un bouton poussoir équivalent à un levier. Nous créons différentes fonctions pour récupérer ou modifier des informations en rapport avec les boutons.
from machine import Pin
from time import sleep
# Importer les modules est inutile car ils sont déjà importés dans boot.py
class Buttons():
def __init__(self):
#self.name = "t-display-s3"
# NomDuBouton : [ PinUtilisé , mode , value ]
# 1 : [ Pin 3 en mode INPUT avec une résistance Pull-Down , levier , 0 ]
# 1 : [ Pin(3, mode=Pin.IN, pull=Pin.PULL_DOWN), 1, 0 ]
# Note : le chiffre de value dans la liste n'est pas pris en compte si le bouton est en mode "poussoir" -> On ne peut pas mettre None car si on décide de changer le mode du bouton, la valeur devient importante.
# Pour une raison inconnue, "left" et "right" ne fonctionne plus.
self.list_button = {"left" : [Pin(0, Pin.IN, Pin.PULL_UP),0,1],
"right" : [Pin(14, Pin.IN, Pin.PULL_UP),0,1],
1 : [Pin(2, mode=Pin.IN, pull=Pin.PULL_UP),0,1],
2 : [Pin(3, Pin.IN, Pin.PULL_UP),0,1]
}
def getButton(self, button):
return self.list_button[button]
def setButton(self, button, pin, mode, value=None): # Le set fait également add.
self.list_button[button] = [pin,mode,value]
def setMode(self, button, val:bool): # Ce mode change le mode du bouton -> soit "levier" soit "poussoir"
if isinstance(val, bool) or val in (0,1):
self.list_button[button][1] = val
if not(val):
self.list_button[button][2] = 1
return print("Mode définie sur : " + str(self.list_button[button][1]))
else:
raise ValueError("val must be a boolean or a integer included between 0 and 1.")
def setValue(self, button, value):
if self.list_button[button][1]:
self.list_button[button][2] = value
return print("Valeur définie sur : " + str(self.list_button[button][2]))
else:
print("Button must be a toogle button, not a push button.")
return False
def getValue(self, button): # Renvoie la valeur du bouton
if not(self.list_button[button][1]): # Si le statut de mode_toogle est égal à 0 <=> Si le bouton est en mode "poussoir" et non "levier"
return self.list_button[button][0].value()
else:
if not(self.list_button[button][0].value()):
self.list_button[button][2] = 0 if self.list_button[button][2] else 1
sleep(0.25)
return self.list_button[button][2]
def isButtonPressed(self,button): # Renvoie True si le bouton est pressé (donc si value = 0) et False sinon
return not(self.getValue(button))
Continuons avec le fichier temperature.py dans lequel nous avons une simple fonction qui nous renvoie les données récupérées par le capteur de température et d’humidité.
from time import sleep #Inutile car importé dans boot.py
def getTemperatureAndHumidity(capteur): # Capteur doit etre sous cette forme : capteur = dht.DHT11(Pin(17)) -> Ne pas oublier d'importer le module dht
try:
capteur.measure() # Met à jour les données de températures et d'humidités
sleep(1)
return (capteur.temperature(),capteur.humidity())
except:
print("Valeurs non récupérées")
return False
Egalement, à l’aide des fichiers motor.py et servo.py (trouvé sur internet), nous créons des fonctions qui réaliseront des déplacements particuliers :
from servo import Servo
import time
motor=Servo(pin=12) # A changer selon la broche utilisée
motorbd=Servo(pin=10)
motorbg=Servo(pin=11)
def droit(t=1):
motor.move(285)
time.sleep(t)
def bassin(t=2):
motor.move(265)
time.sleep(t)
motor.move(305)
time.sleep(t)
def baissebg(t=0.5):
motorbg.move(335)
time.sleep(t)
def levebg(t=0.5):
motorbg.move(270)
time.sleep(t)
def baissebd(t=0.5):
motorbd.move(335)
time.sleep(t)
def levebd(t=0.5):
motorbd.move(270)
time.sleep(t)
droit()
Pour finir, à l’aide du fichier connection.py, nous créons plusieurs fonctions en rapport avec la partie sans-fil de l’ESP32.
import network
import st7789 #En théorie inutile car déjà importé dans boot.py
from time import sleep
def connect_to_wifi(display, font, ssid, mdp):
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
if not wlan.isconnected():
display.init()
display.draw(font,"Connexion a un point",0,111)
display.draw(font,"d'acces en cours",15,126)
wlan.connect(ssid,mdp)
while not wlan.isconnected():
pass
display.fill_rect(0,107,170,25,st7789.BLACK)
display.draw(font,'Connecte !',40,111)
sleep(0.8)
display.fill_rect(0,107,170,10,st7789.BLACK)
display.deinit()
def search_wlan():
station = network.WLAN(network.STA_IF)
station.active(True)
return station.scan()
Passons aux modules qui vont utiliser des apis :
En premier lieu, nous avons le fichier geoloc.py dans lequel nous utilisons l’api de google qui à l’aide des réseaux wifi aux alentours est capable de situer l’ESP32. Dans ce fichier est présent une fonction qui récupère les coordonnées géographiques de l’ESP32.
from modules.connection import search_wlan
import ustruct as struct
import urequests as requests
import ujson as json
import modules.api_txt as api_txt
def getLocation(api_key): # Avec Google maps API + sécurité sur le nombre de requête.
if int(api_txt.get_api_counter()[0]) > 24000:
print("Quota de demande dépassé !!! Vous ne pouvez pas faire de requête...")
return False
list_wlan = search_wlan()
data = {
"considerIp": False,
"wifiAccessPoints": []
}
for wifi in list_wlan:
entry = {
"macAddress": "%02x:%02x:%02x:%02x:%02x:%02x" % struct.unpack("BBBBBB", wifi[1]),
"signalStrength": wifi[3],
"channel": wifi[2]
}
data["wifiAccessPoints"].append(entry)
headers = {"Content-Type": "application/json"}
url = "https://www.googleapis.com/geolocation/v1/geolocate?key=" + api_key
response = requests.post(url, headers=headers, data=json.dumps(data))
api_txt.add_api_counter(0)
return json.loads(response.content)["location"]
En second et dernier lieu, il reste le fichier meteo.py qui va être capable d’utiliser une api de météorologie pour récupérer, analyser et mettre en forme des données en rapport avec la météo.
import urequests
import modules.api_txt as api_txt
def get_meteo(latitude, longitude): # Sur la prochaine heure
if int(api_txt.get_api_counter()[1]) > 10000:
print("Quota de demande dépassé !!! Vous ne pouvez pas faire de requête...")
return False
url = "https://api.open-meteo.com/v1/forecast?latitude={0}&longitude={1}¤t=temperature_2m,precipitation&daily=temperature_2m_max,temperature_2m_min,precipitation_sum&timezone=auto&forecast_days=3".format(latitude,longitude)
json_meteo = urequests.get(url).json()
api_txt.add_api_counter(1)
return {"current":
{"temperature":
[
json_meteo["current"]["temperature_2m"],
json_meteo["current_units"]["temperature_2m"]
],
"precipitation":
[
json_meteo["current"]["precipitation"],
json_meteo["current_units"]["precipitation"]
]
},
"demain":
{"temperature": [round((json_meteo["daily"]["temperature_2m_min"][1] + json_meteo["daily"]["temperature_2m_max"][1]) / 2, 1), json_meteo["daily_units"]["temperature_2m_min"]],
"precipitation":
[
json_meteo["daily"]["precipitation_sum"][1],
json_meteo["daily_units"]["precipitation_sum"]
]
},
"apres-demain":
{"temperature": [round((json_meteo["daily"]["temperature_2m_min"][2] + json_meteo["daily"]["temperature_2m_max"][2]) / 2, 1), json_meteo["daily_units"]["temperature_2m_min"]],
"precipitation":[
json_meteo["daily"]["precipitation_sum"][2],
json_meteo["daily_units"]["precipitation_sum"]
]
}
}
Passons à la gestion graphique, nous avons récupérer le module tft_config.py fournit par les développeurs du pilotes graphiques pour l’esp32. Celui-ci permet de créer facilement une gestion de l’écran avec les bonnes caractéristiques. Nous n’afficherons pas le code ici, car ce n’est pas nous qui l’avons codé. Vous pouvez le retrouver dans l’archive à la fin de cet article ou ici.
Nous avons créé le fichier affichage.py qui contient un certain nombre de fonctions pour réaliser le rendu graphique pour l’ESP32. Il contient également le code qui récupère des images pour les animations du visage et des icones. Ces dessins et animations ont été réalisé par Ilana, ancienne première NSI.
import st7789
from time import sleep, localtime
import modules.motor as motor
last_temps = -1
def display_time(display,font,x,y):
global last_temps
temps = localtime()
if last_temps < temps[5]:
display.png("/images/icones/horloge.png",x,y,True)
display.fill_rect(x+30,y+5,60+6,10,st7789.BLACK)
display.draw(font, str(temps[3]) + ":" + str(temps[4]) + ":" + str(temps[5]),x+30,y+10)
last_temps = temps[5]
def display_meteo(display,font,infos_meteo, x, y):
display.draw(font,str(infos_meteo["temperature"][0]),x,y)
display.draw(font, font.LAST,x + display.draw_len(font,str(infos_meteo["temperature"][0])), y)
display.draw(font, " C",x + display.draw_len(font,str(infos_meteo["temperature"][0])), y)
display.draw(font,str(infos_meteo["precipitation"][0]),x+80,y)
display.draw(font,str(infos_meteo["precipitation"][1]),x + 80 + display.draw_len(font,str(infos_meteo["precipitation"][0])),y)
def display_temperature(display,font,infos_temperature,x,y):
display.fill_rect(x,y,70,20,st7789.BLACK)
display.png("/images/icones/temperature.png",x,y,True)
display.draw(font,str(infos_temperature) + " C",x+30,y+9)
display.draw(font,font.LAST,x+30+display.draw_len(font,str(infos_temperature)), + y+9)
def meteo_icon(display,icone,x,y):
display.fill_rect(x,y,50,50,st7789.BLACK)
if icone == "pluie":
display.png("/images/icones/mauvais_temps.png",x,y,True) #Nuage pluie gris pas content
else:
display.png("/images/icones/beau_temps.png",x,y,True) # Soleil content
def meteo_widget(display,font,infos_meteo,x,y):
display.fill_rect(x,y,170,200,st7789.BLACK)
display.draw(font, "Auj.",x,y)
display_meteo(display,font,infos_meteo["current"],x, y+20) #x,y+20)
display.draw(font, "Dem.", x, y+40) #x+50, y)
display_meteo(display,font,infos_meteo["demain"], x, y+60) #x+50,y+20)
display.draw(font, "Apr-Dem.", x, y+80) #x+90, y)
display_meteo(display,font,infos_meteo["apres-demain"], x, y+100) #x+90,y+20)
def main_menu(display,font,infos_temp,infos_meteo):
display_time(display,font, 10, 111) # x = 52 pour un semblant de centrage
display_temperature(display,font,infos_temp,10,151)
if infos_meteo["current"]["precipitation"][0] > 0:
icone = "pluie"
motor.baissebg()
motor.levebd()
else:
icone = "soleil"
motor.baissebd()
motor.levebg()
meteo_widget(display,font,infos_meteo,10,191)
meteo_icon(display,icone,110,111)
def animation(display,name:str,iteration:int,i_fixe:int): # list_anim : {"content":(2,1),"endormi":(4,1),"somnole":(3,1),"observe":(0,0),"monocle":(2,1)}
display.fill_rect(0,0,170,105,st7789.BLACK)
for i in range(2,iteration+1):
display.png("/images/" + name + "/" + name + str(i) + ".png",0,0)
if name == "endormi":
sleep(0.3)
for i in range(iteration,0,-1):
display.png("/images/" + name + "/" + name + str(i) + ".png",0,0)
if name == "endormi":
sleep(0.3)
display.png("/images/" + name + "/" + name + str(i_fixe) + ".png",0,0)
Pour finir nous avons le fichier api_txt.py qui s’occupe de gérer des fichiers de textes importants pour le fonctionnement du programme, présents dans le dossier data.
"""
api[0] => Google Maps API
api[1] => Météo API
"""
def get_api_counter():
fichier_r = open("data/counter-api.txt",'r')
liste = fichier_r.read().split(",")
fichier_r.close()
return liste
def add_api_counter(indice_api): # ne fonctionne qu'avec deux apis
fichier_w = open("data/counter-api.txt",'w')
val = get_api_counter()
val[indice_api] = int(val[indice_api]) + 1
fichier_w.write(str(val[0]) + "," + str(val[1]))
fichier_w.close()
def set_api_counter(indice_api,value): # ne fonctionne qu'avec deux apis
fichier_w = open("data/counter-api.txt",'w')
api_value = get_api_counter()
api_value[indice_api] = str(value)
fichier_w.write(api_value[0] + "," + api_value[1])
fichier_w.close()
Maintenant que toutes nos briques sont construites, il ne reste qu’à écrire le fichier python principal qui va organiser tout le programme tel un chef d’orchestre.
Assemblage final
Maintenant, il faut simplement assembler notre montage électronique à notre construction LEGO. Puis à brancher notre ESP32 à un câble, lui injecter le code, et tout en le gardant brancher, le lancer, et la magie opère !
ROBKEY est assemblé !ROBKEY est vivant !
Fichiers
Veuillez noter que vous devrez ajouter votre propre clé api Google Maps API pour que la position soit mise à jour (dans boot.py à la ligne 21). Sinon vous pouvez changer manuellement la position dans le fichier old-location.txt se trouvant dans le dossier data. Veuillez respecter l’ordre suivant et ne surtout rien ajouter d’autre dans le fichier, pas même un espace :
latitude,longitude
Vous devrez également ajouter vos propres informations pour un point d’accès dans le fichier boot.py au niveau de la ligne 19 : wlan_info = ("SSID","MDP") Le projet ne fonctionne pas sans une connexion à internet !!
L’astronomie fait partie intégrante de notre histoire en tant qu’être humain. On peut la percevoir comme une fenêtre ouverte sur l’immensité du cosmos. Chaque découverte, chaque image semble être ajoutée au puzzle infiniment grand et complexe qu’est l’univers.
Mise en avant de notre idée de projet
Tout d’abord, nous avons beaucoup réfléchi à la base de notre projet. Nous avons décidé de choisir l’astronomie, un domaine vaste et varié qui offre de nombreuses options. Nous avons opté pour une perspective de l’espace, imaginant une planète face au soleil avec sa « lune ». Notre inspiration est donc venue de la Terre.
Le fond
Dans un premier temps, concernant le fond, nous avons dû commencer obligatoirement par nous plonger dans l’ambiance de l’espace. Ainsi, nous avons choisi un fond noir. Pour parvenir à cela, nous nous sommes inspirés d’autres codes de création et en avons tiré ceci :
pensize(10000)
goto(100,1)
pensize(1)
Les étoiles
Après avoir ajouté le fond, il fallut combler ce vide. Quoi de mieux que des centaines d’étoiles ? Nous avons utilisé un script permettant de placer aléatoirement 400 étoiles de couleur blanche, de taille plutôt petite et identiques les unes aux autres, sur l’image avec ce script :
def etoile(longueur, x, y, couleur=(1, 1, 1)):
penup()
goto(x, y)
pendown()
pencolor("white")
fillcolor("white")
for i in range(5):
forward(longueur)
right(144)
forward(longueur)
left(72)
for y in range(400):
x, y = randint(-800, 800), randint(-400, 400)
longueur = 2
couleur = (randint(247, 255), randint(127, 255), randint(0, 12))
etoile(longueur, x, y, couleur)
Et voici le résultat des étoiles sur le fond noir :
Le soleil
Après avoir ajouté les étoiles, nous souhaitions inclure un élément principal à l’image : le soleil, élément majeur de notre existence et de celle de notre planète. Nous l’avons positionné en haut à gauche de l’image pour montrer son importance cruciale. Pour ce faire, nous avons ajouté un cercle à l’aide d’une fonction que nous avons nommée « planete », puis nous lui avons attribué des coordonnées, une couleur et une taille.
# Fonction de cercle
def planete(rayon, x, y, couleur):
penup()
goto(x, y)
pendown()
pencolor(couleur)
fillcolor(couleur)
begin_fill()
circle(rayon)
end_fill()
# Dessiner le soleil
rayon_planete = 300
x_planete, y_planete = -450, 30
couleur_planete = "#FFC300"
planete(rayon_planete, x_planete, y_planete, couleur_planete)
Puis, nous avons souhaité intégrer une sorte de dégradé de couleur pour apporter réalisme et nuance. Après des recherches, nous avons finalement ajouté un cercle de couleur différente, de taille plus petite, au même emplacement que le soleil avec ce code :
Après tout cela, l’image restait incomplète et semblait toujours trop vide. Nous avons donc ajouté une planète que nous avons placée à l’opposé du soleil pour donner l’impression qu’elle est en face de celui-ci. Nous avons décidé de représenter une planète bleue en référence à la Terre en utilisant la même fonction à celle utilisée précédemment pour dessiner un cercle. Voici le code utilisé :
Pour finaliser notre image, nous avons pensé qu’il manquait quelques détails à ajouter. Quoi de mieux que d’inclure une lune, que nous avons positionnée près de la planète bleue, pour accroître le réalisme. Pour créer cette lune, nous avons réutilisé la fonction des cercles. Nous avons défini sa couleur en gris et l’avons rendue plus petite, car elle est moins importante que le soleil et la planète. Ensuite, à l’intérieur de cette lune, nous avons ajouté deux cercles encore plus petits pour représenter des cratères, de couleur plus foncée pour les faire ressortir. Voici le code utilisé :
« Are you telling me I can dodge bullets ? » Neo, The matrix. Cette citation représente la base de notre projet dans lequel est présenté le personnage Neo au visage hélicoïdal stoppant les balles sur un fond de chiffres binaires aléatoirement positionnés.
I – Le fond
Premièrement, le fond nous semblait être la partie la plus importante du projet. Nous avons donc commencé par poser un fond noir avec les lignes de code suivantes
Nous avons ensuite créé une suite de boucle pour placer aléatoirement des 1 et des 0 en colonnes. Pour cela, nous avons utilisé le module « random » avec la fonction « random.choice » pour sélectionner aléatoirement un nombre dans une liste prédéfinie, ensuite, une condition nous a permis de placer les chiffres. Pour ordonner ces derniers, une incrémentation aux coordonnées déjà inscrites (définissant la position du premier caractère posé) à la fin de chaque boucle a été nécessaire. Voici le code
y = 330
x = -620
for i in range(50):
penup()
goto(x, y)
pendown()
for i in range(20):
list1 = [1,2]
if random.choice(list1) == 1:
un()
else:
zero()
penup()
goto(x, y - 40 * (i + 1))
pendown()
x += 25 #incrémentation de la distance entre chaque colonnes (horizontalement)
Voici le résultat du fond finalisé :
II – Le personnage, Neo
1 – La main
La main était aussi une partie importante de l’image : elle constitue le point de fuite centrale de l’image, où se dirige toutes les balles. Voici la main, constituée de lignes plus ou moins courtes (doigts) et d’un cercle (paume).
2 – Le corps
Nous avons donc créé le corps d’un homme bâton, avec de simples lignes et un cercle pour la tête. Voici le code :
Pour créer cette spirale, il n’a suffit que de 2 lignes, avec une boucle for :
for i in range(48):
circle(i,20) # i est donc augmenté a chaque répétition
Le rendu fut le suivant :
III – Les balles
Pour créer les balles, nous avons créé une fonction, en utilisant les méthodes « begin_fill » et « end_fill » permettant de remplir tout ce que l’on dessine en trait. Voici le code :
Pour créer plus de dynamisme, nous avons opté pour des tirets, encore avec une fonction, appelées (comme les balles) plusieurs fois. Nous avons donc créé une boucle for, se répétant 18 fois :
def tiret():
for i in range(18):
pensize(7)
color("white")
forward(5)
penup()
forward(15)
pendown()
Pour une balle, nous avons combiné les deux fonctions en les appelant de la sorte :
Nous avons répété ce pattern sept fois, en changeant leurs positions (goto).
IV – L’image finale
V – Les problèmes rencontrés
Le seul ‘problème’ qu’on a rencontré fut pour le fond, pour utiliser le module random dans une liste, mais nous avons relu nos exercices sur ce thème et avons facilement trouvé la solution.
VII – Télécharger le .py
Nous vous mettons au défi d’optimiser ce code au maximum, sans changer le rendu.
La musique occupe une place centrale dans la vie contemporaine, transcendant les frontières culturelles et générant des émotions universelles. De nos jours, elle est omniprésente, accompagnant nos moments forts et ponctuant notre quotidien grâce à la facilité d’accès aux plateformes numériques. Au-delà d’un simple divertissement, la musique forge des identités, crée des communautés et offre un refuge émotionnel, devenant ainsi une véritable toile sonore de nos vies modernes.
Pourquoi cet accord ?
Il s’agit d’un do majeur 7 add 11 (Cmaj7add11). C’est un accord rarement utilisé en musique, il est le plus souvent utilisé dans le Jazz. Cet accord est beau à entendre car il est très coloré. Il s’agit d’un accord à 5 notes./
Pourquoi un accord ?
Nous avons choisi de représenter un accord sur une portée car nous sommes tous les trois reliés par la musique. Lowan et Loris faisant principalement du piano et Maceo de la guitare. Nous faisons tous les trois partie de l’option musique qui est l’option la plus intéressante du lycée proposée par l’un des meilleurs professeurs Monsieur CLÉMENTE. Pour cela Nous avons d’abord dessiné La portée à l’aide de ce code ci :
def draw_staff():
for i in range(5):
penup()
goto(-200, 50 - i * 20)
pendown()
forward(400)
def draw_note(x, y):
penup()
goto(x, y)
pendown()
circle(10)
draw_staff()
On a défini une fonction draw_staff où l’on a intégré une boucle de sorte à ce que la tortue fasse la première ligne, puis reviennent au point de départ pour ensuite descendre et répéter cette opération se répétera 4 autres fois car sur une portée il y a 5 lignes.
ensuite nous avons dessiné la clef de sol à l’aide de ce code ci-dessus. On a d’abord commencé par définir la taille de la clef et mis les valeurs correspondantes pour faire les bonnes boucles.
Pourquoi ce fond ?
Pour le fond nous avons représenté des étoiles aléatoirement disposées sur un fond dégradé bleu et noir qui représente le ciel. Nous nous sommes inspirés de l’album Geography de Tom Misch puis nous avons changé les couleurs pour arriver à un dégradé de couleur bleu. Nous nous sommes inspirés du travail d’un première de la spécialité NSI.
goto(-400, -300)
pendown()
for i in range(600):
pencolor(0,0, 255-round((i/(600/255))))
forward(800)
goto(-400,-300+i)
Analyse du script :
Le script se divise en 3 parties : Il y a la première partie, les étoiles sur le fond dégradé, ensuite par dessus nous avons rajouté la portée blanche avec les notes et pour terminer une clef de sol.
Le rendu final du script :
voici l’entièreté de notre script python qui va générer notre image ; « l’accord céleste »
from turtle import *
from random import *
Screen()
setup(800, 600)
penup()
colormode(255)
speed(0)
goto(-400, -300)
pendown()
for i in range(600):
pencolor(0,0, 255-round((i/(600/255))))
forward(800)
goto(-400,-300+i)
color("white")
def etoile(taille):
for i in range(5):
pensize(uniform(0.1, 2.5))
forward(taille)
right(144)
for i in range(200):
x = randint(-400, 400)
y = randint(-250, 250)
couleur = randint(0, 2)
if couleur == 0:
color("#D68B0F")
elif couleur == 1:
color("#EBEBAB")
else :
color("#A7C706")
penup()
goto(x, y)
pendown()
taille = uniform(0.1, 2)
etoile(taille)
shape("arrow")
color("white")
speed(0)
def draw_staff():
for i in range(5):
penup()
goto(-200, 50 - i * 20)
pendown()
forward(400)
def draw_note(x, y):
penup()
goto(x, y)
pendown()
circle(10)
draw_staff()
draw_note(-150, -30)
penup()
goto(-159, -30)
pendown()
setheading(270)
backward(100)
draw_note(-100, 10)
penup()
goto(-100, 10)
pendown()
setheading(270)
backward(100)
draw_note(-50, -10)
penup()
goto(-50, -10)
pendown()
setheading(270)
backward(100)
draw_note(0, -30)
penup()
goto(0, -30)
pendown()
setheading(270)
backward(100)
draw_note(50, -50)
penup()
goto(50, -50)
pendown()
setheading(270)
backward(100)
penup()
goto(-159, 70)
pendown()
left(124)
forward(71)
penup()
goto(-300, 0)
pendown()
pensize(5)
seth(115)
circle(-30, 220)
circle(-50, 220)
forward(70)
circle(50,100)
seth(-145)
circle(50, 58)
forward(200)
circle(-30, 180)
begin_fill()
circle(-10)
end_fill()
hideturtle()
Cette année nous avons eu la possibilité de réaliser un projet sur esp32 (microcontrôleurs), j’ai donc réalisé une mini station météo sans aucun capteur qui utilise internet pour récupérer la météo d’Avignon et l’afficher.
L’idée
Trouver quoi faire sur un esp32 n’a pas été tâche facile, en effet l’objectif final était d’utiliser au moins une API afin d’obtenir des données et par la suite de les traiter. J’ai donc fait en premier lieu des recherches afin de trouver des API utilisables en python et surtout gratuites. J’ai donc au final utilisé l’API du site openweather qui permet de recueillir la météo aux coordonnées renseignées et j’ai également utilisé un protocole permettant d’avoir l’heure.
Préparation de l’esp32
Pour pouvoir faire du Python sur mon eps32 j’ai dû le préparer, puisque à la base, l’esp32 se code avec du C j’ai donc installé MicroPython sur la carte, MicroPython est une version de Python qui est adapté aux microcontrôleurs et qui permet de passer du C au Python. Vous retrouverez probablement dans un tutoriel arrivant pendant les vacances de Noël comment faire.
Le script
Avant de présenter le script il faut savoir qu’un esp32 lorsqu’il est alimenté exécute automatiquement deux fichiers : le boot.py et le main.py. J’ai donc réalisé mon script dans le main.py et j’ai laissé le boot.py vierge.
########## IMPORTATIONS ##########
import tft_config #Module natif qui prend en charge la configuration de l'écran
import tft_buttons #Module natif qui prend en charge l'utilisation des boutons
import st7789 #Module natif qui prend en charge une partie de l'affichage sur l'écran
import vga2_8x16 #Police d'écriture native
import vga2_8x8 #Police d'écriture native
import vga2_bold_16x32 #Police d'écriture native
import network #Module natif qui prend en charge la connexion à un point d'accès wifi
from time import sleep #Le module time
import ntptime #Module natif qui permet d'utiliser le protocole ntp (Network Time Protocol)
from machine import RTC #Module natif qui permet de faire énormément de choses mais qui dans ce cas va régler l'horloge interne
import json #Module natif qui permet de convertir le résultat des requêtes en un format utilisable en python
import urequests #Module natif qui permet de faire des requêtes sur internet
from login_wifi import SSID, PASSWORD #Fichier login_wifi.py qui permet de modifier les logins wifi de l'esp32
#(fait dans un autre fichiers pour réduire les risques d'erreurs)
On a au début du fichier les importations des modules et du fichier login_wifi.py.
########## ECRAN ##########
ecran_initialise = False #Variable global pour savoir si l'écran est initialisé ou pas
tft = tft_config.config(1) #Variable globale qui représente l'écran et qui en utilisant des méthodes permet de faire des choses avec
def afficher_texte(txt, x=0, y=0, alaligne=False, police=vga2_8x16): #Fonction qui permet d'afficher du texte à l'écran
global ecran_initialise
if not ecran_initialise:
initialisation()
if not alaligne:
tft.fill(st7789.BLACK)
tft.text(police, txt, x, y, st7789.WHITE, st7789.BLACK)
def deinit(): #Fonction qui déinitialise l'écran
global ecran_initialise
if ecran_initialise:
tft.deinit()
ecran_initialise = False
def initialisation(): #Fonction qui initialise l'écran
global ecran_initialise
tft.init()
ecran_initialise = True
On a ici les 3 fonctions qui s’occupent de l’écran : l’affichage du texte avec comme paramètres le texte à écrire, les coordonnées qui si elles ne sont pas fournies seront en 0, 0, si le texte est à la ligne et la police d’écriture. Sachant que le alaligne définit si lorsque le texte s’affiche l’écran sera remplit en noir avant l’affichage du texte. Il y a également les fonctions initialisation() et deinit() qui initialise et déinitialise l’écran.
########## INTERNET ##########
wlan = network.WLAN(network.STA_IF) #Variable global qui permet de s'occuper d'accéder à internet
wlan.active(True) #Activation du point d'accès
def do_connect(ssid=SSID, password=PASSWORD): #Fonction qui permet de se connecter à un accès internet
wlan.connect(ssid, password) #Lancement en arrière plan de la connexion
essai = 0
while wlan.isconnected() == False: #Tant que la connexion n'est pas faite...
essai += 1
afficher_texte('Connecting. ', 0, 0, True) #Affichage de message
sleep(0.5)
afficher_texte('Connecting.. ', 0, 0, True)
sleep(0.5)
afficher_texte('Connecting...', 0, 0, True)
sleep(0.5)
if essai == 10: #Si il y a 10 essais de connexions qui n'aboutissent pas...
break #Sortie de la boucle while
if essai == 10: #Si il y a 10 essais de connexions qui n'aboutissent pas...
afficher_texte('Connexion impossible...', 0, 0)
afficher_texte('Tentez de modifier login_wifi.py', 0, 20, True) #Affichage du message d'erreur...
while True: #Puis une boucle infini pour ne pas exécuter le reste du code qui ne fonctionnera pas
pass
afficher_texte('Connected to :', 0, 0) #Sinon message qui indique que l'esp32 est connecté
afficher_texte(ssid, 0, 20, True)
sleep(1)
tft.fill(st7789.BLACK) #Remplit l'écran en noir
def disconnect(): #Fonction qui permet de se déconnecter d'un réseau
wlan.disconnect()
##### Script du login_wifi.py #####
SSID='Le ssid de votre réseau (son nom)'
PASSWORD='Et son mot de passe'
Ici ce sont les fonctions qui s’occupent du réseau de l’esp32 en se connectant au réseau définit dans le fichier login_wifi.py et qui tant que le réseau n’est pas connecté va afficher le texte ‘Connecting…’ et après 10 essais un message d’erreur s’affiche en expliquant comment changer les logins du réseau, sinon on affiche que la connexion s’est faite. Il y a aussi la fonction disconnect qui permet de se déconnecter du réseau.
########## HEURE ##########
ntptime.host = 'ntp.unice.fr' #Définition du site où la demande de l'heure est faite
def set_heure(): #Fonction qui règle l'heure de l'horloge interne en demandant au serveur
if not wlan.isconnected(): #Si pas connecté, se connecte au réseau
do_connect()
ntptime.settime() #Règle l'horloge interne de l'esp32 selon l'heure donnée par le serveur
def get_heure(): #Fonction qui renvoie une liste du format :
#[année, mois, jour, jour de la semaine, heure, minute, seconde, milliseconde]
heure = list(RTC().datetime()) #Récupération de l'heure interne
heure[4] += 1 #Décalage horaire
if heure[4] == 24:
heure[4] = 0
if len(str(heure[6]))==1: #Ajout d'un 0 si l'heure, la minute ou la seconde ne comporte qu'un chiffre
heure[6] = '0' + str(heure[6])
if len(str(heure[4]))==1:
heure[4] = '0' + str(heure[4])
if len(str(heure[5]))==1:
heure[5] = '0' + str(heure[5])
return heure
def afficher_heure(): #Fonction qui permet d'afficher en gros au milieu de l'écran l'heure avec les secondes
temps = get_heure() #Définition de l'heure actuelle
afficher_texte("Menu ->", 264, 0, True) #Affichage permettant de savoir sur quel bouton appuyer pour retourner au menu
while bouton_droite.value() == 1: #Tant que le bouton de droite n'est pas appuyé
if get_heure()[6] != temps[6]: #Si l'heure actuelle diffère de celle définie en dehors de la boucle
afficher_texte(f"{temps[4]} : {temps[5]} : {temps[6]}", 64, 69, True, vga2_bold_16x32) #Affichage de l'heure
temps = get_heure() #Définition de l'heure pour recommencer la vérification du if
menu() #Affichage du menu
while bouton_droite.value() == 0: #Tant que le bouton de droite est appuyé, ne rien faire
pass
Par la suite on a les fonctions qui s’occupent de l’heure utilisant le protocole ntp qui permet de récupérer l’heure en temps réel avec set_heure() qui règle l’horloge interne de l’esp32 et get_heure() qui récupère l’heure et qui va la retourner dans ce format :
[année, mois, jour, jour de la semaine, heure, minute, seconde, milliseconde]
Et afficher_heure() va afficher l’heure en s’actualisant chaque seconde et qui s’arrête lorsque l’on appuie sur le bouton de droite pour retourner au menu.
########## METEO ##########
adresse_meteo = "https://api.openweathermap.org/data/2.5/weather?lat=43.95&lon=4.8167&appid=6dc180325a613e8fe2292078d342022a&lang=fr"
#Variable globale qui définit le lien de l'API de météo
def meteo(): #Fonction qui fait une requête au serveur de météo et qui renvoie une liste de certaines infos
if not wlan.isconnected(): #Si pas connecté, se connecte au réseau
do_connect()
data = json.loads(urequests.get(adresse_meteo).text) #Fait la requête et la convertie pour être utilisable en python
temperature = str(round(data.get("main").get("temp") - 273.15, 1)) #Température en kelvin puis en celsius
if len(temperature) == 3: #Si la temp est de ce format : 1.2 fait de la temp ce format : 01.2
temperature = '0' + temperature
humidite = str(data.get("main").get("humidity")) # Humidité
if len(humidite) == 1: #Comme pour la temperature
humidite = '0' + humidite
vent_vitesse = data.get("wind").get("speed") * 3.6 # vitesse du vent en m/s puis en Km/h
vent_orientation = data.get("wind").get("deg") # origine du vent en degré
image = 'image/' + data.get('weather')[0].get('icon') + '.png' #Récupération du code de l'image puis mise dans le bon format
description = data.get('weather')[0].get('description') #Description de la météo
nom_ville = f"{data.get('name')}, {data.get('sys').get('country')}" #Récupération du nom de la ville
return [temperature, humidite, str(round(vent_vitesse)), str(vent_orientation), image, description, nom_ville]
Pour la météo il y a deux fonctions et voici la première : meteo() va faire une demande API vers le site openweather afin de récupérer la météo d’Avignon.
def station_meteo(): #Fonction qui s'occupe d'afficher les données de la météo et qui s'actualise toutes les minutes
actualisation = True #Variables qui dit si oui ou non la météo doit s'actualiser chaque minutes
while actualisation: #Boucle while tant que actualisation == True
data = meteo() #Récupère les infos de la météo
heure = get_heure() #Récupère l'heure
afficher_texte("Menu ->", 264, 0, False) #Affiche le texte pour le retour au menu
longueur = int((320-(len(data[6]))*8)/2) #Affiche le nom de la ville
for i in range(len(data[6])): #Lettre par lettre pour éviter les problèmes dû aux accents
if data[6][i] == '\xe9':
lettre = 130
elif data[6][i] == '\xe8':
lettre = 138
elif data[6][i] == '\xe0':
lettre = 133
elif data[6][i] == '\xe7':
lettre = 135
else:
lettre = data[6][i]
afficher_texte(lettre, longueur, 5, True)
longueur += 8
tft.fill_rect(0, 44, 320, 1, st7789.WHITE) #Fait une barre blanche pour séparer le nom de la ville du reste
#Affichage de la température
temp = [data[0][0]+data[0][1], data[0][2]+data[0][3]]
afficher_texte('Temp', 28, 50, True)
afficher_texte(temp[0], 20, 67, True, vga2_bold_16x32)
afficher_texte(temp[1], 52, 81, True, vga2_8x16)
afficher_texte('o', 52, 67, True, vga2_8x8)
afficher_texte('C', 60, 67, True, vga2_8x16)
#Affichage de l'heure et des minutes
afficher_texte(f"{heure[4]} : {heure[5]}", 132, 25, True)
#Affichage de l'humidité
x = 20
if len(data[1]) == 3:
x -= 8
afficher_texte("Humid", 24, 105, True)
afficher_texte(data[1] + '%', x, 122, True, vga2_bold_16x32)
#Affichage de l'image selon le code donné
tft.png(data[4], 110, 30, True)
#Affichage du vent avec sa vitesse et sa direction
y = 67
if len(data[2]) == 1:
x = 252
elif len(data[2]) == 2:
x = 244
else:
x = 236
afficher_texte('Vent', 260, 50, True)
afficher_texte(data[2], x, y, True, vga2_bold_16x32)
afficher_texte('Km/h', x + len(data[2])*16, y+14, True)
y = 122
if len(data[3]) == 1:
x = 264
elif len(data[3]) == 2:
x = 256
else:
x = 248
afficher_texte("Direc", 256, 105, True)
afficher_texte(data[3], x, y, True, vga2_bold_16x32)
afficher_texte('o', x + len(data[3])*16, y, True, vga2_8x8)
#Affichage de la description qui correspond à l'image
longueur = int((320-(len(data[5]))*8)/2)
for i in range(len(data[5])):
if data[5][i] == '\xe9':
lettre = 130
elif data[5][i] == '\xe8':
lettre = 138
elif data[5][i] == '\xe0':
lettre = 133
elif data[5][i] == '\xe7':
lettre = 135
else:
lettre = data[5][i]
afficher_texte(lettre, longueur, 108, True)
longueur += 8
#Attente pour actualisation avec retour possible au menu
while True:
if get_heure()[5] != heure[5]: #Si la minute change on refait un tour de la boucle principale
break
if bouton_droite.value() == 0: #Si on appuie sur le bouton de droite on sort des boucles pour retourner au menu
actualisation = False
break
menu() #Affichage du menu
while bouton_droite.value() == 0: #Ne rien faire tant que le bouton de droite est appuyé
pass
Et en deuxième fonction il y a station météo qui est une boucle while qui s’actualise chaque minute et qui affiche toutes les informations soit : le nom de la ville, l’heure, la température, le pourcentage d’humidité, la vitesse du vent et sa direction et pour finir une image représentant le temps et une description juste en dessous
########## BOUTONS ##########
boutons = tft_buttons.Buttons() #Récupération des boutons de l'esp32
bouton_gauche = boutons.left #Définition des boutons dans des variables
bouton_droite = boutons.right
#bouton_gauche.value() == 0 si appuie, 1 si relâché
#bouton_droite.value() == 0 si appuie, 1 si relâché
def wait(): #Fonction qui permet de récupérer l'appui d'un bouton et
while True: #qui attend son relâchement avant de renvoyer le bouton appuyé
if bouton_gauche.value() == 0:
while bouton_gauche.value() == 0:
pass
return 'gauche'
if bouton_droite.value() == 0:
while bouton_droite.value() == 0:
pass
return 'droite'
Il y a également la fonction qui s’occupe de récupérer l’appuie des boutons et les variables globales qui représentent les deux boutons
########## MENU ##########
def menu(): #Fonction qui affiche le menu
tft.fill(st7789.BLACK) #Remplit l'écran en noir
longueur = 256 #Et affiche ce que font les boutons
mot = "Météo ->"
for i in range(len(mot)):
if mot[i] == '\xe9':
lettre = 130
else:
lettre = mot[i]
afficher_texte(lettre, longueur, 0, True)
longueur += 8
afficher_texte("Heure ->", 256, 154, True)
longueur = 56
mot = "Station Météo"
for i in range(len(mot)):
if mot[i] == '\xe9':
lettre = 130
else:
lettre = mot[i]
afficher_texte(lettre, longueur, 69, True, vga2_bold_16x32)
longueur += 16
afficher_texte("By Robin.C", 0, 154, True)
La fonction menu() affiche météo -> et heure -> au niveau des boutons pour indiquer à quoi ils servent, écrit en gros au milieu ‘Station Météo’ et en bas à gauche le nom du génie qui a écrit ce code ;).
########## MAIN ##########
def main(): #Fonction principale qui s'occupe de tout
if not wlan.isconnected(): #Si pas connecté, se connecte au réseau
do_connect()
set_heure()
menu()
while True: #Boucle infini qui appelle les fonctions
bouton = wait()
if bouton == 'gauche':
tft.fill(st7789.BLACK)
afficher_heure()
if bouton == 'droite':
tft.fill(st7789.BLACK)
station_meteo()
Pour finir les fonctions il y a la fonction principale qui va connecter l’esp32 à internet, afficher le menu puis faire une boucle infini afin de choisir si on veut la météo ou l’heure et permettre de changer pendant l’exécution de ce qu’on a choisi.
########## DÉMARRAGE ##########
#Essaie d'exécuter main() et si ça plante ou si l'exécution est interrompu
#Déinitialise l'écran pour éviter des problèmes lors d'autres exécutions
#Et désactive aussi le point d'accès pour encore une fois éviter des problèmes
try:
main()
finally:
deinit()
wlan.active(False)
Et enfin le code qui permet d’appeler la fonction main() d’une certaine manière: main() est dans un try afin qu’il soit exécuté et le finally fait que lorsque l’exécution sort du try le code dans le finally et ce code qui est la déinitialisation de l’écran et la désactivation du point d’accès internet, cela permet de redémarrer l’exécution en évitant des possibles plantages.
Fichiers
Pour avoir cette magnifique station météo chez vous il vous faut simplement un esp32 avec micropython (sachant que pour ma part je possède un esp32 Lilygo T-display S3) et de télécharger les fichiers que vous pouvez retrouver en cliquant sur le bouton :
Pour conclure ce projet m’a permis d’apprendre énormément de choses sur le micropython et je suis assez content du résultat car lorsque j’ai commencé le projet le fait qu’il y ai peu de documentation et personne pour aider était dur, cependant en cherchant un peu partout et en essayant des choses j’ai réussi à comprendre plein de choses.
Le jeu-vidéo mythique des années 70 ! Casse-briques est un jeu de réflexion qui vous demandera beaucoup d’agilité. Le principe est simple, une balle est lancée, utilisez la plateforme mobile mis à votre disposition pour la faire rebondir et tentez de toucher lesbriques.
Genèse du projet
Le Casse-briques sur NumWorks est un jeu que j’ai voulu initialement développé il y a de cela un peu moins d’un an, juste après la publication de l’application Colors. J’avais commencé très brièvement la partie graphique du jeu, mais c’était assez rudimentaire et ça ne plaisait pas trop. Ensuite l’été a débuté et suite à des problèmes techniques lors du développement, le projet a peu à peu pris la poussière… Jusqu’à récemment.
Déterrage
Pour le dernier projet de l’année en NSI (le projet libre), j’ai décidé de sortir du placard le jeu, initialement abandonné, pour le redévelopper. Néanmoins, 2 semaines (pas à temps plein malheureusement, au contraire), ça reste peu pour développer un jeu de cette envergure, même pas l’IDE encore ouvert que j’avais énormément de questions qui me traverser l’esprit :
Comment faire bouger la balle et la faire rebondir correctement ? (rien que ça)
Comment gérer les collisions de la balle avec les briques ? (sans aucun doute la chose la plus complexe)
Comment générer des niveaux inédits et cohérents ?
C’est pour ça qu’en réalité, j’ai commencé doucement le développement du projet en avance (mi-mars), pour avoir pleinement le temps de proposer une réalisation finale convenable et fonctionnelle. J’avais énormément d’idées pour la conception du jeu, notamment avec un système de powers-up. Mais tout n’a pas pu voir le jour malheureusement.
La main à la pâte
Maintenant que les idées sont là, il faut retrousser ses manches et plonger dans la phase de développement.
L’ébauche d’un menu
Élaborons d’abord la page le menu du jeu, celui-ci devra afficher notamment, le score, le niveau, ainsi que le nombre de vies restantes. Et c’est le cas :
C’est une partie plutôt simple (on commencer doucement), rien de bien sorcier :
[...]
def menu():
rec(0, 0, 320, 222, dark_c)
rec(0, 200, 320, 22, game_c)
for k in range(len(chars)): # Display method inspired by @riko_schraf
for j in range(19):
if chars[k] >> j & 1 == 1:
rec(110 + 12 * k + (j % 3) * 3, 40 + (j // 3) * 3, 3, 3, light_c)
txt("Score: " + str(score), 160-5*(7+len(max(str(score), str(stage)))), 70, bright_c, dark_c)
txt("Stage: " + str(stage), 160-5*(7+len(max(str(score), str(stage)))), 90, bright_c, dark_c)
txt("Lives: " + str(pv), 160-5*(7+len(max(str(score), str(stage)))), 110, bright_c, dark_c)
if pv > 0:
txt("Press OK to play", 80, 150, bright_c, dark_c)
else:
txt("GAME OVER", 115, 150, bright_c, dark_c)
txt("Gameplay by nsi.xyz/breakout", 20, 202, bright_c, game_c)
Une fonction menu(), assez simpliste dans le fond. L’affichage du nom du jeu « BREAKOUT » est géré entre les lignes 5 et 8. C’est un système d’affichage initié par Eric SCHRAFSTETTER (@riko_schraf), que j’ai modifié pour afficher le texte voulu, il utilise notamment la décomposition d’entiers en binaire pour savoir si une case est « allumée » ou non. Pour les plus déterminés et les plus curieux qui voudrons découvrir comment ça fonctionne, voici quelques ressources :Opération bit à bit — Wikipédia (wikipedia.org) [FR] • Python Bitwise Operators – GeeksforGeeks [EN]
Ce sont (quasiment) toutes les variables globales utilisés dans le jeu, certaines sont plus intéressantes que d’autres, et nous nous attarderont ici uniquement sur celles que je juge donc intéressantes. Certaines variables respectent une certaine nomenclature (p_*: ce qui concerne la plateforme mobile, b_*: ce qui concerne la balle, br_*: ce qui concerne les briques, etc.).
p_size: C’est la taille de la plateforme mobile
p_speed: C’est sa vitesse de déplacement (si elle vaut 3, c’est qu’elle va se déplacer de 3 en 3 pixels (vers la gauche ou la droite))
p_x: C’est la position x, de la plateforme mobile, plus exactement, c’est la position du pixel au centre de la plateforme mobile. La position y est moins importante, étant donné que celle-ci est constante (c’est pourquoi une list n’a pas été utilisé pour stocker ces deux valeurs).
La position et la taille de la plateforme sont des éléments essentiels pour détecter une collision. Ici, p_x est est représenté par le pixel rouge :
De la même manière.
b_size: C’est le diamètre (même si on parlera ici plutôt de côté) de la balle.
b_dir: C’est un vecteur, qui va donc déterminer où la balle va se diriger (si il vaut [1, 1], la balle ira en diagonale vers la droite et vers le bas (l’axe des ordonnées est inversé)). Plus la norme du vecteur est élevé, plus la balle sera rapide (si il vaut [2, 2], il ira aussi vers la droite et vers le bas, mais la balle sera plus rapide).
b_pos: C’est la position x, y de la balle.
Ces 3 variables (surtout la 1ère et la 3ème) sont essentiels pour détecter une collision.
Comme vous le voyez, le jeu a été conçu pour très facilement modulable. Pourquoi ? Car déjà c’est préférable lorsqu’on développe n’importe quelle application, et aussi pour intégrer des powers-up facilement. En effet, modifier la valeur de b_size aurait fait un power-up qui change la taille de la balle en plein jeu !
Des collisions
C’est sans aucun doute ce qui m’a mis le plus en difficulté, j’ai voulu faire un système non spécifique au jeu, qui serait donc facile d’intégrer dans un autre jeu, et c’est ce que j’ai fait.
Grosso modo, les collisions fixes (le système n’est pas optimisé pour gérer des entités mouvantes, celles de la plateforme mobile sont gérés autrement et sont spécifiques au jeu) sont stockées dans une list, enfin plutôt dans une list elle-même dans une list, enfin non, plutôt dans une list elle-même dans une list qui est elle-même dans une list. 🤯 😵💫 J’ai dit que les collisions étaient stockées, mais qu’est-ce que j’appelle une collision ? En réalité je stocke 2 valeurs entières qui vont former un cuboïde, ce dernier sera interprété comme un masque de collision (hitbox).
Ici le rectangle noir représenté un masque de collision, pour pouvoir le retrouver, nous avons besoin au minimum des coordonnées du point supérieur gauche et du point inférieur droit. Ainsi si la position de la balle se trouve dans la zone, elle doit rebondir. En réalité c’est un peu plus compliqué que ça, car selon le côté du cuboïde où la balle atterrit, la balle ne part pas au même endroit… Il faut donc aussi déterminer le côté du cuboïde où la balle est entré en collision. En bref, ce sont énormément de mathématiques.
[...]
def collision_manager(x, y):
for i in range(len(cuboids)):
if cuboids[i] and (i < cuboids[i][0][1]+10 or len(cuboids)-3 <= i <= len(cuboids)):
h = b_size//2
x_s, y_s, x_e, y_e = cuboids[i][0][0]-h, cuboids[i][0][1]-h, cuboids[i][1][0]+h, cuboids[i][1][1]+h
if y_s-abs(b_dir[1]) <= y <= y_s+abs(b_dir[1]) and x_s <= x <= x_e:
b_dir[1] = -b_dir[1]
destroy_brick(i)
elif x_s-abs(b_dir[0]) <= x <= x_s+abs(b_dir[0]) and y_s <= y <= y_e:
b_dir[0] = -b_dir[0]
destroy_brick(i)
elif x_e-abs(b_dir[0]) <= x <= x_e+abs(b_dir[0]) and y_s <= y <= y_e:
b_dir[0] = -b_dir[0]
destroy_brick(i)
elif y_e-abs(b_dir[1]) <= y <= y_e+abs(b_dir[1]) and x_s <= x <= x_e:
b_dir[1] = -b_dir[1]
destroy_brick(i)
Voici une démonstration du système (pendante la phase de développement) avec quelques informations de débogage affichés en haut à droite :
Les masques de collisions sont représentés par des rectangles rouges.
Génération de niveaux
Le système de générations de niveaux a été pensé par Vincent ROBERT (@nsi.xyz), ce système utilise également les mathématiques (comme tous les systèmes du jeu en fait).
[...]
def level_generator(stg):
lvl = "".join([" " for _ in range(10)])+"*"*(stg//11+1)*10
col = set()
for i in (2, 3, 5, 7):
if not stg % i:
for j in range(i, 10, i):
col.add(j)
for i in range(stg // 11 + 2):
for j in range(10):
if j in col:
lvl = lvl[:i * 10 + j] + " " + lvl[i * 10 + j + 1:]
return lvl
Un niveau est stocké dans un str, à l’aide d’un « motif », le « motif » est composé de « * » et de » « , lorsqu’il y a un « * », c’est que c’est l’emplacement d’une brique, sinon c’est qu’il y en a pas. Ainsi, générer un niveau consiste à générer une chaine de caractères avec des « * », » « . À noter, qu’ici, utiliser une chaine de caractère n’est pas très pertinent, il aurait été préférable d’utiliser un entier, et d’utiliser sa notation binaire (1: emplacement d’une brique, 0: emplacement vide). Peut-être que ce sera optimisé dans une version future du jeu (avec l’intégration des powers-up).
Ensuite, le niveau est construit :
[...]
def level_constructor():
global level, cuboids
rec(0, 0, 320, 222, dark_c)
level = level_generator(stage)
for i in range(len(level)):
if level[i] == "*":
rec(1 + (br_width + 2) * (i % 10), 1 + (br_height + 2) * (i // 10), br_width, br_height, set_color(i // 10))
cuboids = [[[1+(br_width+2)*(i % 10), 1+(br_height+2)*(i//10)], [1 + (br_width + 2) * (i % 10) + br_width,
1 + (br_height + 2) * (i // 10) + br_height]] if level[i] == "*" else [] for i in range(len(level))]
cuboids += (((0, 0), (0, 222)), ((0, 0), (320, 0)), ((320, 0), (320, 222)))
Lorsqu’une brique est dessiné, ses collisions sont directement ajoutés dans la liste des collisions (cuboids).
Fonction mère
Enfin, les interactions du joueur sont directement interprétés dans la fonction engine(), Si on appuie sur la flèches gauche, on déplace la plateforme vers la gauche, et si c’est la flèche droite, on la déplace vers la droite. Lorsqu’il reste 3 collisions, c’est que toutes les briques sont cassés, et donc que le niveau est terminé ! Pourquoi 3 ? Car les collisions des bords de l’écran sont aussi stockés dans cuboids.
def engine():
global p_x, pv, game_state, stage
while game_state not in ("L_CLEAR", "G_OVER"):
if keydown(0) and p_x > 10 + p_size // 2:
p_x -= p_speed
pad(p_size, 1)
if keydown(3) and p_x < 310 - p_size // 2:
p_x += p_speed
pad(p_size, -1)
ball_manager()
if len(cuboids)-sum([1 if not i else 0 for i in cuboids]) == 3:
game_state = "L_CLEAR"
stage += 1
pv += 1
debug()
pv -= 1 if game_state == "G_OVER" else 0
menu()
Conclusion
Finalement, l’élaboration et le développement de ce projet ont été très enrichissantes. J’étais habitué jusqu’à ce projet à développer des applications « fixes » (avec un seul processus à gérer en même temps), développer des applications « dynamiques » (avec plusieurs processus simultanés (en l’occurrence, les mouvements de la balle, et celles de la plateforme)) est quelque chose d’un peu plus complexe, mais pas moins intéressant, au contraire ! Je suis assez satisfait du jeu final, même si je juge qu’il reste quelques défauts et qu’il manque des fonctionnalités que j’aurai voulu intégrer mais que je n’ai pas pu par manque de temps. Cependant, rien ne m’empêche de continuer le développement du jeu à l’avenir en y ajouter et corrigeant des choses !
Le jeu de Sudoku est un jeu de logique joué sur une grille de 9 * 9 cases, divisée en 9 blocs de 3 * 3 cases. Le but est de remplir chaque case avec un chiffre de 1 à 9, en respectant certaines règles : chaque chiffre ne doit apparaître qu’une seule fois par ligne, colonne et bloc. Le jeu est terminé lorsque toutes les cases sont remplies ou lorsque toutes les vies ont été utilisées.
Logique du jeu
J’ai commencé par coder la couche logique du Sudoku. Pour stocker les informations, la grille est représentée par une matrice de 9 listes, contenant chacune 9 zéros.
board = reset()
def reset():
return [[0 for i in range(9)] for j in range(9)]
Comme précédemment indiqué, le Sudoku doit respecter trois règles : chaque chiffre ne doit apparaître qu’une seule fois par ligne, colonne et bloc (un bloc étant un regroupement de 3 * 3 case). J’ai donc créé trois fonctions qui renvoient les éléments dans la ligne, la colonne et le bloc. Ensuite, j’ai créé une fonction qui appelle les trois précédentes et qui renvoie les nombres qui respectent les règles. Jusque-là, rien de bien compliqué.
def ligne(x):
return [i for i in range(1,10) if i in board[x]]
def colonne(y):
return [board[i][y] for i in range(9) if board[i][y] != 0]
def bloc(x, y):
nums = []
for i in range(x//3*3, x//3*3+3):
for j in range(y//3*3, y//3*3+3):
if board[i][j] != 0:
nums.append(board[i][j])
return nums
def possible(x, y):
return [i for i in range(1,10) if i not in ligne(x)+colonne(y)+bloc(x,y)]
Il faut maintenant s’attaquer au plus complexe : créer la grille de Sudoku.
J’avais commencé par concevoir une grosse fonction qui créait bel et bien une grille valable de Sudoku, mais cette fonction était récursive (dans mon cas, elle s’appelait elle-même tant que la grille n’était pas valable). Et si sur ordinateur le jeu pouvait tourner (via un environnement de développement comme Thonny), ce n’était pas le cas sur Numworks où le nombre d’itération est très limitée.
Pour régler ce problème, j’avais modifié cette fonction qui faisait alors apparaître des nombres aléatoires présents dans la liste générée par possible(x, y). Par exemple, je générais un premier nombre, la grille étant vide tous les nombres étaient valides, puis un autre… jusqu’à une cinquantaine de nombres.
Mais je suis alors arrivé à un problème majeur : même si tous les nombres générés étaient valides, certains cases vides n’étaient pas solvables, c’est-à-dire que l’on ne pouvait placer aucun nombre car les seuls nombres pouvant être théoriquement placé étaient déjà présents dans la ligne/colonne/bloc par rapport à la case non solvable.
Je me suis retrouvé dans une impasse et c’est à ce moment-là que M. Robert m’a proposé un code qui parcourt la matrice à l’aide de deux boucles while. Pour chaque emplacement, le code vérifie si au moins un nombre peut être placé. Si c’est le cas, un nombre aléatoire est choisi dans le résultat de possible(x,y). Si aucun nombre n’est valide, la boucle recommence à la ligne précédente. Si le nombre d’essais dépasse 42, la fonction se bloque et recommence depuis le début.
def genere_board():
global board
board = reset()
x = y = essai = 0
while x!=9:
essai += 1
if essai ==42:
x = essai =0
board = reset()
y = 0
while y!=9:
if possible(x,y)==[]:
board[x] = [0 for i in range(9)]
y = 8
x = x-1
else:
board[x][y] = choice(possible(x,y))
y +=1
x +=1
return board
Maintenant que ma fonction principale est prête, je peux commencer à supprimer des nombres pour que la grille puisse être résolue. Cette fonction va donc prendre une case au hasard, et si elle est remplie, elle supprime le nombre.
def suppr():
for i in range(40):
x, y = randint(0,8), randint(0,8)
while board[x][y] == 0:
x, y = randint(0,8), randint(0,8)
board[x][y] = 0
Gestion graphique (affichage)
Tout d’abord, j’ai généré une grille de 9 * 9, mais pour chaque bloc (groupe de 3 * 3 cases), la couleur change. Voici donc les deux fonctions qui s’en occupent :
def couleur(x,y,p=0):
if (x//3 + y//3) %2 == 1:
return (180-42*p,140-35*p,225)
else:
return (255,200-30*p,125-85*p)
def grille():
for x in range(9):
for y in range(9):
rect(2+x*(22), 2+y*(22), 20, 20, couleur(x,y,0))
La fonction grille() ne dessine donc que la grille, mais elle utilise la fonction couleur(x, y, p) pour attribuer une couleur à chaque bloc. Grâce à l’opérateur modulo, on peut savoir dans bloc la case que l’on souhaite dessiner se trouve, et donc lui assigner la bonne couleur (en jaune ou en violet).
Résultat:
Ensuite, je me suis occupée du déplacement sur la grille. J’ai donc utilisé un exemple fourni par les professeurs que j’ai adapté :
def wait(buttons=(0,1,2,3,4,52)):
while True:
for i in buttons:
if keydown(i):
while keydown(i): True
return i
while True:
key_pressed = wait()
pos_old = list(pos)
if key_pressed == 1: # flèche haut
pos[1] = (pos[1]-1) % pmax[1]
elif key_pressed == 2: # flèche bas
pos[1] = (pos[1]+1) % pmax[1]
elif key_pressed == 3: # flèche droite
pos[0] = (pos[0]+1) % pmax[0]
elif key_pressed == 0: # flèche gauche
pos[0] = (pos[0]-1) % pmax[0]
if key_pressed not in (42, 43, 44, 36, 37, 38, 30, 31, 32):
deplacement()
La fonction wait() attend qu’une touche soit pressée, et grâce au module ion, elle retourne la clé (valeur numérique identifiant la touche) de celle-ci qui est enregistrée dans key_pressed. Ensuite, en fonction de la touche pressée, la position via la variable pos change. L’opérateur modulo permet d’éviter de dépasser les limites de la grille. Il permet de retourner au début d’une ligne ou colonne lorsqu’on a atteint la fin de celle-ci.
Afin de repérer la case sur laquelle on se situe, j’ai ajouté la fonction surbrillance(), appelée par la fonction deplacement():
def surbrillance(x, y, mode):
for i in range(9):
rect(2+i*(22), 2+y*(22), 20, 20, couleur(i, y, mode))
rect(2+x*(22), 2+i*(22), 20, 20, couleur(x, i, mode))
if board[i][y] != 0:
dessine_nb(i, y, board[i][y], mode)
if board[x][i] != 0:
dessine_nb(x, i, board[x][i], mode)
for i in range(x//3*3, x//3*3+3):
for j in range(y//3*3, y//3*3+3):
rect(2+i*(22), 2+j*(22), 20, 20, couleur(i, j, mode))
if board[i][j] != 0:
dessine_nb(i, j, board[i][j], mode)
def deplacement():
x, y = pos_old
surbrillance(x,y,0)
x, y = pos
surbrillance(x,y,1)
rect(2+x*(20+2), 2+y*(20+2), 20, 20,couleur(x,y,2))
if board[x][y]!=0:
dessine_nb(x,y,board[x][y],2)
surbrillance() va redessiner les cases de la ligne, la colonne et le bloc associés à la case, en utilisant la couleur, fournit par couleur(x, y, mode).
La fonction deplacement() va donc à chaque fois qu’elle sera exécutée :
Appeler surbrillance() en utilisant en paramètre les coordonnées de l’ancienne position et mode=0 ce qui va donc effacer la surbrillance précédente,
Rappeler la fonction avec les nouvelles positions, et mode=1 ce qui va dessiner la nouvelle surbrillance.
Résulat:
J’ai ensuite rajouté la détections des touches du pavé numérique de la calculatrice. Pour faire cela, j’ai précisé dans la fonction wait() pour le paramètre buttons les clés 42, 43, 44, 36, 37, 38, 30, 31 et 32 qui correspondent respectivement aux touches 1, 2, 3, 4, 5, 6, 7, 8 et 9.
Une fois cela fait, j’ai indiqué dans le while vu précédemment – celui qui gère changements de la variables pos (… Mais si, je parle du while qui s’occupe des déplacements) – pour chaque nombre l’exécution de la fonction is_valid() en prenant comme en paramètre la position de la case (x et y) et le nombre qui veut être rajouté, dépendant donc de la touche que l’on presse.
Ici, si la touche 1 est pressée (qui correspond a la clé 42), la fonction is_valid() est appelée avec comme paramètre nb qui vaut 1.
def is_valid(x,y,nb):
if board[x][y]==0:
if nb == solution[x][y]:
dessine_nb(x,y,nb,1)
board[x][y]=nb
def dessine_nb(x,y,nb,mode):
txt(str(nb),x*22+7,y*22+3,"black",couleur(x,y,mode))
La fonction is_valid() vérifie donc que le nombre indiqué en paramètre peut être placé, et si c’est le cas, il sera ajouté dans la matrice et dessiné dans la case sélectionnée (celle dont les positions sont indiqués en paramètre).
Autres fonctionnalités
Maintenant que la base du jeu est prête, on peut rajouter d’autres fonctionnalités. On va rajouter un système de difficulté et un système d’aide, que l’on pourra paramétrer via un menu. On va également rajouter un système de vie, pour que le jeu soit plus intéressant.
Je montrerai uniquement le principe pour la gestion des niveaux de difficulté, mais l’idée est la même pour le paramétrage de l’aide :
Premièrement draw_level() permet de dessiner l’affichage du menu, si s=1 alors Find est en violet et les flèches apparaissent, sinon Find est en noir et les flèches ne s’affichent pas. Cette fonction va être appelée plusieurs fois afin de changer l’apparence de la sélection.
Dans la liste options est stockée les 4 difficultés. L’utilisateur peut alterner entre les 4 valeurs de la liste via les flèches gauche et droite grâce à la boucle et la condition while diff is None. Lorsque le joueur appuiera sur la touche OK, il confirmera sa sélection et quittera la boucle, afin de continuer la suite des instructions du programme. C’est en effet le même principe que la boucle pour gérer les déplacements.
Par la suite, la fonction suppr(lvl) est appelée (expliqué précedamment). Ainsi, le nombre de chiffre retiré de la matrice (la grille en somme) dépend du choix du joueur parmi les 4 proposés.
Comme je l’ai dit, l’idée est la même pour le choix de l’aide, sauf qu’au lieu d’avoir 4 choix, il n’y en a que deux : « On » ou « Off ».
Si « On » est sélectionnée, « Valid Number » apparait en bas à droite, et pour chaque déplacement dans la grille, aide() est appelée :
def aide(x,y):
rect(200,155 ,200,20,(255,)*3)
nbs = possible(x, y)
if board[x][y]==0:
for i in range(len(nbs)):
txt(str(nbs[i]), 265 + i * 20- len(nbs) *10, 155,(42,)*3)
if nbs[i]!=nbs[-1]:
txt(",", 275+ i * 20 - len(nbs) *10, 155,(42,)*3)
else:
txt("Full", 240,155)
Si la case sélectionnée est pleine, elle affiche « Full », sinon elle affiche tous les nombres qui pourrait être valables dans une case, générés par possible(x, y) vu précédemment.
On a presque mis en place toutes les fonctionnalités supplémentaires mais il manque encore une gameover quand le jeu se termine et le système de vie :
def check():
c=0
for i in range (9):
for j in range (9):
if board[i][j]!=0:
c+=1
return c==81
def coeur():
rect(x+3,y+0,3,3, col)
rect(x+15,y+0,3,3,col)
rect(x+0,y+3,9,3,col)
rect(x+12,y+3,9,3,col)
rect(x+0,y+6,21,3,col)
rect(x+3,y+9,15,3,col)
rect(x+6,y+12,9,3,col)
rect(x+9,y+15,3,3,col)
def perdre_vie():
rect(272 - vie *25, 5, 21, 21, (255,) * 3)
La fonction perdre_vie() est appelée dans is_valid(). Si le nombre n’est pas juste, on retire une vie en décrémentant la variable vie de 1 et la fonction perdre_vie() est appelée. Elle dessine un carré blanc, afin d’effacer un des trois cœurs, dessiné au lancement du jeu avec coeur(222,5), coeur(247,5) et coeur(272,5).
La fonction check() regarde si la grille est remplie entièrement. Cette fonction est appelée à chaque déplacement dans la boucle principale while True :
while True:
if vie==0:
txt("Perdu!",230,5,(42,)*3,(255,)*3)
break
if check()==True :
txt(" Gagné! ",210,5,(42,)*3,(255,)*3)
break
Ainsi si check() == True, le texte » Gagné! » apparait et la partie se termine grâce au break. Si le jeu se termine parce que l’utilisateur n’a plus de vie, c’est plutôt le texte « Perdu! » qui apparait.
Captures d’écran finale
Conclusion
Le jeu est donc fini ! La conception m’a pris relativement beaucoup de temps, mais ca m’a permit d’apprendre plein de chose ainsi que de m’améliorer en Python !
Si vous souhaitez le télécharger, voici le lien vers le script avec en supplément un lien vers la page de présentation du jeu :
Le Puissance 4 est probablement un jeu de votre enfance, c’est pourquoi je vous propose de jouer à ma version du Puissance 4 directement sur votre NumWorks avec un ami.
L’idée
L’idée du Puissance 4 a été longuement réfléchi car le projet de ces vacances était libre et j’avais eu l’idée de faire un jeu sur la NumWorks mais je ne savais pas lequel faire. Après avoir parcouru le site à la recherche de jeu original qui n’avait pas été déjà fait, l’idée du Puissance 4 m’est venu à l’esprit.
La réalisation
Pour réaliser le jeu j’ai avant tout fait en sorte qu’il soit jouable sur la console avant de faire la partie graphique de la calculatrice (même si certains ajouts ont été fait pendant le développement de la partie graphique).
Le Script
Je vais maintenant vous présenter le script et vous faire une brève explication de chacune des fonctions :
from kandinsky import fill_rect as rect, draw_string as txt
from time import sleep
from ion import keydown
Au tout début du script nous avons évidemment les appels des différents modules :
Kandinsky : c’est un des modules propriétaire de NumWorks qui est utilisé afin de dessiner des rectangles ou même écrire du texte sur l’écran de la calculatrice
Time : permet avec la fonction sleep que j’appel de mettre des pause dans le script
Ion : c’est le second module propriétaire de NumWorks qui permet de prendre en compte l’appui des touches pendant le script.
Nous avons ensuite la définition des variables globales :
# 1 = rouge // 2 = jaune
# Variables globales
player = 1 #Définit le joueur qui doit jouer
grille_preview = [0, 0, 0, 0, 0, 0, 0] #Est utilisé pour déterminer les positions possible du preview
grille = [[0 for i in range(7)] for i in range(6)] #La matrice qui représente la grille de jeu
#Les couleurs utilisées
rouge = (182, 2, 5)
jaune = (255, 181, 49)
gris = (191, 189, 193)
pos = 3 #Donne la position du preview
#Les points des joueurs
points_rouge = 0
points_jaune = 0
Ensuite une des fonctions majeures du jeu : la fonction de vérification. Cette fonction va après chaque coup vérifier toutes les positions afin de voir si il y a un gagnant ou pas.
def verifie(): #Gagnant ?
for i in range(6): #lignes
for j in range(4):
if grille[i][j] == player and grille[i][j+1] == player and grille[i][j+2] == player and grille[i][j+3] == player:
gagnant(player)
for i in range(3): #colonnes
for j in range(7):
if grille[i][j] == player and grille[i+1][j] == player and grille[i+2][j] == player and grille[i+3][j] == player:
gagnant(player)
for i in range(3): #diagonales
for j in range(4):
if grille[i][j] == player and grille[i+1][j+1] == player and grille[i+2][j+2] == player and grille[i+3][j+3] == player:
gagnant(player)
for i in range(3, 6):
for j in range(4):
if grille[i][j] == player and grille[i-1][j+1] == player and grille[i-2][j+2] == player and grille[i-3][j+3] == player:
gagnant(player)
Cependant je n’ai pas tout dit à propos de cette fonction car celle ci n’est pas tout à fait de moi : en effet avant d’avoir cette fonction là j’avais codé une fonction vérification mais celle ci faisait environ 70 lignes et n’était pas du tout optimisé ce qui amenait à des ralentissement, ChatGPT m’a donc aidé à réduire la fonction afin d’avoir la version ci-dessus. Et donc voici en exclusivité ma fonction de vérification originelle :
def verifie():
#horizontalement
for i in range(6):
for j in range(4):
rouge = 0
jaune = 0
for k in range(4):
if grille[i][j+k] == 1 :
rouge += 1
elif grille[i][j+k] == 2 :
jaune += 1
if rouge == 4 :
player_won(1)
elif jaune == 4 :
player_won(2)
#verticalement
for i in range(3):
for j in range(7):
rouge = 0
jaune = 0
for k in range(4):
if grille[i+k][j] == 1 :
rouge += 1
elif grille[i+k][j] == 2 :
jaune += 1
if rouge == 4 :
player_won(1)
elif jaune == 4 :
player_won(2)
#diagonalement
"""(ij)
/
2 diag de 4 : 03 12 21 30 // 26 35 44 53
2 diag de 5 : 04 13 22 31 40 // 16 25 34 43 52
2 diag de 6 : 05 14 23 32 41 50 // 06 15 24 33 42 51
\
2 diag de 4 : 03 14 25 36 // 20 31 42 53
2 diag de 5 : 02 13 24 35 46 // 10 21 32 43 54
2 diag de 6 : 00 11 22 33 44 55 // 01 12 23 34 45 56
"""
#création des listes pour vérifier
diag4 = [[[0, 3], [1, 2], [2, 1], [3, 0]], [[2, 6], [3, 5], [4, 4], [5, 3]], [[0,3], [1,4], [2,5], [3,6]], [[2,0], [3,1], [4,2], [5,3]]]
diag5 = [[[0, 4], [1, 3], [2, 2], [3, 1], [4, 0]], [[1, 6], [2, 5], [3, 4], [4, 3], [5, 2]], [[0, 2], [1, 3], [2, 4], [3, 5], [4, 6]], [[1, 0], [2, 1], [3, 2], [4, 3], [5, 4]]]
diag6 = [[[0, 5], [1, 4], [2, 3], [3, 2], [4, 1], [5,0]],[[0, 6], [1, 5], [2, 4], [3, 3], [4, 2], [5,1]],[[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5,5]],[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5,6]]]
#vérification des diagonales de 4
for i in range(4):
if grille[diag4[i][0][0]][diag4[i][0][1]] == grille[diag4[i][1][0]][diag4[i][1][1]] == grille[diag4[i][2][0]][diag4[i][2][1]] == grille[diag4[i][3][0]][diag4[i][3][1]] :
if grille[diag4[i][0][0]][diag4[i][0][1]] == 1 :
player_won(1)
elif grille[diag4[i][0][0]][diag4[i][0][1]] == 2 :
player_won(2)
#vérification des diagonales de 5
for i in range(4):
for j in range(2):
if grille[diag5[i][0+j][0]][diag5[i][0+j][1]] == grille[diag5[i][1+j][0]][diag5[i][1+j][1]] == grille[diag5[i][2+j][0]][diag5[i][2+j][1]] == grille[diag5[i][3+j][0]][diag5[i][3+j][1]] :
if grille[diag5[i][0+j][0]][diag5[i][0+j][1]] == 1 :
player_won(1)
elif grille[diag5[i][0+j][0]][diag5[i][0+j][1]] == 2 :
player_won(2)
#vérification des diagonales de 6
for i in range(4):
for j in range(3):
if grille[diag6[i][0+j][0]][diag6[i][0+j][1]] == grille[diag6[i][1+j][0]][diag6[i][1+j][1]] == grille[diag6[i][2+j][0]][diag6[i][2+j][1]] == grille[diag6[i][3+j][0]][diag6[i][3+j][1]] :
if grille[diag6[i][0+j][0]][diag6[i][0+j][1]] == 1 :
player_won(1)
elif grille[diag6[i][0+j][0]][diag6[i][0+j][1]] == 2 :
player_won(2)
Ma fonction donc vérifiait chaque possibilité afin de gagner au jeu mais le plus long était surtout les diagonales qui n’étaient pas automatisées avec des boucles sans variables définies mais plutôt avec des listes interminables des positions possibles des diagonales et cela ralentissait considérablement le script. C’est pour cela que j’ai préféré utilisé la fonction de ChatGPT.
Par la suite nous avons une autre fonction majeure qui est celle qui est appelée dans le cas d’une fin de partie donc soit ci un joueur a gagné ou si il y a égalité et c’est cette même fonction qui redémarre une partie donc rénitialise la grille et actualise les scores :
def gagnant(winner): #Met fin à une partie gagnant ou pas
global points_jaune, points_rouge, player, nb_partie, grille, partie
affichage_grille()
if winner == 1 : #Vérifie la variable winner pour savoir qui a gagné et agir en conséquence
points_rouge += 1
player = 2
txt("Rouge a gagné !", 88, 20)
elif winner == 2 :
points_jaune += 1
player = 1
txt("Jaune a gagné !", 88,20)
else :
txt("C'est une égalité", 76, 20)
wait() #La fonction attend qu'il y ai une touche de pressé (permet de voir la grille avant sa rénitialisation
actu_src() #Actualisation des score
grille = [[0 for i in range(7)] for i in range(6)] #Rénitialise la grille
affichage_grille() #Affiche la grille
Ensuite nous avons la fonction selection qui est je dirai la dernière fonction majeure du script, elle permet au joueur de selectionner la colonne ou il souhaite ajouter son jeton et appel la fonction jouer que nous allons voir juste après :
def selection():
global pos
affichage_grille()
preview(pos) #Affiche le preview du jeton (par défaut la 4ème colonne)
add = 1
while True : # Boucle qui permet de prendre en compte l'appui des touches et agit en conséquence.
preview(pos)
while colonne_pleine(pos):
pos = (pos+add)%7
preview(pos)
key_pressed = wait() #Récupère la touche appuyé
if key_pressed == 0: #Flèche de gauche // décale le preview vers la gauche
add = -1
if key_pressed == 3:#Flèche de droite // décale le preview vers la droite
add = +1
if key_pressed==0 or key_pressed==3: #Calcul la position du preview
pos = (pos+add)%7
preview(pos)
if key_pressed == 4 or key_pressed == 52 : #OK ou EXE (permet de jouer le coup)
rect(75, 17, 170, 20, (255,255,255))
jouer(pos)
Suite à cela il y a la fonction jouer qui est appelé dans la fonction selection et qui permet de jouer le coup dans la colonne sélectionné dans selection() :
def jouer(colonne): # Ajoute un jeton dans la colonne donnée
global player
if player == 1 : #Si c'est au tour de rouge
animation(colonne) # Fais l'animation de chute du jeton
grille[gravite(colonne)][colonne] = 1 #Modifie la matrice
verifie() #Vérifie si il y a un gagant
player = 2 #Change de joueur
elif player == 2 : #La même chose que pour le rouge mais pour le jaune
animation(colonne)
grille[gravite(colonne)][colonne] = 2
verifie()
player = 1
grille_pleine() #Vérifie si la grille est pleine dans le cas d'un nul
Après il y a la fonction qui anime la chute du jeton dans la grille :
def animation(colonne): #Animation chute
if player == 1 : #Définit la couleur du jeton
color = rouge
else :
color = jaune
for i in range(0, gravite(colonne)+1): #Dessine des jeton à la suite jursqu'à la dernière ligne
ligne = (i-1)*(i!=0)
rect(75+(25*colonne),42+(ligne*25),20,20,gris)
sleep(0.05)
draw_cercle(75 + (25*colonne) + 7, 42 + (i*25) + 2, color)
sleep(0.05)
Ensuite la fonction qui dessine les cercles mais qui n’est pas de moi mais de M.Robert :
def draw_cercle(x,y,color): #Fait des cercles (Par VR)
for d in range(6):
rect(x-d+(d==0),y+d+(d==5),6+2*d-2*(d==0),16-2*d-2*(d==5), color)
Par la suite il y a ma fonction colonne_pleine qui dit si la colonne donnée en paramètre est pleine ou pas :
def colonne_pleine(colonne):
if (grille[0][colonne] == 1) or (grille[0][colonne] == 2):
return True
return False
Une fonction similaire à la précedente : fonction grille_pleine utilise colonne_pleine afin de déterminer si la grille est pleine ou pas donc si il y a égalité :
def grille_pleine(): #Vérifie si il y a une égalité soit si la grille est pleine
colonne_pleines = 0
for i in range(7): #Passe en revue les premières lignes de chaque colonne
if colonne_pleine(i):
colonne_pleines += 1
if colonne_pleines == 7: #Si toutes les colonnes sont pleine
gagnant(0) #Appelle la fonction gagnant pour mettre fin à la partie
Il y a aussi la fonction gravité qui va retourner la ligne la plus basse où le jeton peut aller :
def gravite(colonne): #Détermine la ligne où le jeton peut se placer
ligne = 5
while grille[ligne][colonne] != 0: #parcours la colonne de haut en bas jusqu'à trouver la ligne vide la plus basse
if ligne == 0 :
return ligne
ligne -= 1
return ligne
Une autre des fonctions principales : affichage_grille permet comme son nom l’indique d’afficher la grille entière :
def affichage_grille():
rect(75, 42, 175, 150, (255,255,255))
pos_x, pos_y_base, marge = 50, 42, 25
for i in range(7):
pos_x += marge
pos_y = pos_y_base
for y in range(6):
cote = 20
if grille[y][i] == 1:
color = rouge
elif grille[y][i] == 2:
color = jaune
else :
color = gris
if grille[y][i] == 1 or grille[y][i] == 2:
rect(pos_x, pos_y, cote, cote, gris)
draw_cercle(pos_x + 7, pos_y + 2,color)
else:
rect(pos_x, pos_y, cote, cote, gris)
pos_y += marge
La fonction efface une possible grille avec un rectange blanc de la même taille que la grille puis réaffiche la grille
Voici ce que produit la fonction :
Ensuite il y a affichage_preview qui va afficher le preview du jeton au bon endroit :
def affichage_preview(col_preview):
rect(75, 17, 170, 20, (255,255,255)) #Efface l'ancien preview
if player == 1 : #Choisi la bonne couleur
color = rouge
else :
color = jaune
draw_cercle(75 + (col_preview * 25) + 7, 17+2, color) #Fait le preview au bon endroit
Il y a la fonction wait qui retourne la touche sur laquelle vous appuyez :
def wait(buttons=(0,1,2,3,4,52)): #Retourne la touche appuyée
while True:
for i in buttons:
if keydown(i):
while keydown(i): True
return i
Et enfin les deux dernières fonctions qui sont liées : les fonctions du score, il y a la fonction affichage_src qui est appelé au début du jeu afin d’afficher le score :
#Score par Thomas S. mais code par Robin C.
def affichage_src():
txt("J-1", 22, 42)
draw_cercle(35,70,rouge)
txt("Score", 12, 117)
if points_rouge < 10 :
largeur = 32
else :
largeur = 27
txt(str(points_rouge),32,142)
txt("J-2", 267, 42)
draw_cercle(280,70,jaune)
txt("Score", 257, 117)
if points_jaune < 10 :
largeur = 277
else :
largeur = 272
txt(str(points_jaune),277,142)
def actu_src(): #Actualise le score
txt(str(points_rouge),37-5*len(str(points_rouge)),142)
txt(str(points_jaune),282-5*len(str(points_jaune)),142)
Et il y a aussi la fonction actu_src qui va à chaque fin de partie, actualiser le score en écrasant l’ancien score.
Voici ce que produit la fonction affichage_src() seule :
Et pour finir il y a le lancement du jeu à la fin avec juste avant le code qui permet d’afficher le lien en bas de l’écran :
#Lien article
rect(0,200,320,22,(148,113,222))
txt("Code by nsi.xyz/puissance4",33,202,(242,)*3,(148,113,222))
#lancement du jeu
affichage_src()
selection()
Images du jeu
Conclusion
Pour conclure le tout, ce projet a été très plaisant à faire et très instructif. Il faut savoir que faire un jeu sur la NumWorks comme le mien demande du travail notamment sur la prise en main de la partie graphique qui n’a pas été sans problèmes pour moi mais avec les entrainements de M.Robert sur twitter la prise en main fut plus simple.
Lien du jeu
Il existe deux liens pour le jeu, sachez que seul le premier garanti de disposer de la dernière version et que le deuxième est un lien alternatif qui peut être dépassé.
Un jeu de société existant sous l’ombre des dames et des échecs, il est temps de rendre justice ! Le Reversi est un jeu de société pour deux joueurs qui se joue sur un plateau de 64 cases. Les joueurs placent tour à tour des pions noirs ou blancs sur le plateau, en capturant les pions adverses et en retournant les pions de l’adversaire pour gagner le contrôle du plateau.
À la découverte d’un nouveau jeu !
« – Alors qu’avons-nous là… Un Tetris ? Déjà fait et étonnement, pas le niveau. Un 2048 ? 😤 Une bataille navale ? Oula, pas certain de ce coup. Bon alors, quel jeu faire sur la NumWorks qui n’est pas trop dur à réaliser, mais reste néanmoins intéressant ? – « Le Reversi » ? – À vos souhaits. – Tu n’as pas la lumière à tous les étages toi… C’est un jeu de société également appelé Othello. Voici plus de détails concernant les règles. – D’accord, je vois le style, et bien allez, c’est parti ! »
Maintenant, il faut l’arranger pour notre jeu. Pour commencer, on s’occupe de placer une grille au centre de l’écran, ce sera notre plateau de jeu.
Elle n’est pas au centre ? Achetez-vous des lunettes… Et en plus, on me dit dans l’oreillette que les couleurs ne sont pas bonnes ? La couleur ? Vous n’êtes jamais content. Et là ? On est bon ? Aaah enfin
[...]
def grille(x, y, t_x, t_y, c, col):
for w in range(t_x):
for h in range(t_y):
rec(1+x+w*(c+2), 1+y+h*(c+2), c, c, col)
La fonction est assez simple, elle va simplement faire un nombre de petits carrés indiqués en paramètres. t_x pour la taille en horizontale et t_y pour la taille en vertical (il faut indiquer un nombre de carrés pour les 2 variables).
Ce n’est pas fini ! Même pas du tout 😥
On va s’occuper du système pour gérer les déplacements sur la grille en se basant sur ce qu’a proposé le prof dans son exemple. Avant ça, nous allons définir un paquet de variables qui nous serons utiles tout le long du code (et encore, cette liste n’est pas exhaustive) :
# Beaucoup... BEAUCOUP de couleurs...
col = ((100,203,111),(220,)*3,(60,)*3,(148,113,222),
(242,0,0),(255,183,52),(255,)*3,(60,139,72),
(90,)*3,(180,)*3,(160,)*3,(242,)*3)
# Différents paramètres, à commencer par la taille horizontale et verticale
# de notre grille (ce sont les var pour t_x et t_y)
len_x,len_y = 8,8
# On l'utilisera plus tard, ce sera la position par défaut du sélectionneur de case
pos = [2,3]
# la taille des carrés dans la grille, en pixel
c = 20
# De sombres calcul... Pour centrer la grille !
x_g = (320 - (1+len_x*(c+2))) // 2
y_g = (200 - (1+len_y*(c+2))) // 2
# Très important ! C'est notre grille, chaque valeur d'une case est renseignée dans cette matrice
g = [[0 for i in range(len_x)] for i in range(len_y)]
# Gestion des tours, des scores,
# et des tours où un joueur ne peut pas jouer (allez check les règles pour comprendre ça)
player_turn,sc_noir,sc_blanc,no_round = 2,0,0,0
Une partie de ces variables se situent dans une fonction init() qui permet de relancer une nouvelle partie lorsque la précédente est terminée et de gérer le système de paramètres (nous le verrons plus tard). Une grosse fonction play() s’occupe de vérifier les actions du joueur, c’est-à-dire les déplacements, s’il place un pion, etc.
Ce code permet de gérer les déplacements sur toutes la grille et permet lorsque l’on appuie sur la touche Ok ou EXE, de valider notre sélection et d’exécuter une fonction action() qui s’occupe de lancer différentes fonctions selon certaines conditions pour vérifier le placement du pion puis le placer ou non.
Revenons sur nos déplacements. Avant toute chose, nous allons créer deux fonctions bien pratiques : getCase() et setCase(). Comme leur nom l’indique, l’une nous renvoie des informations concernant une case, l’autre change la valeur d’une case. « Récupérer » des informations ou « changer » la valeur d’une case, c’est modifier/récupérer une valeur dans notre matrice.
def getCase(g_in, x, y, col_mode=False):
if col_mode:
if 0 <= g_in[y][x] <= 2:
return col[g_in[y][x]]
return None
return -1 if x < 0 or x >= len_x or y < 0 or y >= len_y else g_in[y][x]
def setCase(g_in_in, x, y, value):
g_in_in[y][x] = value
On peut voir que getCase(), en plus de pouvoir nous renvoyer un statut pour la case sélectionnée (-1 si non valide, 0 si vide, 1 si blanc et 2 si noir), peut également nous renvoyer la couleur de la case. setCase() est plus simpliste mais tout aussi importante. Voici notre fonction deplacement() :
def deplacement(pos_old=[],for_error=False):
global c
if not(for_error):
if pos_old != []:
x, y = pos_old
if getCase(g,x,y) in (1,2):
rec(x_g+1+x*(c+2),y_g+1+y*(c+2),c,c,col[0])
cercle(x_g+8+(c+2)*x,y_g+3+(c+2)*y,getCase(g,x,y,True))
else:
rec(x_g+1+x*(c+2),y_g+1+y*(c+2),c,c,getCase(g,x,y,True))
x, y = pos
rec(x_g+1+x*(c+2),y_g+1+y*(c+2),c,c,col[7])
cercle(x_g+8+(c+2)*x,y_g+3+(c+2)*y,col[1] if player_turn == 1 else col[2],1)
case = getCase(g,x,y)
if case != 0:
cercle(x_g+8+(c+2)*x,y_g+3+(c+2)*y,getCase(g,x,y,True))
else:
rec(x_g + 1 + pos[0]*(c+2),y_g + 1 + pos[1]*(c+2), c, c, col[4])
sleep(0.1542)
Cette fonction s’occupe de rendre le déplacement naturel et fluide. En effet, si l’on est à une case de coordonnée (1;1) et que l’on décide d’aller en (2;1), il faut que l’on affiche une surbrillance de sélection sur la nouvelle case, et que l’on rende à l’ancienne case son apparence d’origine. C’est très vulgarisé, car en plus de ça, ce code gère un affichage différents si le placement est incorrect, ainsi qu’une surbrillance différentes si on le joueur décide de se déplacer sur une case avec déjà un pion de placé.
On remarque une fonction cercle(). Elle a été proposé par le professeur, qui est chaleureusement remercié, car les pions, au lieu de ressembler à ça…
Petit faux raccord sur la couleur de la grille. Vous voyez également une des premières versions du sélectionneur, qui depuis a été bien amélioré.
…ressemblent plutôt à ça :
def cercle(x,y,col,s=0):
for d in range(6):
rec(x-d+(d==0)+2*s,y+d+(d==5)+2*s,6+2*d-2*(d==0)-4*s,16-2*d-2*(d==5)-4*s, col)
Que d’aventure… Nous avons maintenant un système de déplacement performant. Il faut maintenant s’attaquer à la logique du programme. On est à 21,73 % d’avoir fini le jeu !
Logique du jeux & IA
La partie la plus complexe. Je remercie mon père qui m’a beaucoup aidé pour cette fonction cœur de mon jeu. Cette fonction a deux modes de fonctionnement, elle peut vérifier si un pion peut être placé ; et placer un pion.
def do_pion(mode,pion_x,pion_y,directions_in,ai_ask=False):
if getCase(g,pion_x,pion_y) != 0:
return False
result = []
if ai_ask:
dist_totale = []
global sc_noir,sc_blanc
pion_adverse = 1 if player_turn == 2 else 2
for d in directions_in:
x,y,dir_x,dir_y = pion_x,pion_y,d[0],d[1]
current = getCase(g, x + dir_x, y + dir_y)
dist_parcourue = 1
while pion_adverse == current:
x,y = x+dir_x,y+dir_y
if mode == 1:
sc_blanc += 1-2*(player_turn!=1)
sc_noir += 1-2*(player_turn!=2)
setCase(g, x, y, player_turn)
current = getCase(g, x + dir_x, y + dir_y)
dist_parcourue += 1
if mode == 0 and dist_parcourue > 1 and current == player_turn:
if not(ai_ask):
result.append(d)
else:
dist_totale.append(dist_parcourue)
result.append(d)
else:
continue
if mode == 1:
if player_turn == 1:
sc_blanc += 1
else:
sc_noir += 1
setCase(g,pion_x,pion_y,player_turn)
else:
if ai_ask:
result.append(sum(dist_totale))
return result
Lorsqu’elle vérifie si un pion peut être placé, elle va vérifier dans les 8 directions si la situation permet un retournement de pions adverses. Si c’est le cas, elle stocke la direction, et continue. À la fin, elle renvoie une liste contenant toutes les directions valides. S’il y a au moins une direction valide, la fonction est réexécutée, mais cette fois-ci, elle changera les valeurs dans la matrice en appliquant les règles de retournement. La fonction qui appelle do_pion() et qui analyse le résultat de la première exécution de celle-ci, c’est la fonction action() :
def action(position):
global player_turn
result = do_pion(0,position[0],position[1],directions)
if result != [] and result != False:
do_pion(1,position[0],position[1],result)
player_turn = 1 if player_turn == 2 else 2
update() # Nous verrons cette fonction un peu plus tard.
else:
deplacement(for_error=True)
La fonction do_pion() s’occupe toute seule d’appliquer quasiment toutes les règles du Reversi, elle s’occupe même de mettre à jour le score. Cependant, il y a une règle dans le Reversi qui stipule qu’un joueur ne peut pas jouer si il n’a aucun « mouvement légal », c’est-à-dire qu’il n’a aucun placement possible sur le plateau (fun fact : ce plateau est appelé othellier) qui respecte les règles du jeu. Si c’est le cas, son tour est passé. C’est le job de la fonction has_legit_hit() :
def has_legal_hit():
legal_hits = []
for y in range(len_y):
for x in range(len_x):
if do_pion(0,x,y,directions):
legal_hits.append([x,y])
return legal_hits
Plus précisément, elle vérifie seulement. C’est la fonction play() qui s’occupe de passer le tour du joueur :
def play():
[...]
if has_legal_hit() == []:
player_turn = 1 if player_turn == 2 else 2
no_round += 1
if no_round == 2:
affichage() # Nous verrons cette fonction un peu plus tard.
break
affichage() # bis
continue
else:
no_round = 0
[...]
Ce petit bout de code s’occupe également d’arrêter la partie, car si les deux joueurs ont dû passer leur tour l’un après l’autre, c’est qu’aucune des deux ne pourra rejouer.
Alors, en effet, si vous êtes au fond de la classe – je ne suis responsable de rien – vous pouvez jouer avec votre voisin, mais si vous êtes devant ? Et bien oui, il faut penser à tout le monde.
Notre IA va utiliser tous les composants décris précédemment. La seule action qu’elle va faire d’elle-même est de choisir une case valide. Dans la version actuelle (1.2.1), l’IA a deux niveaux : un où elle choisit parmi toutes les cases valides une case aléatoirement, et un autre où elle choisit la case qui lui rapporte le plus de point. Si vous avez bien été observateur, certaines fonctions telles que do_pion() avaient une partie qui était réservée pour une utilisation par l’IA. C’est dans do_pion() qu’est calculé quel est la case qui rapportera le plus de point. Voici le code de la fonction ai() :
def ai(lvl):
if lvl == 0:
return choice(has_legal_hit())
elif lvl == 1:
legal_hits = has_legal_hit()
temp = []
plus_grand = [[],0]
for i in range(len(legal_hits)):
legal_hits[i] = [legal_hits[i],do_pion(0,legal_hits[i][0],legal_hits[i][1],directions,True)]
for i in legal_hits:
if i[1][-1] > plus_grand[1]:
plus_grand = [[i[0]],i[1][-1]]
elif i[1][-1] == plus_grand[1]:
plus_grand[0].append(i[0])
return choice(plus_grand[0])
Je suis sûr que vous ne savez pas quelque chose… Mais on est à 73,21 % du jeu là ! On y est presque !
Interface graphique, mise à jour de la grille, Game Over & système de paramètres
On y est presque et pourtant… Ce n’est pas encore fini 😵
C’est bien beau de faire des retournements et tout, mais moi ma grille est toujours vide sur mon écran !
Mettons en place une fonction update() qui va s’occuper de mettre à jour graphiquement la grille.
def update():
global c
for y in range(len_y):
for x in range(len_x):
if getCase(g,x,y) in (1,2):
rec(x_g+1+x*(c+2), y_g+1+y*(c+2), c, c, col[0])
cercle(x_g+8+(c+2)*x, y_g+3+(c+2)*y, getCase(g, x, y, True))
# Ce else pourrait être facultatif et ferait une belle optimisation
# si le code d'autres fonctions était adapté.
# Il est ici depuis très longtemps et s'est fait oublié xD
else:
rec(x_g+1+x*(c+2), y_g+1+y*(c+2), c, c, getCase(g, x, y, True))
deplacement()
Elle n’est pas très compliquée à comprendre. Je parcours toute la grille, je récupère la valeur de chaque case et je mets à jour ce qui doit apparaître (s’il doit y avoir un pion ou pas, et la couleur du pion).
Ensuite, le visuel est un peu pauvre, comme ceci sera bien mieux :
Il y a vraiment des délires sombres avec les couleurs…
Je remercie le professeur qui m’a aiguillé pour la conception de l’interface (après attention, il m’a juste suggéré d’aligner les informations avec des cases de la grille, ça va il a pas tout fait non plus 😂).
On ajoute un système permettant d’utiliser l’interface en début de partie pour paramétrer si on veut jouer en mode multijoueur ou contre IA, et le niveau de difficulté de l’IA :
Et un Game Over :
C’est M. ROBERT qui a joué cette partie, il est trop mauvais (🤪).
EDIT : Normalement je ne modifie pas les articles des élèves, mais je me dois de nier l’affirmation précédente qui porte atteinte à mon honneur. 😉
On assemble les pièces de puzzles correctement, et… Attendez, je crois que ça y est ! On a terminé ! Le jeu est fini à 100,42 % 😁
Projets
