Author: Thomas Q.

Tutoriels

Extensions utiles pour l’utilisation de chrome

De nombreuses extensions peuvent nous faciliter la vie, mais on ne les connait pas forcément. Ce tutoriel propose donc des extensions qui vous seront utiles dans diverses tâches comme par exemple le travail tout en vous expliquant comment les installer et comment les utiliser à bon escient.

Pourquoi utiliser des extensions ?

Il y a plusieurs raisons d’utiliser des extensions:

  1. Améliorer son écriture: des extensions telles que Grammarly qui améliore la qualité de l’écriture en temps réel, que ce soit dans les e-mails, les messages sur les réseaux sociaux, ou la rédaction en ligne.
  2. Mieux gérer ses onglets : certaines extensions permettent une meilleure organisation des onglets et de même de suspendre automatiquement ceux qui ne sont pas utilisés.
  3. Personnaliser son navigateur: en utilisant des extensions, vous pouvez accéder à de nouvelles fonctionnalités (Exemple : télécharger en un clic une vidéo trouvée sur Twitter).
  4. Optimisation de la Productivité: les extensions offrent des outils dédiés à l’efficacité, comme des gestionnaires de tâches, des rappels, et des fonctionnalités de bloc-notes intégrées, pour maximiser la productivité.

Une extension pour ne plus jamais faire de fautes d’orthographe


L’une des extensions les plus populaires et efficaces pour éviter les fautes d’orthographe est Languagetool.

En bref, c’est un outil qui fonctionne automatiquement en arrière-plan. Il soulignera les erreurs d’ orthographes (en jaune) et grammaticales et vous fournira des suggestions pour les corriger.

Pour cela, il faudra cliquer juste ici.

Une fois l’extension installée, LanguageTool fonctionnera automatiquement en arrière-plan, soulignant les erreurs d’orthographe et de grammaire et fournissant des suggestions de correction.

Et voilà, maintenant votre orthographe est corrigée et vous êtes intelligents ! 😁

À noter : l’efficacité de cette extension peut varier en fonction de la complexité des erreurs grammaticales et de la spécificité linguistique de chaque langue. Il peut être utile d’essayer différentes extensions pour trouver celle qui correspond le mieux à vos besoins et à votre style d’écriture.

Une extension pour mieux gérer ses onglets

La gestion des onglets dans le navigateur peut rapidement devenir chaotique, ce qui peut entrainer une perte de productivité et une expérience de navigation « désorganisée ».

C’est pour cela que je vous présente TabMaster qui résout ce problème en offrant les avantages suivants :

  • Sauvegarde et reprises rapides : Avec la possibilité d’enregistrer des sessions d’onglets, TabMaster permet aux utilisateurs de reprendre rapidement leur travail là où ils l’ont laissé.

Voici ce qu’on obtient, par exemple comme fonctionnalité, en faisant Ctrl + K :

  • Économie de ressources : Cette extension peut vous permettre de fermer automatiquement les onglets inactifs, ainsi TabMaster optimise les performances du navigateur en libérant de la mémoire.

Il y a aussi une liste de commandes utiles pour bien utiliser l’extension :

Vous pouvez donc aller ajouter l’extension ici.

Des extensions pour améliorer votre expérience navigateur

  • Une extension pour disposer toujours du dark mode

Vous en avez marre des sites web qui utilisent des fonds blancs lorsque vous naviguez sur internet la nuit ?

L’extension Dark Reader propose un mode sombre (ou « dark mode ») pour les sites web en inversant les couleurs des sites web, remplaçant les fonds blancs par des fonds noirs ou sombres, et les textes noirs par des textes blancs ou de couleurs sombres.

Voici un avant/après usage de l’extension :

Bien sûr, l’option est activable/désactivable. Et cette extension est aussi intéressante pour d’autres points : vous pouvez gérer la luminosité actuelle, mais aussi le contraste, ce qui peut être utile ! 😁

Comme le montre ici ce screen :

L’extension juste ici. D’autres options non citées ici sont aussi fournies grâce à cette extension.

  • Une extension pour personnaliser son navigateur

Il est intéressant de personnaliser son navigateur à ses gouts, c’est que propose l’extension Stylish.

Stylish est une extension polyvalente qui vous permet de personnaliser l’apparence des sites web que vous visitez. Que vous souhaitiez ajuster les couleurs, les polices de caractères, ou même la disposition d’un site, Stylish offre une grande flexibilité pour créer une expérience de navigation qui vous convient.

Prenons un exemple : vous êtes fan du jeu Hollow Knight et vous voulez personnaliser votre navigateur en fonction de votre jeu favori qu’est Hollow Knight, ainsi Stylish vous permet d’avoir un thème Hollow Knight pour regarder des videos Youtube (comme on le voit sur le screen).

Vous pouvez retrouver l’extension juste ici.

Pour conclure, vous pouvez trouver plus d’extensions quelles qu’elles soient juste ici.

Projets

Jeux de Calcul Mental chronométré en python

Êtes-vous bon en calcul mental ? Ce script en python vous propose de tester vos capacités à travers différents niveaux de difficulté, et tout cela chronométré !

Objectif

L’objectif de ce projet est de tester mes capacités en python et de mobiliser les notions vues en python en spécialité NSI (and, or, not, …etc). De plus, cela à pour but de proposer un outil pour s’entraîner au calcul mental. Je pense aussi l’adapter plus tard pour la calculatrice Numworks, ce qui donnera la possibilité d’y jouer dessus.

Projet

Le choix du langage pour ce projet est assez simple : python. C’est un langage assez simple à maitriser et adapté pour l’idée de mon jeux. Il propose aussi des bibliothèques assez intéressantes pour sa réalisation notamment time et random.

Analyse du code

Analysons le code.

Dans un premier temps on importe différentes bibliothèques qui vont nous être utilise. Nous utilisons la bibliothèque random pour générer des valeurs aléatoires pour diversifier les calculs ainsi que le module time.

import math
from random import *
from time import time
from art import text2art

operateurs1 = ["+","-"]
operateurs2 = ["+","-","x"]])

Subséquemment, vous pouvez aussi voir une bibliothèque art avec le module text2art qui nous sert à convertir du texte en ascii art et donc à sublimer par exemple le menu.

La première liste sert uniquement au niveau 1 qui est censé être le plus simple, on se limite donc à des additions/soustractions tandis que la deuxième liste est destinée au niveaux 2 et 3.

Passons maintenant au menu.

def menu(): # Interface du début
    titre1 = text2art("NSI : Calcul \t mental") # Titre en ascii art
    print(titre1)
    
    print("Il y a 3 niveaux:") # Présente les différents niveaux 
    print("1-Niveau facile")
    print("2-Niveau intermédiaire") 
    print("3-Niveau difficile")
    
    choix = int(input("\nAlors, qu'allez vous choisir :\n"))
    
    while choix not in [1, 2, 3]:  # Empêche toutes valeurs autre que 1, 2 ou 3
        input("Veuillez choisir un chiffre :\n")
    
    if choix == 1: # Renvoie au niveau choisie
        niveau1()
        
    if choix == 2:
        niveau2()
        
    if choix == 3:
        niveau3()

menu()

On commence par présenter les différents niveaux avec des print() et aussi un titre en ascii art grâce au module text2art(). Vous allez voir que tout au long du code que nous allons utiliser des input() qui permettent à l’utilisateur de rentrer des valeurs ou une chaîne de caractère.

Ici, la boucle à la ligne 12 est nécessaire pour que l’utilisateur entre quelque chose de valable, la logique est simple : tant que qu’il n’a pas rentrer une valeur valable on réitère la question et dès lors qu’il tapera 1,2 ou 3 le script pourra continuer.

Enfin, on ajoute des conditions avec if pour le rediriger le joueur sur le niveau choisi. Passons maintenant à la structure d’un niveau.

def niveau2(): # Deuxième niveau
    score = 0
    compteur =  0
    while compteur < 10:
        indice_aleatoire = randint(0,len(operateurs1)-1)
        generation1 = randint(2,4)
        generation2 = randint(11,42)
        generation3 = randint(300,600)
        generation4 = randint(384,666)  # Plus de génération car on ajoute des multiplications
        
        if indice_aleatoire == 2:
            print("\nPeux tu calculer", str(generation1), operateurs1[indice_aleatoire], str(generation2), "? Tu as 7 secondes.")
        else:
            print("\nPeux tu calculer", str(generation4), operateurs1[indice_aleatoire], str(generation3), "? Tu as 7 secondes.")
        
        depart_temps = time() # Calcule le temps
        rep = int(input("\nMa réponse : "))
        
        fin_temps = time()-depart_temps

Nous allons ici prendre pour exemple le niveau 2 (intermédiaire), mais les autres niveaux ne sont pas si différents que ça. On va diviser le niveau en 3 parties :

  • La génération du calcul et la réponse de l’utilisateur
  • La correction de la réponse
  • Félicite le joueur en fonction de son score

Dans un premier temps, on commence par initialiser le score et le compteur qui correspond au nombre de question, donc ici 12 questions. Le compteur s’incrémente à chaque fin de question d’où l’utilisation de while.

On génère ensuite un indice aléatoire pour choisir entre tous les opérateurs et des nombres pour les calculs. Si cela tombe sur une multiplication on va multiplier des nombres par des petites valeurs (entre 2 et 4), sinon on fait l’addition ou soustraction de deux nombres entre environ 300 à 600.

Enfin, on lance le chrono avec le module time(), on demande alors la réponse et on arrête le chrono pour savoir le temps passé.

if operateurs2[indice_aleatoire] == "+": # Détermine l'opérateur pour la correction
    resultat = generation4 + generation3
elif operateurs2[indice_aleatoire] == "-":
    resultat = generation4 - generation3
elif operateurs2[indice_aleatoire] == "x":
    resultat = generation1 * generation2
else:
    resultat = None
        
if resultat is not None and resultat == rep and fin_temps <=7: # Correction en fonction du résultat et du temps mis
    print("Bravo, tu as donné la bonne réponse dans le temps imparti. Ton temps:", fin_temps)
    score += 1
elif resultat is not None and resultat == rep and fin_temps > 7:
    print("Tu as donné la bonne réponse mais pas dans le temps imparti. Ton temps:", fin_temps)
            
else:
    print("\nAh...apparemment tu t'es trompé, réessaye !")
    
suite = input("\nPrêt pout ma suite ? o/n\n")  # Demande si l'utilisateur est prêt
if suite.lower() != "o":
    break
compteur += 1

Dans un deuxième temps, on détermine l’opérateur pour effectuer la correction avec la réponse de l’utilisateur. Il y a 3 cas possibles :

  • La réponse est correcte et a été donnée dans le temps imparti (dans ce cas la le score s’incrémente)
  • La réponse est correcte mais n’a pas été donnée dans le temps imparti
  • La réponse est incorrecte et n’a pas été donnée dans le temps imparti

Ensuite, on demande si l’utilisateur est prêt pour passer à la suite. Ici, on utilise la méthode .lower() qui permet d’éviter que le script plante si l’utilisateur a mis un « o » ou un « n » en majuscule.

Puis on incrémente le compteur comme nous l’avons expliqué précédemment.

if score > 4:
    print("\nBravo tu as répondu à tous les calculs et tu a au moins la moyenne, ton  score est de", score) # Donne le score et félicite le joueur
    gg = text2art("gg")
    print(gg)
else:
    print("\nTon score est de", score,", ce n'est pas fameux ! Je te conseille d'acheter ma formation pour seulemment 773€/mois") # Peut être que je vais la prendre cette formation finalement

Dans un troisième temps, à la fin de toutes les questions, on obtient plusieurs grades de félicitation en fonction du score du joueur.

On retrouve aussi l’utilisation tu module text2art() qui permet de dire bien joué.

Conclusion

Le projet était assez plaisant à faire et il a permis de tester mes capacités en python tout en mobilisant des notions vues en spé NSI notamment not, and, or, les boucles, …etc. Ce script peut aussi être adapté sur la numworks dans l’avenir, ce qui peut être sympa.

Télécharger le script

Tutoriels

Comment Installer Optifine avec des shaders et des textures…

Vous venez de débuter Minecraft et vous commencez à comprendre que creuser sous ses pieds, dans ce jeu, est peut être une mauvaise idée. Nous allons non pas vous présenter un tutoriel sur comment jouer à Minecraft mais bien un tutoriel qui va vous permettre de sublimer et d’améliorer votre expérience de jeux grâce à l’installation d’optifine avec des shaders et des textures packs.

Quel est l’intérêt et qu’est ce que c’est ?

Comme nous l’avons déjà dis, cela va permettre d’améliorer votre expérience de jeu en sublimant les graphismes. Si vous êtes ici c’est que l’univers de Minecraft vous intéresse. En tant que joueur de Minecraft depuis maintenant de nombreuses années, je fais moi même l’usage de packs de textures et de shaders dans mes aventures ou encore même pour combattre contre d’autres joueurs en ligne (appelé « PvP »), c’est pourquoi je vais vous conseiller des packs de textures et des shaders et vous montrer comment se passe l’installation de ces derniers.

Les shaders sont des programmes qui modifient les pixels qui s’affichent, ce qui va donner un meilleur rendu du jeu. Comme moi, l’apparence des textures (blocs, objets, créatures et autres) peut vous lasser, on installe donc un pack de texture qui va venir changer ces apparences.

Aperçu des shaders :

Voici un exemple de ce que donne l’application des quelques étapes qui suivent pour installer des shaders :

Sans shaders VS Avec Shaders

Passons maintenant à l’installation.


Installation Optifine

a) Prérequis

On choisis ici la version 1.8.9 pour le tutoriel, le processus reste le même pour une autre version mais il faudra télécharger les logiciels suivants pour la version souhaitée.

Tout d’abord, pour le bon déroulement de l’installation, il y a certains prérequis :

b) Installation

Vous avez maintenant tous les outils pour installer Optifine. Passons donc à son installation :

Rendez vous sur ce lien pour télécharger Optifine 1.8.9.

Après l’avoir télécharger, vous pouvez le lancer et vous arrivez sur cette fenêtre :

Vous devez tous simplement cliquez sur « Install ».

Shaders

Vous possédez maintenant Optifine qui est enfaite nécéssaire pour l’installation de shaders. Maintenant il va falloir choisir des shaders parmi des centaines qui se trouvent sur le net, c’est pour cela que je vais vous faire 3 suggestions qui sont, à mon sens, des très bons shaders.

a) Suggestions de shaders

  • BSL Shaders : shaders avec de l’eau peu mouvementée accompagnée d’un léger brouillard assez sympathique. Ce pack a aussi une très beau couché de soleil ce qui donne une bonne ambiance.
Sans shaders VS Avec BSL shaders

  • Complementary shaders : shaders lumineux, assez simples mais qui restent néanmoins très beaux. Si vous ne savez pas quoi choisir, ces shaders sont une bonne option ils conviennent généralement à la plupart des gens.
Sans shaders VS Avec complementary shaders

  • Sildur’s Vibrant : d’après moi les plus beaux shaders de Minecraft. C’est une pack qui fait sa force grâce à son couché de soleil compétitif et de très beaux reflets sur l’eau. L’apparence de nuit est aussi très sympathique.
Sans shaders VS Avec BSL shaders

b) Installation des shaders

Vous avez sûrement choisi des shaders parmi les suggestions ci-dessus, passons maintenant à l’installation de ces derniers pour qu’ils soient fonctionnels en jeu. Pour cela on prendra comme exemple les shaders Sildur’s Vibrant.

Tout d’abord, après avoir installé les shaders de votre choix, il va falloir saisir le raccourci Windows+R puis écrire « %appdata% ».

Vous arrivez normalement sur des dossier. Il vous faudra juste cliquer sur le premier dossier nommé « .minecraft » puis le dossier « shaderpacks » : .minecraft > shaderpacks

Vous n’avez plus qu’à glisser le pack dans ce dossier et à lancer Minecraft. 😁

Packs de texures

Concentrons nous maintenant sur les packs de textures. En effet, tout bon joueur minecraft possède des pack de textures que ce soit pour de la survie ou encore pour du PvP (=combat contre d’autres joueurs en ligne).

Si vous êtes arrivé sur ce tutoriel c’est que vous n’avez surement pas de pack de texture et/ou vous cherchez la manière pour les installer. Je vais donc vous proposer quelques packs de textures pour la survie et pour le PvP et par la suite vous montrer le déroulement de l’installation.

a) Suggestions de packs de textures

Voici donc 3 packs de textures que je vous suggère :

  • Faithful : pack très similaire au pack de texture de base de Minecraft mais qui améliore les graphismes. Un très bon choix pour ne pas se retrouver dépayser surtout si vous vous axez sur la survie, je vous le conseille donc fortement.
  • Amaranth : ce pack s’axe principalement sur le PvP. Il offre un style épuré et des graphiques sympathiques. J’utilise personnellement ce pack depuis maintenant quelques temps et il passe très bien.
  • Red Killua x32 Revamp : pack qui s’axe principalement sur le PvP mais peut aussi convenir pour la survie si ce style vous plaît. En revanche, les graphiques sont assez simples, ce qui explique ce côté épuré qu’on peut voir sur les blocs.

b) Installation des packs de textures

Contrairement au shaders, vous n’avez pas besoin d’Optifine pour avoir des pack de textures, ce qui vous laisse plus de liberté pour essayer les packs proposés !

Passons maintenant à l’installation :

Après avoir téléchargé l’un des packs, il faut saisir le même raccourci que pour les shaders : Windows+R et écrire « %appdata ». Aller dans .minecraft > ressourcepacks et glisser votre pack dans ce dossier.

Mise en place en jeu

Vous possédez maintenant tous les packs de textures et shaders installés, peut-être avez vous envie de les essayer, lancez donc votre jeu !

Je vais vous montrer comment les avoir en jeu directement, c’est enfaite assez simple :

Commençons par les packs de textures.

Etape 1 : accéder aux options comme l’affiche le screen ci-dessous.

Etape 2 : aller dans les packs de ressources.

Etape 3 : transférer le pack souhaité dans la colonne « Packs de ressources sélectionnés ».

La colonne a gauche « Packs de ressources disponibles » correspond enfaite au dossier « ressourcepacks », même si ils sont là, pour en utiliser un il faut simplement cliquer sur la flèche comme on le voit dans le screen ci-dessous.

Pour les shaders, rendez-vous dans encore une fois dans les options puis dans la section « Options graphiques ».

Etape 1 :

Etape 2 : aller dans la section « Shader… »

Etape 3 : vous pouvez enfin voir les packs que vous avez téléchargés. Pour appliquer un des shaders, vous avez tout simplement à cliquer dessus, il se chargera (ce qui peut bugger parfois) et vous en avez terminé.

Conclusion

Voila, maintenant vous savez comment installer des shaders et des packs de texures. N’hésitez pas à en tester pleins pour trouver le style qui vous convient dans l’optique d’améliorer votre expérience de jeu !

Art

Perspective : un paysage Synthwave

Dans le cadre de la 5ème édition du dispositif “Regards de Géomètre”, nous avons décidé dans le thème « Perspective » de produire un paysage synthwave.

Vidéo du projet

Origines de la Synthwave

Avant tout la synthwave est un genre musical électronique ayant émergé dans les années 2000/2010 qui s’inspire d’éléments des années 80. Et c’est justement dans les clips de ces musiques que l’on va retrouver ce type d’image.

Pour en savoir plus nous vous conseillons cette vidéo qui explique brièvement les origines.

Le Projet

Revenons donc au projet. Pour ce projet nous avons donc décidé de produire une image d’un paysage synthwave. Pour cela nous utilisons le module turtle ainsi que le module random, le module turtle est utilisé pour produire l’image est le module random est utilisé pour les étoiles de l’image où la taille et leur position est générée aléatoirement nous avons également utilisé le script permettant d’exporter une image générée par turtle en .png que vous pouvez retrouver ici.

Structure du script

Pour la structure du script nous avons décidé de découper chaque partie de l’image (pavage, fond, étoiles, soleil, ville et montagnes) afin de créer des fonctions et à la fin nous les avons toutes appelées dans un ordre précis pour que les différentes parties de l’image soit dans leur plan respectif.

Analyse du script

Nous allons donc analyser le script.

Commençons par l’appel des modules et la mise en place de turtle.

from turtle import *
from random import randint
# vérification des modules importés
try:
    from PIL import Image
    pillow_installed = True
except:
    print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
    print("https://nsi.xyz/py2png")
    pillow_installed = False
titre = "Perspective - Un paysage Synthwave"
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")
setup(1280, 720) # définit la taille de la fenêtre
colormode(255) # permet l'utilisation de couleurs rgb
speed(0) #Remplaçable par tracer(2) (10x plus rapide) mais si il est utilisé des lignes du pavage peuvent manquer
hideturtle() #dissimule la tortue

On appelle les fonctions turtle, random avec pour random uniquement randint et on utilise une partie du script « exporter une image générée par turtle » pour vérifier que l’utilisateur a bien installé le module PIL et dans le cas contraire un message d’erreur s’affichera et lui donnera un lien pour installer le module et tout ça sans que le script ne s’arrête. Après la vérification on met en place le titre de la fenêtre qui va affiché le rendu ainsi que sa taille. Enfin on définit le type de couleurs utilisées (R,G,B), la vitesse de la tortue, et on dissimule la tortue (c’est plus joli).

Commençons par la première fonction : le fond

def fond():
    penup()
    rciel = 0
    gciel = 0 
    bciel = 0
    hauteur = -360
    goto(-642,-358)
    pendown()
    while hauteur != 360:
        pencolor(round(239 + rciel), round(41 + gciel), round(209 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (-29/180)
        gciel += (2/45)
        bciel += (7/720)

Pour le fond on aurait pu utiliser une fonction qui crée un rectangle et qui le remplit avec fill_rect, cependant la couleur dans ce cas est uni ce qui ne nous intéresse pas. Nous avons donc produit un script qui fait un fond dégradé qui fait avancer la tortue sur une ligne d’un pixel de large et à la fin de cette ligne la tortue est envoyé grâce à un goto à la ligne d’après et qui ajoute la différence de chaque couleur (rouge,vert et bleu) entre la couleur de début du dégradé et la couleur de fin. Tout ceci est arrondi car turtle n’est pas compatible avec des arguments à virgule (pour la fonction pencolor en tout cas).

Par la suite la fonction qui produit les étoiles a été codée :

def etoile():
    for i in range(90):
        penup()
        goto(randint(-720,720), randint(0,360))
        pendown()
        pencolor(255, 255, 255)
        lcercle = randint(1,3)
        fillcolor('white')
        begin_fill()
        circle(lcercle)
        end_fill()

Pour les étoiles on définit aléatoirement leur position sur la moitié haute de l’image, on les met en blanc, on définit aussi aléatoirement la taille de l’étoile et on créer l’étoile avec sa position, et sa taille en aléatoire puis on refait ce processus 90 fois pour avoir 90 étoiles.

Ensuite nous avons le soleil (Le script affiché n’est qu’une petite partie du script total du soleil car il est très long et qu’il se répète, il est donc inutile de commenter la suite) :

def soleil():
    penup()
    liste1 = [10,7,5,4,3,3,3,3,2,2,2,2,2,2,2,1,2,1,2,1,1,2,1,1,1,1,2,1,1,1]
    liste2 = [1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]
    pliste1 = 0
    pliste2 = 0
    rsoleil = 0
    gsoleil = 0
    bsoleil = 0
    lsoleil = 8
    hauteur = 30
    goto(0,30)
    pendown()
    for i in range(15):
        pencolor(round(255 + rsoleil), round(23 + gsoleil), round(226 + bsoleil))
        forward(lsoleil)
        backward(2*lsoleil)
        hauteur += 1
        lsoleil += liste1[pliste1]
        pliste1 += 1
        goto(0, hauteur)
        rsoleil += (0)
        gsoleil += (114/101)
        bsoleil += (-203/202)
    forward(lsoleil)
    backward(2*lsoleil)
    penup()

Pour le soleil nous réutilisons le script du dégradé, cependant nous l’avons modifier pour que le point d’origine de la tortue soit au centre du rectangle et que la longueur de chaque ligne soit défini par une liste (ce qui permet de faire un cercle en prenant les longueur d’un cercle utilisable en pixel art). Pour ce qui est des endroits ou le soleil est coupé la tortue fait le tracé mais on a utilisé la fonction penup() qui fait que la tortue ne dessine plus.

Après nous avons la fonctions des montagnes (Encore une fois le script n’est pas complet car il se répète encore 3 fois après.) :

def montagne():
    #montagne derrière la première
    penup()
    goto(-480,0)
    fillcolor(110, 27, 188)
    begin_fill()
    for i in range(3):
        forward(250)
        left(120)
    end_fill()
    
    goto(-480,0)
    pencolor(51, 210, 246)
    ymontagne = 10
    for i in range(11):
        pendown()
        goto(-355,ymontagne)
        goto(-230,0)
        penup()
        goto(-480,0)
        ymontagne += 20

Pour le script des montagnes nous avons utilisé le script pour faire des triangles équilatéraux retrouvable ici. Et ensuite nous avons utilisé un ‘for i in range’ pour faire des goto enchaîné pour faire les lignes des montagnes.

Ensuite nous avons les fonctions de la ville. Pourquoi les fonctions car il y a une fonction pour chaque bâtiment différent ainsi qu’une fonction finale qui définit l’ordre des bâtiments.

def bat1():
    penup()
    rbat = 0
    gbat = 0 
    bbat = 0
    hauteur = 0
    pendown()
    xturtle, yturtle = pos()
    while hauteur != 72:
        pencolor(round(125 + rbat), round(35 + gbat), round(216 + bbat))
        forward(42)
        hauteur += 1
        goto(xturtle, hauteur)
        rbat += (-5/3)
        gbat += (-7/15)
        bbat += (-72/25)
    forward(42)
    penup()
    right(90)
    forward(72)
    left(90)

Pour le bâtiment 1 il y a un dégradé (toujours le même script) puis on fait que la tortue finisse le bâtiment en bas à droite de ce dernier pour pouvoir enchainer les bâtiments.

fun fact : Au début nous n’avions pas prévu les quelques lignes à la fin pour que la tortue puisse enchaîner les bâtiments sans que les fonctions des bâtiments aient besoin d’être modifiés ce qui nous a amené à avoir tous les bâtiments qui se chevauchaient.

def ville():
    penup()
    goto(-320,0)
    bat3(), bat2(), bat1(), bat4() ,bat3(), bat4(), bat3(), bat2(), bat1(), bat2(), bat1(), bat3(), bat1(), bat4(), bat2(), bat1(), bat3(), bat1(), bat4(), bat3()

Et à la fin on a fait la fonction ville qui appelle dans l’ordre choisi les bâtiments. Le goto permet de définir où commence le premier bâtiment, les autres se mettent juste après le premier sans se chevaucher ni laisser un espace.

Par la suite nous avons le pavage (très long aussi, il sera donc coupé) :

def pavage():
    colormode(255)
    pensize(5)
    speed(0)
    rciel = 0
    gciel = 0 
    bciel = 0
    hauteur = -360
    penup()
    goto(-640,-360)
    pendown()
    while hauteur != 0:
        pencolor(round(15 + rciel), round(4 + gciel), round(76 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (91/180)
        gciel += (1/36)
        bciel += (7/18)

Pour le début du pavage on retrouve encore le script du dégradé mais avec les couleurs modifiées.

pencolor(229, 123, 240)
    #Lignes au dessus du pavage
    pensize(4),penup(),goto(-640,0),pendown(),goto(640,0),pensize(2),penup(),goto(-640, 0),pendown()
    #lignes gauche
    penup(),goto(-20.00,0),pendown(),goto(-60.00,-360.00),penup(),goto(-60.00,0),pendown(),goto(-180.00,-360.00),penup(),goto(-100.00,0),pendown(),goto(-300.00,-360.00),penup(),goto(-140.00,0),pendown(),goto(-420.00,-360.00),penup(),goto(-180.00,0),pendown(),goto(-540.00,-360.00),penup(),goto(-220.00,0),pendown(),goto(-660.00,-360.00),penup(),goto(-260.00,0),pendown(),goto(-780.00,-360.00),penup(),goto(-300.00,0),pendown(),goto(-900.00,-360.00),penup(),goto(-340.00,0),pendown(),goto(-1020.00,-360.00),penup(),goto(-380.00,0),pendown(),goto(-1140.00,-360.00),penup(),goto(-420.00,0),pendown(),goto(-1260.00,-360.00),penup(),goto(-460.00,0),pendown(),goto(-1380.00,-360.00),penup(),goto(-500.00,0),pendown(),goto(-1500.00,-360.00),penup(),goto(-540.00,0),pendown(),goto(-1620.00,-360.00),penup(),goto(-580.00,0),pendown(),goto(-1740.00,-360.00),penup(),goto(-620.00,0),pendown(),goto(-1760.00,-360.00)
    #lignes droites
    penup(),goto(20,0),pendown(),goto(60.00,-360.00),penup(),goto(60.00,0),pendown(),goto(180.00,-360.00),penup(),goto(100.00,0),pendown(),goto(300.00,-360.00),penup(),goto(140.00,0),pendown(),goto(420.00,-360.00),penup(),goto(180.00,0),pendown(),goto(540.00,-360.00),penup(),goto(220.00,0),pendown(),goto(660.00,-360.00),penup(),goto(260.00,0),pendown(),goto(780.00,-360.00),penup(),goto(300.00,0),pendown(),goto(900.00,-360.00),penup(),goto(340.00,0),pendown(),goto(1020.00,-360.00),penup(),goto(380.00,0),pendown(),goto(1140.00,-360.00),penup(),goto(420.00,0),pendown(),goto(1260.00,-360.00),penup(),goto(460.00,0),pendown(),goto(1380.00,-360.00),penup(),goto(500.00,0),pendown(),goto(1500.00,-360.00),penup(),goto(540.00,0),pendown(),goto(1620.00,-360.00),penup(),goto(580.00,0),pendown(),goto(1740.00,-360.00),penup(),goto(620.00,0),pendown(),goto(1760.00,-360.00)
    #Lignes horizontales
    penup(),goto(-640, -300),pendown(),goto(640, -300),penup(),goto(-640, -240),pendown(),goto(640, -240),penup(),goto(-640, -190),pendown(),goto(640, -190),penup(),goto(-640, -140),pendown(),goto(640, -140),penup(),goto(-640, -100),pendown(),goto(640, -100),penup(),goto(-640, -70),pendown(),goto(640, -70),penup(),goto(-640, -40),pendown(),goto(640, -40),penup(),goto(-640, -15),pendown(),goto(640, -15),

On a par la suite énormément de goto afin de faire le quadrillage du pavage.

Pour produire l’image finale nous avons les appels des différents fonctions à la fin :

#appel de toutes les fonctions
fond(), etoile(), soleil(), montagne(), ville(), pavage()

Et pour exporter l’image finale en .png il y a la suite du script pour exporter une image générée par turtle en .png utilisé au début du script.

#enregistrement de l'image finale avec vérification des modules importés
image = getcanvas()
nom_du_fichier_sans_extension=titre+"_"+hex(randint(2**30+2**25,2**30+2**25+2**24-1))[2:]
image.postscript(file=nom_du_fichier_sans_extension+".ps", colormode='color')
try:
    psimage = Image.open(nom_du_fichier_sans_extension+".ps")
    psimage.load(scale=2)
    psimage_resized = psimage.resize((1280, 720))
    psimage.save(nom_du_fichier_sans_extension+".png")
    print(nom_du_fichier_sans_extension+".png", psimage.size, "sauvegardé dans le dossier")    
except:
    if not pillow_installed:
        print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
        print("https://nsi.xyz/py2png")
    else:
        print("Oops! - 'ghostscript' not installed- RTFM :")
        print("https://nsi.xyz/py2png")
exitonclick()

Le script va donc générer une image en .ps et la convertir en .png avec un nom généré aléatoirement pour éviter que à chaque fois que vous générez une image l’image soit écrasée

Télécharger le .py

L’image finale