Auteur : Thomas Q.

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