translation: update french translation

translation: translate mappings article to french

translation: translate world type article to french

src/lib/translations/en/wiki.json

@@ -114,8 +114,8 @@
 		"mappings": {
 			"title": "Customizing your Mappings"
 		},
-    "world_types": {
+		"world_types": {
 			"title": "Adding World Types"
-    }
+		}
 	}
 }

src/lib/translations/fr/wiki.json

@@ -74,7 +74,7 @@
 		}
 	},
 	"items": {
-		"title": "Objets",
+		"title": "Items",
 		"armor": {
 			"title": "Ajouter une Armure"
 		},
@@ -110,6 +110,12 @@
 		},
 		"sounds": {
 			"title": "Ajouter des Sons"
+		},
+		"mappings": {
+			"title": "Personnalisez vos Mappings"
+		},
+		"world_types": {
+			"title": "Ajouter des Types de Monde"
 		}
 	}
 }

wiki/introduction/get-started/fr.md

@@ -14,14 +14,11 @@ Pour commencer à modder Minecraft, vous aurez besoins de deux choses.
 
 ## Comment Utiliser ce Wiki
 
-TODO: Create example code repository and put it here ([Issue #68](https://github.com/QuiltMC/developer-wiki/issues/68))
+<!-- TODO: Create example code repository and put it here ([Issue #68](https://github.com/QuiltMC/developer-wiki/issues/68)) -->
 
 Ce wiki contient des pages qu'il vaut mieux lire dans l'ordre. Nombre de ces articles, surtout ceux au début, suggèrent d'autres articles avec lesquels continuer.
 La plupart des pages contiennent des extraits de code, et des exemples complets de mods sont prévus. (ça n'est pas encore fait)
 
-Vous pourrez rencontrer des lignes qui commencent avec `TODO: `. Ce sont des notes pour les rédacteur·ice·s du wiki sur le travail qu'il reste à faire.
-Vous pouvez les ignorer pour l'instant, sachez simplement que plus de contenu sera inséré à leur place plus tard.
-
 Dans le prochain article, vous mettrez en place votre premier mod pour débuter avec le développement de mod.
 
 Une fois cela fais, il est recommandé d'apprendre à [Créer votre Premier Item](../items/first-item). Puis, si vous êtes près, vous pouvez apprendre à [ajoutez des blocs](../blocks/first-block), ou à créer des items plus avancés, tels que de la [nourriture](../items/food), des [outils](../items/tools) et des [armures](../items/armor).
@@ -57,9 +54,3 @@ sont là pour que vous puissiez en apprendre, n'ayez pas peur de les utiliser !
 Il y a de nombreux sujets dans le modding pour lesquels vous ne trouverez pas de tutoriels. Dans ces cas là vous devrez soit comprendre le code de Minecraft impliqué, soit regarder le code d'autres mods pour comprendre comment ils accomplissent des choses similaires à ce que vous essayez de faire. Si vous voulez regarder le code source de Minecraft, lancez la tâche Gradle `genSourcesWithVineFlower` dans la catégorie `fabric` ou ouvez n'importe quel fichier source de Minecraft dans IntelliJ IDEA et cliquez sur le bouton "download sources".
 
 <!-- TODO: Is this todo fixed?: Levi write your thing about stealing code here -->
-
-## Les différences entre Fabric et Quilt
-
-Quilt est basé sur Fabric. Cependant, il y a des différences clés entre les deux.
-
-TODO: Levi write your thing here

wiki/introduction/setting-up/fr.md

@@ -57,7 +57,10 @@ pour Minecraft qui est hautement recommandé. Vous pouvez l'obtenir ici :
 
 Après avoir ouvert le projet, vous devriez voir une fenêtre qui ressembler vaguement à ça :
 
-TODO: Embed screenshot
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="/introduction/template-mod-intellij-dark.png">
+  <img alt="IntelliJ IDEA open to the template mod" src="/introduction/template-mod-intellij-light.png">
+</picture>
 
 Vous pouvez voir des barres latérales de chaque côté de la fenêtre avec des icônes pour accéder à différents outils.
 En voici quelques uns qui vous seront utiles :
@@ -238,4 +241,4 @@ Enfin, rechargez le projet Gradle en appuyant sur ce bouton dans le menu Gradle
 </picture>
 
 Après avoir complété toutes ces étapes, vous pouvez maintenant travailler sur votre mod !
-Vous pouvez commencer par [Créer votre Premier Item](../items/first-item).
+Vous pouvez commencer par ajouter du contenu avec les tutoriels ["Créer votre Premier Item"](../items/first-item) et [Ajouter un Bloc Simple](../blocks/first-block).

wiki/items/first-item/fr.md

@@ -13,13 +13,20 @@ Les blocs, les entités, les items, les sons, les particules... tous ces différ
 
 ---
 
-Premièrement, nous devons créer une instance de `net.minecraft.item.Item` avec les paramètres de notre item.
+Premièrement, il faut que nous mettions en place un endroit pour les objets de notre mod. Créez une nouvelle classe nommée `ExampleModItems`, en renplaçant `ExampleMod` par le nom de votre mod, dans le même package que votre classe principale.
+Cela nous aidera à rester organiser si jamais notre mod s'aggrandit et ajoute plus d'un item.
 
-En théorie, nous pourrions faire ça directement dans la même ligne où nous enregistrons l'item,
+Ensuite, on va déclarer une instance de `net.minecraft.item.Item` avec les paramètres pour notre item.
+
+En théorie, nous pourrions passer cette étape et déclarer l'item en même temps qu'on lenregistre,
 mais l'avoir dans une variable séparée nous permet d'y faire référence à d'autres endroit pour d'autres usages.
 
+`src/main/com/example/example_mod/ExampleModItems`:
+
 ```java
-public static final Item EXAMPLE_ITEM = new Item(new QuiltItemSettings());
+public class ExampleModItems {
+	public static final Item EXAMPLE_ITEM = new Item(new QuiltItemSettings());
+}
 ```
 
 Ici, le `public static final` permet d'acceder à l'item ailleurs sans que l'on puisse changer la valeur de la variable en elle même,
@@ -32,11 +39,19 @@ mais dans notre cas nous utilisons simplement les paramètres par défaut.
 
 ---
 
-Après avoir déclaré l'item, nous devons dire au registre des items du jeu de l'inclure dans ce dernier.
-Pour ce faire nous ajoutons la ligne suivante dans le `ModInitializer` du mod (([Plus d'information sur les 'mod initializers' ici](../concepts/sideness#les-mod-initializers))) dans la méthode `onInitialize` :
+Après avoir déclaré l'item, nous devons l'enregistrer pour l'inclure dans le jeu.
+Nous allons mettre en place une méthode dans votre classe pour items responsable de l'enregistrement de tous vos items.
+Vous pouvez voir que l'on prend le `ModContainer` du mod comme paramètre pour que l'on puisse l'utiliser pour récupérer l'ID du mod.
+
+`src/main/com/example/example_mod/ExampleModItems`:
 
 ```java
-Registry.register(Registries.ITEM, new Identifier(mod.metadata().id(), "example_item"), EXAMPLE_ITEM);
+public class ExampleModItems {
+	// ...
+	public static void register(ModContainer mod) {
+		Registry.register(Registries.ITEM, new Identifier(mod.metadata().id(), "example_item"), EXAMPLE_ITEM);
+	}
+}
 ```
 
 `Registry.register()` prend trois arguments :
@@ -46,6 +61,22 @@ Registry.register(Registries.ITEM, new Identifier(mod.metadata().id(), "example_
   suivi du nom de l'item en lui même. Seules les lettres minuscules, les chiffres, les underscores, les tirets, les points et les slashs sont autorisés.
 - L'`Item` à enregistrer. Ici, on passe l'item déclaré plus tôt.
 
+Enfin, nous devons nous assurer que la méthode `register()` est bien appelée pendant le démarrage du jeu.
+On peut accomplir cela en appelant la méthode dans le `ModInitializer` du mod ([plus d'informations sur les mod initializers ici!](../concepts/sideness#les-mod-initializers)) dans la méthode `onInitialize`:
+
+`src/main/com/example/example_mod/ExampleMod`:
+
+```java
+public class ExampleMod implements ModInitializer {
+	// ...
+	@Override
+	public void onInitialize(ModContainer mod) {
+		// ...
+		ExampleModItems.register(mod);
+	}
+}
+```
+
 Une fois que vous avez fait tout ça, si on lance le jeu on peut voir que l'on peut se donner l'item avec la commande give : `/give @s simple_item_mod:example_item` !
 Mais il n'apparait pas dans le menu du mode créatif, et il n'a pas de texture, et son nom n'a pas de traduction.
 Comment réparer ça ?
@@ -59,10 +90,18 @@ en utilisant seulement les [Quilt Standard Libraries](../concepts/qsl-qfapi#les-
 Grâce à la [Quilted Fabric API](../concepts/qsl-qfapi#la-quilted-fabric-api), qui est inclue dans le mod patron
 et est téléchargée par les utilisateurs avec la QSL, on peut aussi l'utiliser avec Quilt :
 
+`src/main/com/example/example_mod/ExampleModItems`:
+
 ```java
-ItemGroupEvents.modifyEntriesEvent(ItemGroups.INGREDIENTS).register(entries -> {
-	entries.addItem(EXAMPLE_ITEM);
-});
+public class ExampleModItems {
+	// ...
+	public static void register(ModContainer mod) {
+		// ...
+		ItemGroupEvents.modifyEntriesEvent(ItemGroups.INGREDIENTS).register (entries -> {
+			entries.addItem(EXAMPLE_ITEM);
+		});
+	}
+}
 ```
 
 Ici on utilise l'API `ItemGroupEvents`. On récupère l'[événement](../concepts/events)
@@ -101,6 +140,8 @@ donc dans notre cas : `assets/simple_item_mod/textures/item/example_item.png`.
 Enfin, on a besoin d'ajouter une traduction.
 Mettez ceci dans `assets/simple_item_mod/lang/en_us.json`, en remplaçant l'identifiant du mod et le nom de l'item comme avant :
 
+`assets/simple_item_mod/lang/en_us.json`;
+
 ```json
 {
 	"item.simple_item_mod.example_item": "Example Item"

wiki/misc/mappings/en.md

@@ -2,7 +2,7 @@
 
 ## What are mappings?
 
-Before a new Minecraft version jar is published to Mojang's servers, it goes through a process called *obfuscation*,
+Before a new Minecraft version jar is published to Mojang's servers, it goes through a process called _obfuscation_,
 where the human-readable class, field and method names are simplified to just a few letters, mainly to optimize the file
 size. In addition, obfuscation makes code very difficult to understand, because those simplified names aren't just
 contractions of the real names, they're completely random letters. This is where mappings come into play.
@@ -60,7 +60,7 @@ closing Enigma.
 ### Contributing the changes back to Quilt
 
 To contribute your changes, you have to add and commit your changes, then push the changes to your fork of QM. This is
-really easy to do with an IDE, as described in [the Setting Up article][setting-up], but if you want you can also do it
+really easy to do with an IDE, as described in [the Setting Up article](../introduction/setting-up), but if you want you can also do it
 from the command prompt or terminal with these commands.
 
 ```bash
@@ -105,15 +105,12 @@ their documentation or code to verify the version you want.
 That's it! You can now reload gradle through your IDE to apply these changes, and use your new mappings when reading
 Minecraft's code.
 
-
 <!-- Links -->
+
 [Quilt Mappings]: https://github.com/QuiltMC/quilt-mappings
 [QM CONTRIBUTING.md]: https://github.com/QuiltMC/quilt-mappings/blob/HEAD/CONTRIBUTING.md
 [Fork QM]: https://github.com/QuiltMC/quilt-mappings/fork
 [QM PRs]: https://github.com/QuiltMC/quilt-mappings/pulls
 [Enigma]: https://github.com/QuiltMC/enigma
 [Enigma guide]: https://github.com/QuiltMC/quilt-mappings/blob/HEAD/GUIDE.md
-
-[setting-up]: /en/introduction/setting-up
-
 [Tiny V2]: https://fabricmc.net/wiki/documentation:tiny2

wiki/misc/mappings/fr.md

@@ -0,0 +1,137 @@
+# Personnaliser les Mappings dans votre Environnment de Développement
+
+## C'est quoi les mappings ?
+
+Avant que le jar d'une nouvelle version de Minecraft ne soit publiée sur les serveurs de Mojang,
+il passe par un procédé appelé l'_obfuscation_, qui simplifie les noms des classes, champs et méthodes à quelques lettres,
+surtout pour optimiser la taille du fichier. L'obfuscation rend le code très difficile à comprendre
+car ces noms simplifés ne sont pas de simples abreviations des vrais noms, ce sont des lettres complétement aléatoires.
+C'est là que les mappings interviennent.
+
+Un mapping est simplement le changement d'un nom à un autre, dans la plupart des cas d'un nom "obfusqué" vers un nom compréhensible.
+Chaque mapping peut aussi avoir des metadonnées supplémentaires, comme de la documentation.
+Un ensemble de mappings est souvent appelé juste des "mappings".
+Vous pouvez voir un ensemble de mappings comme un dictionnaire de traduction,
+dans lequel chaque mapping est une traduction d'un mot dans une autre langue.
+Ici les noms "obfusqués" serait le langage utilisé par l'ordinateur
+et le dictionnaire nous aide à traduire ça dans un langage qu'on peut comprendre.
+
+Bien qu'un simple ensemble de mappings d'"obfusqué" à compréhensible serait suffisant pour une version de Minecraft,
+les noms "obfusqués" ne sont pas constants d'une version de Minecraft à une autre : `DirtBlock` pourrait être "obfusqué"
+en `abc` en 1.19 mais en 1.20 ça pourrait être `def`.
+Il faudait donc garantir que les changement d'obfuscation entres deux versions reste minimal,
+un problème qui peut être résolu avec les mappings intermédiaires qui convertissent ces noms "obfusqués"
+en noms qui ne changeront pas d'une version à une autre mais qui ne sont quand même pas faits pour être compréhensibles.
+Quilt utilise Hashed Mojmap, dans lequel chaque classe, champ et méthode est préfixé par
+`C_`, `f_` et `m_` respectivement, suivi par un hash de 8 lettres.
+En développant des mods, vous rencontrerez surtout les mappings intermédiaires de Fabric,
+qui utilisent `class_`, `field_` et `method_`, suivit d'un nombre.
+Mojang publie également des mappings officiel, souvent appelés Mojmap (abreviation pour Moj(ang)-map(pings)),
+pour chaque version après la 1.14.
+Comme ils n'ont pas de mappings intermédiaires vous devez faire un peu de travail supplémentaire
+pour les utiliser à la place d'autres mappings.
+Heureusement, Loom fait ce travail pour vous donc vous n'avez pas à vous inquietez pour ça
+et vous pouvez facilement remplacé les mappings utilisés dans votre mod par les mappings officiel de Mojang.
+
+Il y a plusieurs formats différents pour stocker des mappings et, au moment où cet article a été écrit,
+nous travaillons sur un nouveau format avec beaucoup d'améliorations.
+Dans notre écosystème, le format le plus populaire est [Tiny v2], qui utilise un unique fichier `.tiny` pour stocker
+les mappings, et place les champs et méthodes comme "enfants" de leur classe.
+Un autre format que l'on utilise souvent est le format Enigma, qui utilise une arborescence de fichiers avec un fichier pour
+chaque classe de haut niveau et organise les entrées dans une hiérarchie avec chaque champ, méthode et classe comme enfant
+d'une autre classe ou d'une classe de haut niveau.
+
+## Modifier vos Mappings
+
+Les ensembles de mappings n'ont pas besoin de contenir des mappings pour toutes les classes, champs ou méthodes pour être
+valides, en fait la majorité des mappings ne sont pas complets.
+Par exemple, les Quilt Mappings (ou QM) atteignent au mieux 99% de complétion.
+Dans un environnement de développement, les choses non-mappées utiliseront leur nom intermédiaire
+au lieu de leur nom "obfusqué", donc si vous avez déjà traversé le code de Minecraft avec les QM
+ou Yarn (les mappings de Fabric) appliqué, il est très probable que vous ayez vu un bon nombre de noms intermédiaires.
+C'est encore pire pour les paramètres de méthodes : comme ils sont à haut risque d'incompatibilité entre deux versions,
+ils n'ont (en général) pas de noms intermédiaires, ainsi les noms que vous voyez dans le code dépend des outils
+que vous avez utilisé pour décompiler le jeu.
+
+Si vous voulez ajouter un nom ou un changer un qui est faux ou juste mauvais,
+vous pouvez commencer par choisir un mapping que vous utiliserez comme base.
+Dans cet article, nous utiliserons les QM mais le procédé pour Yarn est presque identique.
+Si vous voulez utiliser les mappings de Mojang comme base,
+vous devrez accomplir un peu de travail supplémentaire qui ne sera pas expliqué ici.
+Si vous décidez d'utiliser les QM, nous vous recommandons fortement de lire
+sa [documentation de contribution][QM CONTRIBUTING.md] et de contribuer vos modification au dépot.
+Vous aurez besoin de connaissances très basique de Git mais cela devrait être assez facile à faire
+si vous avez déjà travaillé avec Git auparavant.
+
+Pour commencer, vous devez acquérir votre propre copie du code des [Quilt Mappings] en clonant ou téléchargeant le dépot.
+Si vous voulez contribuer vos modifications à un moment, télécharger directement le code ne fonctionnera pas,
+il faudra [fork le dépot][fork qm] et cloné votre fork à la place.
+Une fois que vous avez le code, lancez `./gradlew mappings` dans votre terminal pour lancer [Enigma],
+notre outil préféré pour modifier et écrire des mappings.
+Rai a écrit un [super guide (en anglais) qui explique comment modifier des mappings avec Enigma][Enigma guide],
+donc vous pouvez y jetter un œil et commencer à mapper!
+Une fois que vous aurez fini de modifier les mappings,
+n'oubliez pas de sauvegarder vos modifications avant de fermer Enigma.
+
+### Contribuer les modifications à Quilt
+
+Pour contribuer vos modifications, vous devez ajouter et commiter vos modifications,
+puis push les modifications vers votre fork des QM.
+C'est très facile à faire avec une IDE, comme expliqué dans l'[article de Mise en Place](../introduction/setting-up),
+mais vous pouvez aussi le faire depuis votre terminale avec ces commandes si vous le voulez.
+
+```bash
+git add . # dit à git de suivre toutes les modifications dans le dossier actuel
+
+git commit -m "Blabla" # ajoutes ces modifications dans un nouveau commit (remplacez "blabla" par une courte description de vos modifications)
+
+git push # upload vos commits vers votre fork des QM. Vous aurez peut-être besoin d'ajouter `origin <version de minecraft>` à la fin si git se plaint de ne pas avoir de branche upstream
+```
+
+Après avoir push vos modification vers votre fork, allez dans [l'onglet des Pull Request des QM][QM PRs]
+et cliquez sur le boutton "Compare & Pull Request" dans la note sur vos modifications récentes.
+Remplissez le titre et la description de votre PR, validez là,
+puis attendez que vos modifications soient vérifiées et acceptées.
+N'oubliez pas que vous pouvez trouver une expication plus approfondie (en anglais) du procédé de PR dans
+la [documentation de contribution][QM CONTRIBUTING.md].
+
+### Utiliser les mappings modifiés
+
+Si vous ne voulez pas contribuer vos modifications à Quilt,
+ou si vous voulez les tester dans un environnement de développement,
+vous pouvez lancer `./gradlew publishToMavenLocal` pour rendre les fichiers nécessaires disponibles
+aux autres projets dans votre ordinateur.
+Vous pouvez maintenant aller dans le projet ou vous voulez appliquer ces mappings, et éditer le fichier `build.gradle`
+pour ajouter `mavenLocal()` au block `repositories`, si il n'y est pas déjà.
+
+```gradle
+repositories {
+    // ...
+    mavenLocal()
+}
+```
+
+Une fois que vous avez `mavenLocal()` dans les repositories, vous pouvez modifier le fichier `libs.versions.toml`,
+dans le dossier `gradle/`, pour changer la version des mappings que vous utilisez pour celle que vous venez de modifier.
+Dans le cas des QM, vous pouvez changer le suffix `+build.*` en `+local`, d'autres projets peuvent utiliser d'autres
+format de versioning, donc vous devrez vérifier leur documentation ou code pour vérifier la version que vous voulez.
+
+```diff
+ minecraft = "1.20.4"
+-quilt_mappings = "1.20.4+build.1"
++quilt_mappings = "1.20.4+local"
+ quilt_loader = "0.23.1"
+```
+
+Et voilà ! Vous pouvez maintenant recharger gradle via votre IDE pour appliquer les modifications
+et utiliser vos nouveaux mappings en lisant le code de Minecraft.
+
+<!-- Links -->
+
+[Quilt Mappings]: https://github.com/QuiltMC/quilt-mappings
+[QM CONTRIBUTING.md]: https://github.com/QuiltMC/quilt-mappings/blob/HEAD/CONTRIBUTING.md
+[Fork QM]: https://github.com/QuiltMC/quilt-mappings/fork
+[QM PRs]: https://github.com/QuiltMC/quilt-mappings/pulls
+[Enigma]: https://github.com/QuiltMC/enigma
+[Enigma guide]: https://github.com/QuiltMC/quilt-mappings/blob/HEAD/GUIDE.md
+[Tiny V2]: https://fabricmc.net/wiki/documentation:tiny2