From 7ecec85ea779a7042504901bf584c93722f7dde4 Mon Sep 17 00:00:00 2001 From: celeri Date: Fri, 29 Mar 2024 02:11:03 -0400 Subject: [PATCH] Translation of latest updates to French (#90) * Started translating updates to french * Translated some of the new articles * Finished translating all the new stuff * Integrating recommanded changes --- src/lib/translations/fr/application.json | 2 +- src/lib/translations/fr/wiki.json | 19 +- wiki/configuration/advanced-configuring/en.md | 17 +- wiki/configuration/advanced-configuring/fr.md | 267 ++++++++++++++++++ wiki/configuration/config-screen/fr.md | 1 + wiki/configuration/getting-started/en.md | 20 +- wiki/configuration/getting-started/fr.md | 159 +++++++++++ wiki/configuration/metadata/en.md | 4 +- wiki/configuration/metadata/fr.md | 64 +++++ wiki/introduction/get-started/fr.md | 26 +- wiki/introduction/setting-up/fr.md | 13 +- wiki/items/armor/fr.md | 4 +- 12 files changed, 560 insertions(+), 36 deletions(-) create mode 100644 wiki/configuration/advanced-configuring/fr.md create mode 100644 wiki/configuration/config-screen/fr.md create mode 100644 wiki/configuration/getting-started/fr.md create mode 100644 wiki/configuration/metadata/fr.md diff --git a/src/lib/translations/fr/application.json b/src/lib/translations/fr/application.json index 840afc3a..06aedd68 100644 --- a/src/lib/translations/fr/application.json +++ b/src/lib/translations/fr/application.json @@ -1,5 +1,5 @@ { - "title": "Wiki pour Développeur·euse·s de Quilt :P", + "title": "Wiki pour Développeur·euse·s Quilt :P", "dev-notice": "Attention : Ce site est encore en cours de développement. Veuillez signaler les problèmes (en anglais) ici : <{{placeholder}}>", "translation-notice": "Veuillez noter que la langue originale de ce wiki est l'anglais et que les versions traduites peuvent ne pas être à jour en comparaison à la version anglaise", "draft-notice": "Cette page du wiki est prévue mais n'a pas encore été implémentée. Vous pouvez participer à la création de ce wiki ici : <{{placeholder}}>", diff --git a/src/lib/translations/fr/wiki.json b/src/lib/translations/fr/wiki.json index 0e912e92..c7f2db3d 100644 --- a/src/lib/translations/fr/wiki.json +++ b/src/lib/translations/fr/wiki.json @@ -1,5 +1,5 @@ { - "not-translated": "Cette page du wiki n'est pas encore été traduite en {{placeholder}}", + "not-translated": "Cette page du wiki n'a pas encore été traduite en {{placeholder}}", "not-found": "Aucune page du wiki trouvée à l'adresse : `{{placeholder}}`", "blocks": { "title": "Blocs", @@ -79,7 +79,7 @@ "title": "Ajouter une Armure" }, "first-item": { - "title": "Créez votre Premier Item" + "title": "Créer votre Premier Item" }, "food": { "title": "Ajouter de la Nourriture" @@ -88,6 +88,21 @@ "title": "Ajouter des Outils Personnalisés" } }, + "configuration": { + "title": "Configuration", + "getting-started": { + "title": "Débuter avec Quilt Config" + }, + "advanced-configuring": { + "title": "Configuration Avancée" + }, + "config-screen": { + "title": "Mettre en place un Écran de Configuration" + }, + "metadata": { + "title": "Référence pour les Annotations et les Métadonnées" + } + }, "misc": { "title": "Divers", "commands": { diff --git a/wiki/configuration/advanced-configuring/en.md b/wiki/configuration/advanced-configuring/en.md index 90a81d3a..d4204e52 100644 --- a/wiki/configuration/advanced-configuring/en.md +++ b/wiki/configuration/advanced-configuring/en.md @@ -1,9 +1,4 @@ ---- -title: Advanced Configuring -index: 2 ---- - -# Advanced configuring +# Advanced Configuring Simple values are nice and all, but if you have a lot of them it can begin to get unwieldy. In this tutorial, we'll discuss how to organize your config and use processors to get the most out of it. @@ -49,9 +44,10 @@ We simply create a new class, inside our config class, that extends `ReflectiveC ## Serializing custom values -In Java, you can print to different output streams in the console. These aren't basic integer or float objects, so we can't just save them in our config! This is where the `ConfigSerializableObject` interface comes in. By implementing its three methods, we can set up any class to be usable as a config object. +In Java, you can print to different output streams in the console. These aren't basic serializable objects like integers or `String`, so we can't just save them in our config! This is where the `ConfigSerializableObject` interface comes in. By implementing its three methods, we can set up any class to be usable as a config object. The interface works via generics, just like `TrackedValue`. The `` in `ConfigSerializableObject` can be swapped out with any serializable class (remember, by default that's primitive types, `String`, `ValueList`, and `ValueMap`), and the value of your object will be translated into that type to be saved to disk, and then converted back into your custom object when read. To do that translating, we need to implement three methods: + - `T getRepresentation()`: here, your value is converted to the serializable class that you specified in the generics (represented by `T`) so that it can be saved. - `YourSerializableClass convertFrom(T)`: this one is called when reading the config file, and converts the representation created by `getRepresentation` back to its original type. - `YourSerializableClass copy()`: makes a copy of the value, which Quilt Config uses internally. @@ -167,6 +163,7 @@ public class ExampleModConfig extends ReflectiveConfig { With that, our config will print "Loading config!" before any of its values are deserialized. Note despite the method name passed to `@Processor` not coming with any parameter information, we still had to put a `Config.Builder` on our method: what's up with that? Processors can be attached to three different types: tracked values, config sections, and config classes. For each, the parameter will be different, as documented in `Processor`'s Javadoc: + - When used on a tracked value, the processor method will take a `TrackedValue.Builder` as its parameter. - When used on a section, the processor method will take a `SectionBuilder` as its parameter. - When used on a config class, the processor method will take a `Config.Builder` as its parameter. @@ -190,7 +187,7 @@ public class ExampleModConfig extends ReflectiveConfig { With that line, we've expanded our logging to now tell us whenever a config value is updated! Neat, but what else can we do with callbacks? -One example of a callback usage is syncing a value between your config field and another. This could be needed for many reasons: your config value is complicated, and you want to make it easier to access, or maybe you need to update the configuration of one of the libraries you depend on when the value is changed ([enigma]() does just that!). +One example of a callback usage is syncing a value between your config field and another. This could be needed for many reasons: your config value is complicated, and you want to make it easier to access, or maybe you need to update the configuration of one of the libraries you depend on when the value is changed ([enigma](https://github.com/QuiltMC/enigma) does just that!). We're going to set up a shortcut to accessing the print stream made available in `printStream`, that doesn't force you to go through two separate getters to use. To do that, we can use a processor applied to the field! `src/main/com/example/example_mod/ExampleModConfig`: @@ -208,7 +205,7 @@ public class ExampleModConfig extends ReflectiveConfig { public void processPrintStream(TrackedValue.Builder builder) { builder.callback(value -> activeStream = printStream.value().getStream()); } - + // ... } } @@ -238,7 +235,7 @@ public class ExampleModConfig extends ReflectiveConfig { } ``` -With our knowledge of processors, this is simple! You can also use the config builder to add new fields, new sections, and update [metadata](https://wiki.quiltmc.org/en/configuration/metadata), on top of changing the format and using callbacks as we've already covered. +With our knowledge of processors, this is simple! You can also use the config builder to add new fields, new sections, and update [metadata](../configuration/metadata), on top of changing the format and using callbacks as we've already covered. ## Adding multiple files diff --git a/wiki/configuration/advanced-configuring/fr.md b/wiki/configuration/advanced-configuring/fr.md new file mode 100644 index 00000000..fbde01dc --- /dev/null +++ b/wiki/configuration/advanced-configuring/fr.md @@ -0,0 +1,267 @@ +# Configuration Avancée + +Les valeurs simples c'est sympa mais si vous en avez beaucoup ça peut rapidement devenir compliqué à gérer. Dans ce tutoriel, nous allons voir comment organiser votre config et utiliser des processeurs pour en tirer le maximum. + +## Utiliser des sections + +Un simple fichier avec dizaines de valeurs à la suite peut rapidement devenir complexe à comprendre et à utiliser. Heureusement on peut l'organiser en plusieurs sections en utilisant Quilt Config ! C'est très simple à réaliser. + +Avec des sections, vous pouvez utiliser de l'indentation pour differencier visuellement les parties de votre fichiers de configuration pour faciliter la lecture des utilisateur·ice·s. Nous allons ajouter une section d'exemple qui ressemblera à ça dans le fichier TOML : + +```toml +# ... + +# This isn't actually used by the mod, but I was completely out of ideas for things to add. +typesOfSoup = ["tomato", "borscht", "chicken noodle", "ramen", "STEW", "mushroom"] + +# Advanced settings for advanced users. +[advanced_settings] + # Whether to automatically append newlines to every message printed. + # default: true + printNewlines = true +``` + +Pour faire cela, nous allons créer une section dans notre code : + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +public class ExampleModConfig extends ReflectiveConfig { + // ... + @Comment("Advanced settings for advanced users.") + @SerializedName("advanced_settings") + public final AdvancedSettings advancedSettings = new AdvancedSettings(); + + public static class AdvancedSettings extends Section { + @Comment("Whether to automatically append newlines to every message printed.") + @SerializedName("print_newlines") + public final TrackedValue printNewlines = this.value(true); + } +} +``` + +Nous ajoutons simplement une nouvelle classe, dans notre classe de configuration, qui hérite de `ReflectiveConfig.Section`. Ensuite nous devons créer un autre objet dans notre config principale pour ajouter cette section. Notez que cette instance de notre section n'est **pas** contenue dans une `TrackedValue` comme le reste, en fait elle contient elle-même des `TrackedValue` ! Maintenant que l'on a une section, on peut ajouter autant de valeurs que l'on veut dedans. Et si on veut contenir quelque-chose de plus intéressant que des types basiques, des maps ou des listes ? Serialisons un objet personnalisé. + +## Sérialiser des valeurs personnalisées + +En Java, vous pouvez écrire dans plusieurs flux de sortie dans la console. Ce ne sont pas des objets serialisables basiques comme des entiers ou des `String` donc on ne peut pas simplement les contenir dans notre config ! C'est là que l'interface `ConfigSerializableObject` intervient. En implémentant ses trois méthodes, on peut mettre en place n'importe quelle classe pour pouvoir les utiliser comme objet de configuration. + +L'interface fonctionne avec des generics, comme `TrackedValue`. Le `` dans `ConfigSerializableObject` peut être remplacé par n'importe quelle classe sérialisable (par défaut ce sont les types primitifs, `String`, `ValueList` et `ValueMap`) et la valeur de votre objet sera traduit en ce type pour être sauvegardé en dur puis sera reconverti en votre objet personnalisé en étant lu. Pour faire cette traduction, nous devons implémenter trois méthodes : + +- `T getRepresentation()` : ici, votre valeur est converti en la classe sérialisable que vous avez spécifié dans les generics (représenté par `T`) pour qu'elle puisse être sauvegardée. +- `YourSerializableClass convertFrom(T)` : celle-là est appelée en lisant le fichier de configuration et reconverti la représentation créée par `getRepresentation` en son type original. +- `YourSerializableClass copy()` : réalise une copie de la valeur que Quilt Config utilise internalement. + +Assez avec les explications : voyons un exemple ! + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +public class ExampleModConfig extends ReflectiveConfig { + // ... + public static class AdvancedSettings extends Section { + // ... + @Comment("What stream to print the message to.") + @SerializedName("print_stream") + public final TrackedValue printStream = this.value(PrintStreamOption.SYSTEM_OUT); + + @SuppressWarnings("unused") // les IDEs ne comprendront pas que toutes les options de cet enum peuvent être utilisées via la config + public enum PrintStreamOption implements ConfigSerializableObject { + SYSTEM_OUT(System.out), + SYSTEM_ERROR(System.err); + + private final PrintStream printStream; + + PrintStreamOption(PrintStream stream) { + this.printStream = stream; + } + + public PrintStream getStream() { + return this.printStream; + } + + @Override + public PrintStreamOption convertFrom(String representation) { + return valueOf(representation); + } + + @Override + public String getRepresentation() { + return this.name(); + } + + @Override + public PrintStreamOption copy() { + // les valeurs d'enum ne peuvent pas être dupliquées + return this; + } + } + } +} +``` + +Cela peut avoir l'air d'être beaucoup de code mais on en a déjà couvert la majorité ! Ici on utilise un `Enum` qui nous permet de définir clairement une liste d'options pour notre valeur. Si vous le vouliez, pour pourriez utiliser une classe normale et avoir un nombre infinie de possibilités pour votre champ de configuration ! Un autre bonus avec l'utilisation d'un `Enum` est que Quilt Config va automagiquement générer un commentaire avec les valeurs possibles dans le fichier de configuration sérialisé. + +L'implémentation des méthodes de `ConfigSerializableObject` est incroyablement simple ici : comme les valeurs de notre enum ont déjà des noms, on utilisé simplement les méthodes `name` et `valueOf(String)` pour sérialiser et désérialiser respectivement. Pratique ! Regardons un autre exemple d'un objet personnalisé qui ne peut pas être représenté comme un enum. + +Disons que l'on veut stocker un point sur une grille 3d dans la config. Nous devrions stocker des coordonées `x`, `y` et `z` pour cette valeur. Faisons cela ! C'est un simple exemple et ne sera pas utilisé dans notre mod. + +```java +public class Vec3i implements ConfigSerializableObject> { + public final int x; + public final int y; + public final int z; + + public Vec3i(int x, int y, int z) { + this.x = x; + this.y = y; + this.z = z; + } + + @Override + public Vec3i copy() { + return this; + } + + @Override + public Vec3i convertFrom(ValueMap representation) { + return new Vec3i(representation.get("x"), representation.get("y"), representation.get("z")); + } + + @Override + public ValueMap getRepresentation() { + return ValueMap.builder(0) + .put("x", this.x) + .put("y", this.y) + .put("z", this.z) + .build(); + } +} +``` + +Ici on utilise une `ValueMap` au lieu d'un `String` comme type sérialisé. Cela nous permet de facilement distinguer les champs `x`, `y` et `z` et c'est le type que vous utiliserez presque à chaque fois pour sérialiser des objets complexes comme celui-ci. On ne va pas aller trop en profondeur ici, le code est assez parlant maintenant que l'on comprend l'interface `ConfigSerializableObject`. + +## Utiliser des processeurs + +Maintenant que nous avons tout apprit sur les valeurs, apprenons à faire des choses malveillantes : voici les `Processeur`s. +Cette annotation sournoise vous permet de configurer votre config et ses valeur, ainsi que d'ajouter des callbacks de modifications, qui vous permettent d'appeler du code quand une valeur est modifiée. +L'annotation fonctionne en vous permettant de désigner du code qui sera appelé à la construction de la config. +D'abord, mettons en place un simple processeur qui écrit dans la console quand la config commence à être chargée. + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +@Processor("processConfig") +public class ExampleModConfig extends ReflectiveConfig { + public void processConfig(Config.Builder builder) { + System.out.println("Loading config!"); + } + + // ... +} +``` + +Avec ça, notre config écrira "Loading config!" dans la console avant qu'aucune de ses valeurs n'ai été désérialisé. Notez que bien que le nom de la méthode soit passée à `@Processor` sans information sur des paramètres, nous devons quand même mettre un `Config.Builder` dans notre méthode : mais pourquoi ? +Les processeurs peuvent être attachés à trois différents types : des valeurs de la configuration, des sections de la configuration ou des classes de configuration. Dans chacun des cas, le paramètre sera différent comme expliqué dans la Javadoc de `Processor` : + +- Quand utilisé avec une valeur, la méthode du processeur prendra un `TrackedValue.Builder` comme paramètre. +- Quand utilisé avec une section, la méthode du processeur prendra un `SectionBuilder` comme paramètre. +- Quand utilisé avec une classe de configuration, la méthode du processeur prendra un `Config.Builder` comme paramètre. + +Mais on peut faire plus avec les processeur qu'écrire n'importe quoi dans la console ! Voyons ce que l'on peut faire avec cet object `Builder` qui nous a été donné. +Sur les valeur et les classes de configurations, nous pouvons utiliser une méthode appelée `callback` pour mettre en place du code qui est appelé quand la config est modifiée ! + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +@Processor("processConfig") +public class ExampleModConfig extends ReflectiveConfig { + public void processConfig(Config.Builder builder) { + System.out.println("Loading config!"); + builder.callback(config -> System.out.println("Updated!")); + } + + // ... +} +``` + +Avec cette ligne, on a développé notre logging pour nous dire quand une valeur de la config est modifiée ! Sympa, mais que peut-on faire d'autres avec ces callbacks ? + +Un exemple d'utilisation de callback est de synchroniser entre deux champs de la configuration. Cela pourrait être nécessaire pour plusieurs raisons : la valeur de votre config est compliquée et vous voullez la rendre plus accessible, ou peut-être que vous devez modifier la configuration d'une des librairies dont vous dépendez quand une valeur est modifiée (c'est ce que fait [enigma](https://github.com/QuiltMC/enigma) !). +Nous allons mettre en place un racourcit pour accéder au flux de sortie rendu disponible par `printStream`, cela ne vous force pas à utiliser deux getters pour l'utiliser. Pour faire cela, on va utiliser un processeur appliqué au champ ! + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +@Processor("processConfig") +public class ExampleModConfig extends ReflectiveConfig { + // ... + public static class AdvancedSettings extends Section { + // ... + @Processor("processPrintStream") + public final TrackedValue printStream = this.value(PrintStreamOption.SYSTEM_OUT); + public transient PrintStream activeStream = printStream.value().getStream(); + + public void processPrintStream(TrackedValue.Builder builder) { + builder.callback(value -> activeStream = printStream.value().getStream()); + } + + // ... + } +} +``` + +En utilisant notre callback, nous mettons à jour la variable `activeStream` à chaque fois que le flux de sortie est changé. Cela le garde parfaitement synchronisé avec le champ `printStream` en tout temps ! Notez que l'on marque cette variable avec le mot clef `transient` qui dit à Java (et donc aussi à Quilt Config !) de ne pas sérialiser la valeur. +Maintenant au lieu de se casser la tête avec `ExampleModConfig.INSTANCE.advancedSettings.printStream.value().getStream()` on peut simplement faire `ExampleModConfig.INSTANCE.advancedSettings.activeStream`, simplifiant nos vie un petit peu quand on utilise la config. Le pouvoir des processeurs en action. + +## Changer le format de la config + +Voyons comment choisir un format de fichier pour sauvegarder votre config. Quilt Config ne fournit pour l'instant que deux sérialisateurs : `json5`, une extension du format JSON qui permet une syntax plus propre et des commentaires, et `toml`, qui est la valeur par défaut. Si vous voulez utiliser `json5`, nous pouvons le faire en utilisant un `Processor` ! +Nous aurons besoin d'appliquer ce processeur globalement à notre configuration comme nous allons changer le format via l'objet `Config.Builder` fournit par un processeur de classe de configuration. + +Ce processeur a besoin d'être appelé avant que la config soit lue donc nous allons le mettre directement sur la classe : + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +@Processor("processConfig") +public class ExampleModConfig extends ReflectiveConfig { + public void processConfig(Config.Builder builder) { + // ... + builder.format("json5"); + } + + // ... +} +``` + +Avec notre connaissance des processeurs, c'est très simple ! Vous pouvez également utiliser le config builder pour ajouter des nouveaux champs, nouvelles sections et mettre à jour les [métadonnées](../configuration/metadata) en plus de changer le format et utiliser des callback comme nous l'avons déjà montré. + +## Ajouter plusieurs fichiers + +Pour des très gros mods, un seul fichier de configuration peut vite devenir difficile à géré, même découpé en sections. +Heureusement, Quilt Config est designé pour permettre d'ajouter facilement plusieurs fichiers de configuration : par défaut, vos fichiers de configuration sont tous placés dans leurs propres dossiers. +Pour ajouter un deuxième fichier dans ce dossier, nous devons créer une autre classe de configuration : appelons là `ExampleModConfig2`. +Nous devrons aussi changer le nom de notre fichier de config originale pour être plus spécifique : + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +public class ExampleModConfig extends ReflectiveConfig { + public static final ExampleModConfig INSTANCE = QuiltConfig.create(ExampleMod.MOD_ID, "main", ExampleModConfig.class); +} +``` + +Au lieu d'utiliser l'ID du mod comme nom de notre classe, nous appelons notre config originale `main`. +Maintenant créons une deuxième config : + +`src/main/com/example/example_mod/ExampleModConfig2`: + +```java +public class ExampleModConfig2 extends ReflectiveConfig { + public static final ExampleModConfig2 INSTANCE = QuiltConfig.create(ExampleMod.MOD_ID, "secondary", ExampleModConfig2.class); +} +``` + +La même chose qu'avec notre originale mais en utilisant la classe `ExampleModConfig2` à la place de `ExampleModConfig` partout. Nous l'appelons aussi `secondary` pour aller avec le nom `main` de notre config originale. +Maintenant vous pouvez ajouter les champs que vous voulez ! Avec Quilt Config, vous pouvez répéter ce procédé autant que vous le voulez, tant qu'aucunes des configs n'ont des noms en doublons. diff --git a/wiki/configuration/config-screen/fr.md b/wiki/configuration/config-screen/fr.md new file mode 100644 index 00000000..f03a4e6c --- /dev/null +++ b/wiki/configuration/config-screen/fr.md @@ -0,0 +1 @@ +cette page sera remplie une fois que les QSL auront de la generation d'écran de configuration automatique ! sauf si quelqu'un veut l'écrire pour spruceui par exemple diff --git a/wiki/configuration/getting-started/en.md b/wiki/configuration/getting-started/en.md index 742f8817..13384ab5 100644 --- a/wiki/configuration/getting-started/en.md +++ b/wiki/configuration/getting-started/en.md @@ -1,11 +1,13 @@ -# Getting started with Quilt Config +# Getting Started with Quilt Config [Quilt Config](https://github.com/QuiltMC/quilt-config) is Quilt's powerful configuration API. It allows developers (that's you!) to easily set up values that can be changed by the user in order to change the behaviour of your mod. It's built into [Quilt Loader](https://github.com/QuiltMC/quilt-loader) to allow any Quilt mod to leverage it without having to pull in new dependencies or run any setup. ## Setting up your config In this tutorial, we're going to be building a simple mod that prints a line of text to the console when it's initialized. Keep in mind that this is an example, and your mod can use config values anywhere you want! You can view of the final source code of this tutorial [on GitHub](https://github.com/ix0rai/quilt-config-example-mod). + + To begin with Quilt Config, you'll need a dedicated class for holding your config. For an extremely configurable mod, you may want to break up your config into multiple files inside a `config` package, but for this tutorial and most mods we're going to put everything in one file. Let's create a new file for our config, in the same directory as our mod initializer. We'll call it `ExampleModConfig`, but you can call it whatever you want. This new config class will extend the `ReflectiveConfig` API, which will provide everything we need to get the config working. @@ -21,7 +23,8 @@ public class ExampleModConfig extends ReflectiveConfig { ``` Now that big line in the middle may seem intimidating, but we're going to break it down. -- First, `public static final` means that the value never changes (though data *stored* in the config can), and `instance` is a fancy programmer word that just means it's an object of a class. We create the object in this way since it's the only instance of the config we'll ever be making. + +- First, `public static final` means that the value never changes (though data _stored_ in the config can), and `instance` is a fancy programmer word that just means it's an object of a class. We create the object in this way since it's the only instance of the config we'll ever be making. - Second, we're calling the method `QuiltConfig.create(String family, String id, Class configCreatorClass)`. As you can see, it takes three parameters: - The string `family`, which indicates the directory that your config file will be stored in, relative to the global config directory (usually `/config`). We're using our mod ID as the directory, and that's the best practice. - A second string, `id`, which will be the name of the configuration file (before the file extension is added, which changes depending on the format you choose). Here we use our mod ID once again, but if you have a complicated config with multiple files you'll want to use a different name. @@ -41,8 +44,9 @@ public class ExampleModConfig extends ReflectiveConfig { ``` We're introducing a bunch of things with one line again. Lovely! Let's dig into it: -- This value is `public final`, which means that instead of being accessible by anything you need an instance of `ExampleModConfig` first. Note that you *must* use `public final` whenever creating a config value using Quilt Config. Since we defined our `INSTANCE` field already, we'll be able to access this from anywhere via `ExampleModConfig.INSTANCE.message`. -- The type is `TrackedValue`. The angle brackets (`<>`) allow us to use what's called *generics*, which in Java are a way to adapt a class to your specific use case. Here, the `TrackedValue` class allows us to adapt the type of object it holds, so we use it to store a `String`. Thanks to the generics, we could put another type inside those brackets later to store a different kind of value! This is foreshadowing. We're going to store some different values. Get ready. + +- This value is `public final`, which means that instead of being accessible by anything you need an instance of `ExampleModConfig` first. Note that you _must_ use `public final` whenever creating a config value using Quilt Config. Since we defined our `INSTANCE` field already, we'll be able to access this from anywhere via `ExampleModConfig.INSTANCE.message`. +- The type is `TrackedValue`. The angle brackets (`<>`) allow us to use what's called _generics_, which in Java are a way to adapt a class to your specific use case. Here, the `TrackedValue` class allows us to adapt the type of object it holds, so we use it to store a `String`. Thanks to the generics, we could put another type inside those brackets later to store a different kind of value! This is foreshadowing. We're going to store some different values. Get ready. - We call the `value` method, which comes from the `ReflectiveConfig` class we're extending. This method takes one parameter, which will be the default value of that config field. Here, the author of this tutorial is using it to self-advertise. Phew. We got through it! That'll be the final big information dump of this tutorial, and we can begin having some fun. Now that we have a field in our config, we can pop back over to our mod initializer and start using it! @@ -79,8 +83,9 @@ public class ExampleModConfig extends ReflectiveConfig { ``` We're not going to show the changes to the code to use each one of these values, but remember you can see how they're used in the [final code](https://github.com/ix0rai/quilt-config-example-mod). Let's get back on our bullet points to explain this snippet! + - `IntegerRange` is an annotation: it adds new functionality to our field, outside the normal declaration. `IntegerRange` allows us to limit the allowed values of our `Integer` field, to between `min` and `max` (inclusively). -- We've changed the type from `String` to `Integer`. Now, why `Integer` instead of `int` like we would use for a normal number field? `int` is a *primitive type*, which means that it isn't actually a class! Since generics can only take classes, Java provides class versions of each primitive. `boolean` becomes `Boolean`, `float` becomes `Float`, `double` becomes `Double`, `char` becomes `Character`, etc etc. +- We've changed the type from `String` to `Integer`. Now, why `Integer` instead of `int` like we would use for a normal number field? `int` is a _primitive type_, which means that it isn't actually a class! Since generics can only take classes, Java provides class versions of each primitive. `boolean` becomes `Boolean`, `float` becomes `Float`, `double` becomes `Double`, `char` becomes `Character`, etc etc. Something incredibly important to remember is that you can't just send any class into `TrackedValue`'s generics: Quilt Config has to know how to serialize it. By default, all [primitive types](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html) are serializable, as well as the `String` class. We'll cover how to explain to Quilt Config how to serialize a class later, but first: more fun with annotations! @@ -116,7 +121,7 @@ Problem solved! Now it'll follow the Java conventions in the Java code, and the ## Maps and lists -Two of the most common data structures used in Java programming are `Map` and `List`. Quilt Config provides convenient serializable versions of both of these in the for of `ValueMap` and `ValueList`! +Two of the most common data structures used in Java programming are `Map` and `List`. Quilt Config provides convenient serializable versions of both of these in the form of `ValueMap` and `ValueList`! Starting with maps, `ReflectiveConfig` provides us a handy `map` method to help us easily make a default value. @@ -135,6 +140,7 @@ public class ExampleModConfig extends ReflectiveConfig { ``` There are a few things of note here: + - We have to pass an empty string (`""`) to the `map` method, in order for it to understand that the map stores values of the type `String`. This value is not used beyond checking the type, so you can put whatever you'd like there. - `ValueMap` always uses `String` as the type for its keys, instead of having you pick like most Java `Map` implementations. - We can put as many values in the default map as we'd like. If the author wanted to replace every single Quilt developer with herself instead of just the admins, that would be possible! @@ -150,4 +156,4 @@ public class ExampleModConfig extends ReflectiveConfig { } ``` -This is pretty similar to building a map. Here, instead of chaining `put` calls on a builder, we simply add as many values as we want directly in the constructor. Again, the first argument is unused and is to help Quilt Config infer the type. With that, we've made an excellent little config for our mod! If you want to know more, let's move on to the [Advanced Configuring tutorial](https://wiki.quiltmc.org/en/configuration/advanced-configuring). +This is pretty similar to building a map. Here, instead of chaining `put` calls on a builder, we simply add as many values as we want directly in the constructor. Again, the first argument is unused and is to help Quilt Config infer the type. With that, we've made an excellent little config for our mod! If you want to know more, let's move on to the [Advanced Configuring tutorial](../configuration/advanced-configuring). diff --git a/wiki/configuration/getting-started/fr.md b/wiki/configuration/getting-started/fr.md new file mode 100644 index 00000000..8d123931 --- /dev/null +++ b/wiki/configuration/getting-started/fr.md @@ -0,0 +1,159 @@ +# Débuter avec Quilt Config + +[Quilt Config](https://github.com/QuiltMC/quilt-config) est la puissante API de configuration de Quilt. Elle permet aux developpeur·euse·s (c'est vous !) de facilement mettre en place des valeurs qui peuvent être modifiées par l'utilisateur·ice pour changer le comportement de votre mod. Elle est inclue dans le [Quilt Loader](https://github.com/QuiltMC/quilt-loader) pour permettre à n'importe quel mod Quilt de l'utiliser sans importer de nouvelles dépendences ou lancer de setup. + +## Mettre en place votre config + +Dans ce tutorial, nous allons constuire un mod simple qui écrit une ligne de texte dans la console quand il est initilisé. N'oubliez pas que c'est un exemple et votre mod peut utiliser les valeurs de la config n'importe où ! Vous pouvez voir le code source complété de ce tutoriel [sur GitHub](https://github.com/ix0rai/quilt-config-example-mod). + + + +Pour débuter avec Quilt Config, vous aurez besoin d'une classe dédiée pour contenir votre config. Pour un mod extrémement configurable, vous pourriez vouloir séparer votre config dans plusieurs fichiers dans un package `config`, mais pour ce tutoriel et la majorité des mods nous allons tout mettre dans un seul fichier. + +Créons un nouveau fichier pour notre config, dans le même dossier que notre `ModInitializer`. Nous l'appelerons `ExampleModConfig`, mais vous pouvez l'appeler comme vous voulez. Cette nouvelle classe de configuration hérite de l'API `ReflectiveConfig` qui fournit tout ce dont nous avons besoin pour faire fonctionner la config. + +Nous commencerons avec ce code : + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +public class ExampleModConfig extends ReflectiveConfig { + public static final ExampleModConfig INSTANCE = QuiltConfig.create(ExampleMod.MOD_ID, ExampleMod.MOD_ID, ExampleModConfig.class); +} +``` + +Cette grosse ligne au milieu peut sembler intimidante alors on va l'expliquer morceau par morceau. + +- D'abord, `public static final` signifie que la valeur ne peut jamais changer (bien que les données _contenues_ dans la config le peuvent) et `instance` est un mot utilisé par les programmeur·euse·s pour désigner l'objet d'une classe. On créé cet object de cette manière car c'est la seule instance de la config que nous ferons. +- Ensuite, nous appelons la méthode `QuiltConfig.create(String family, String id, Class configCreatorClass)`. Comme vous pouvez le voir elle prend trois paramètres : + - Le string `family`, qui indique le dossier dans lequel votre config sera stockée, par rapport au dossier de configuration global (en général `/config`). Nous utiliserons l'ID de notre mod comme dossier et c'est une bonne pratique. + - Un deuxième string `id`, qui sera le nom du fichier de configuration (avant que l'extension de fichier soit ajouté, ce qui change en fonction du format que vous choisissez). Ici nous utilisons à nouveau l'ID de notre mod mais si vous avez une config compliqué avec plusieurs fichiers vous voudrez utiliser différents noms. + - Enfin, quelque-chose de bizarre : c'est quoi un `Class configCreatorClass` ? On ne va pas trop s'occuper des détails : passez simplement le nom de votre classe de configuration avec `.class` ajouté à la fin, comme on l'a fait ici avec `ExampleModConfig.class`. + +## Ajouter des valeurs + +Voilà ! Nous avons maintenant une config à laquelle nous pouvons accéder partout dans notre projet. Le problème étant, on n'a aucune raison d'y accéder parce qu'il n'y a rien. Réglons ce problème en ajoutant une valeur ! Notre mod d'exemple écrit une ligne de texte dans la console au démarage : pourquoi pas permettre à l'utilisateur·ice de choisir quelle est cette ligne. Ajoutons un deuxième champ dans notre config : + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +public class ExampleModConfig extends ReflectiveConfig { + // ... + public final TrackedValue message = this.value("rai minecraft :thumbsup:"); +} +``` + +On présente encore plein de choses avec cette seule ligne ! Regardons tout ça : + +- Cette valeur est `public final`, ce qui signifie qu'au lieu d'être accessible par n'importe quoi il faut d'abord une instance de `ExampleModConfig`. Notez qu'il _faut_ utiliser `public final` quand vous créer une valeur de config en utilisant Quilt Config. Vu qu'on a déjà défini notre champ `INSTANCE`, nous pourrons cette valeur n'importe où via `ExampleModConfig.INSTANCE.message`. +- Le type est `TrackedValue`) nous permettent d'utiliser des _generics_, une méthode d'adapter une classe à votre besoin spécifique en Java. Ici, la classe `TrackedValue` nous permet d'adapter le type d'objet qu'elle contient, donc nous l'utilisons pour contenir un `String`. Grâce aux generics, nous pourrions mettre un autre type dans ces chevrons plus tard pour contenir un autre type de valeur ! C'est du foreshadowing. Nous allons stocker d'autres valeurs. Soyez prêt·e·s. +- Nous appelons la méthode `value`, qui vient de la classe `ReflectiveConfig` dont on hérite. Cette méthode prend un paramètre, qui sera la valeur par défaut d'une valeur de configuration. Ici, l'autrice originale de ce tutoriel l'utilise pour pour faire sa promo. + +Ouf. On s'en est sorti ! C'était le dernier gros afflux d'informations de ce tutoriel et on peut commencer à s'amuser un peu. Maintenant qu'on a un champ dans notre config, on peut retourner à notre `ModInitializer` et commencer à l'utiliser ! + +`src/main/com/example/example_mod/ExampleMod`: + +```java +public class ExampleMod implements ModInitializer { + // ... + + @Override + public void onInitialize(ModContainer mod) { + LOGGER.info(ExampleModConfig.message.value()); + } +} +``` + +Comme le champ `message` est une `TrackedValue` et pas un simple `String`, nous devons appeler sa méthode `value` pour récupérer sa valeur et pouvoir l'écrire dasn la console. Nous pourrons aussi utiliser la méthode `setValue` pour changer la valeur depuis le code. + +Maintenant notre mod écrit un message personnalisé dans la console au démarage ! Bien que cela nous permettrait facilement d'obtenir 1 million de téléchargements, Quilt Config nous permet de faire beaucoup plus que ça. + +## Utiliser des annotations + +Ajoutons un deuxième champ. Ici nous allons faire quelque chose d'un peu plus recherché en utilisant à la fois un nouveau type de données et une des nombreuses annotations de Quilt Config. + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +public class ExampleModConfig extends ReflectiveConfig { + // ... + @IntegerRange(min = 0, max = 10) + public final TrackedValue timesToPrint = this.value(1); +} +``` + +Nous n'allons pas montrer les changements dans le code pour utiliser chacune de ces valeurs mais n'oubliez pas que vous pouvez voir comment elles sont utilisées dans le [code terminé](https://github.com/ix0rai/quilt-config-example-mod). Revenons à nos listes à puces pour expliquer cet extrait ! + +- `IntegerRange` est une annotation : elle ajoute un nouvelle fonctionnalité à notre champ, au délà de la déclaration normale. `IntegerRange` nous permet de limiter les valeurs possibles de notre champ `Integer`, pour qu'elles soient contenues entre `min` et `max` (de manière inclusive). +- Nous avons changé le type de `String` à `Integer`. Pourquoi `Integer` au lieu de `int` comme nous l'utiliserions pour un champ numérique normal ? `int` est un _type primitif_, ce qui signifie que ce n'est pas une classe ! Comme les generics ne peuvent prendre que des classes, Java fournit des classes pour chaque primitive. `boolean` devient `Boolean`, `float` devient `Float`, `double` devient `Double`, `char` devient `Character`, etc, etc. + +Quelque chose de primordial à ne pas oublier est que vous ne pouvez pas simplement mettre n'importe quelle classe dans les generics de `TrackedValue` : Quilt Config doit savoir comment le sérialiser. Par défaut, tous les [types primitifs](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html) sont sérialisables ainsi que la classe `String`. Nous expliquerons comment dire à Quilt Config comment sérialiser une classe plus tard mais d'abord : plus de fun avec des annotations ! + +Nouvelle valeur ! + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +public class ExampleModConfig extends ReflectiveConfig { + // ... + @Comment("Whether to print the message at all.") + public final TrackedValue print = this.value(true); +} +``` + +Ici on utilise l'annotation `Comment` pour ajouter un commentaire expliquant exactement ce que fait le champs de la configuration. Ça sera sauvegarder par Quilt Config dans le fichier de configuration, tant que le format que vous utilisez permet les commentaires. Pratique ! + +Enfin, nous allons utiliser une autre annotation pour conclure. Par défaut, Quilt Config serialise en [TOML](https://toml.io/en/) qui a quelques standards que l'on ne suit pas. En Java, les champs `public final` sont nommés en utilisant la `lowerCamelCase`, comme notre champ `timesToPrint`. Mais, dans des fichiers TOML, les noms devrait utiliser la `snake_case`, signifiant que nous devrions nommer le champ `times_to_print`. Pour suivre les deux conventions, nous pouvons utiliser l'annotation `SerializedName` ! + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +public class ExampleModConfig extends ReflectiveConfig { + // ... + @IntegerRange(min = 0, max = 10) + @SerializedName("times_to_print") + public final TrackedValue timesToPrint = this.value(1); + // ... +} +``` + +Problème résolu ! Maintenant notre champ suit la convention de Java dans le code Java et la convention de TOML dans le fichier TOML. Nous pouvons utiliser l'annotation `SerializedName` pour tous les champs de config avec des noms à plusieurs mots pour résoudre notre problème partout. + +## Maps and lists + +Deux des structures de données les plus communes utilisées en Java sont les `Map` et les `List`. Quilt Config fournit des versions pratiques et sérialisables de ces structures de données avec `ValueMap` et `ValueList` ! + +En commençant avec les maps, `ReflectiveConfig` nous fournit une méthode `map` pour nous aider à créer une valeur par défaut facilement. + +`src/main/com/example/example_mod/ExampleModConfig`: + +```java +public class ExampleModConfig extends ReflectiveConfig { + // ... + @Comment("When a key in this map shows up in the message, it'll be replaced with the corresponding value.") + public final TrackedValue> replacements = this.map("") + .put("oro armor", "rai minecraft") + .put("lambda aurora", "rai minecraft") + .put("tib s", "rai minecraft") + .build(); +} +``` + +Il y a quelques éléments intéressants ici : + +- Nous devons passer un string vide (`""`) à la méthode `map` pour qu'elle comprenne que la map stocke des valeurs de type `String`. Cette valeur n'est pas utilisée pour autre chose que vérifier les types donc vous pouvez mettre n'importe quoi ici. +- `ValueMap` utilise toujours `String` comme type pour ses clefs, au lieu de vous permettre de choisir comme avec la plupart des implémentations de `Map` en Java. +- On peut mettre autant de valeur que l'ont veut dans la map par défaut. Si l'autrice voulait remplacer tous les développeur·euse·s Quilt avec elle-même au lieu de se limiter aux admins, ça serait possible ! + +Maintenant que l'on sait comment utiliser des maps, continuons avec les listes ! + +```java +public class ExampleModConfig extends ReflectiveConfig { + // ... + @Comment("This isn't actually used by the mod, but I was completely out of ideas for things to add.") + @SerializedName("types_of_soup") + public final TrackedValue> typesOfSoup = this.list("", "tomato", "borscht", "chicken noodle", "ramen", "STEW", "mushroom"); +} +``` + +C'est assez similaire à la création d'une map. Ici, au lieu de d'enchainer des appels à `puts` sur un builder, on ajoute simplement autant de valeur que l'on veut directement dans le constructeur. Encore une fois, le premier argument n'est pas utilisé et est ici pour aider Quilt Config à déduire le type. Ceci étant fait, nous avons fait une excellente petite config pour notre mod ! Si vous voulez en apprendre plus, continuons avec le tutoriel de [Configuration Avancée](../configuration/advanced-configuring). diff --git a/wiki/configuration/metadata/en.md b/wiki/configuration/metadata/en.md index 82578a3f..827e2d84 100644 --- a/wiki/configuration/metadata/en.md +++ b/wiki/configuration/metadata/en.md @@ -29,16 +29,18 @@ On startup and when the annotated field is changed, checks if the `String` value - Can only be applied once per member Allows you to set up methods that will run before the config is initialized. Takes a `String` parameter that matches the method name of a method inside your class: this method will be run before config initialization. You must give the method one parameter corresponding to the type annotated with `@Processor`: + - When used on a tracked value, the processor method will take a `TrackedValue.Builder` as its parameter. - When used on a section, the processor method will take a `SectionBuilder` as its parameter. - When used on a config class, the processor method will take a `Config.Builder` as its parameter. Processors allow you to do a large variety of things, including: + - Running custom code when values are edited - Adding new values and sections programmatically - Dynamically updating metadata -You can see example processors and a more in-depth look at their usage in the [advanced configuring tutorial](https://wiki.quiltmc.org/en/configuration/advanced-configuring). +You can see example processors and a more in-depth look at their usage in the [advanced configuring tutorial](../configuration/advanced-configuring#using-processors). ## `@SerializedName` diff --git a/wiki/configuration/metadata/fr.md b/wiki/configuration/metadata/fr.md new file mode 100644 index 00000000..ba09fb64 --- /dev/null +++ b/wiki/configuration/metadata/fr.md @@ -0,0 +1,64 @@ +# Référence pour les Annotations et les Métadonnées + +Quilt Config est plein d'annotations qui vous permettent toutes d'étendre les fonctionnalités de votre config ! Cette page sert de référence, donnant un apperçu des fonctionnalités de chaque annotation. Des informations plus en profondeurs peuvent être trouvées dans la Javadoc de chaque annotation. + +## `@Comment` + +- Utilisable sur les champs et les sections de configuration +- Peut être répété à l'infini sur un élément + +Vous permet d'attacher des commentaires à vos champs qui sont sauvegardés comme métadonnées. Par défaut ils seront sérialisés dans le fichier de configuration dans les formats `toml` et `json5`. Comme ils sont sauvegardés comme métadonnée, vous pouvez y accéder n'importe où où vous avez acès aux `TrackedValue` pour les champs de votre config, signifiant que vous pouvez les afficher dans des écrans de configuration ou autre. + +## `@FloatRange` et `@IntegerRange` + +- Utilisables sur les champs de configuration de type `Float` et `Integer` respectivement +- Ne peut être utilisée qu'une fois par élément + +Au démarrage et quand les champs avec ces annotations sont modifiés, vérifie si les valeurs des champs sont bien contenues entre les `min` et `max` fournient, de manière inclusive. Si ce n'est pas le cas, lance une erreur `TrackedValueException`. + +## `@Matches` + +- Utilisable sur les champs de configuration de type `String` +- Ne peut être utilisée qu'une fois par élément + +Au démarage et quand les champs avec cette annotations sont modifiés, vérifie si les valeurs de ces champs correspondent à l'[expression régulière](https://regexr.com/) fournie. Si ce n'est pas le cas, lance une erreur `TrackedValueException`. + +## `@Processor` + +- Utilisable sur les champs, les sections et les classes de configuration +- Ne peut être utilisée qu'une fois par élément + +Permet de mettre en place des méthodes qui seront appelées avant que la config ne soit initialisée. Prend un paramètre `String` qui correspond le nom d'une méthode dans votre classe : cette méthode sera appelée avant l'initialisation de la config. Vous devez une paramètre à la méthode correspondant au type avec l'annotation `@Processor` : + +- Quand utilisé avec une valeur, la méthode du processeur prendra un `TrackedValue.Builder` comme paramètre. +- Quand utilisé avec une section, la méthode du processeur prendra un `SectionBuilder` comme paramètre. +- Quand utilisé avec une classe de configuration, la méthode du processeur prendra un `Config.Builder` comme paramètre. + +Les processeurs vous permettent de faire une grande variété de choses, comme par exemple : + +- Appeler du code personnalisé quand des valeurs sont modifiées +- Ajouter des nouvelles valeurs et sections via du code +- Changer dynamiquement les métadonnées + +Vous pouvez voir des processeurs d'exemple et une apperçu plus en profondeur de leurs usages dans le [tutoriel de configuration avancée](../configuration/advanced-configuring#utiliser-des-processeurs). + +## `@SerializedName` + +- Utilisable sur les champs et section de configuration +- Ne peut être utilisée qu'une fois par élément + +Ajoute une métadonnée `String` utilisée comme le nom qui sera sérialisé dans le fichier de configuration. Le nom par défaut reste en fallback : si le nom sérialisé n'est pas présent dans le fichier pendant la désérialisation, le nom par défaut sera utilisé. Le nom par défaut sera toujours utilisé pour écrire dans le fichier. + +## `@SerializedNameConvention` + +- Utilisable sur les champs, les section et les classes de configuration +- Ne peut être utilisée qu'une fois par élément + +Ajoute des métadonnées sur la convention de nommage pour chaque champ dans la classe de configuration qui dictent quel convention utiliser pour sauvegarder dans la config. Cela transformera le nom par défaut du champ pour appliquer la convention contenue dans les métadonnées. Si le nom a une annotation `@SerializedName` elle prendra la priorité sur celle-ci. Les options de conventions de nommages sont documentées dans `NamingSchemes`. Quand cette annotation est utilisée sur un champs ou une section dans un parent qui a aussi cette annotation, remplace la valeur du parent pour cet élément seulement (par exemple, si une classe a cette annotation avec une certaine convention et un champs dans cette classe a aussi cette annotation avec une autre convention, le champ prendra la convention de son annotation à lui). + +## `@Alias` + +- Utilisable sur les champs et les section de configuration +- Peut être répété à l'infini sur un élément + +Ajoute des métadonnées précissant d'autres noms pour cet élément. Ces noms seront pris en compte pendant la désérialisation mais ne seront jamais écrit dans le fichier de configuration. Vous pouvez par exemple utiliser cette annotation avec d'anciens noms utilisés pour un champs afin de faciliter la mise à jour des configurations ! diff --git a/wiki/introduction/get-started/fr.md b/wiki/introduction/get-started/fr.md index 3055c34f..959a0401 100644 --- a/wiki/introduction/get-started/fr.md +++ b/wiki/introduction/get-started/fr.md @@ -8,13 +8,13 @@ Pour commencer à modder Minecraft, vous aurez besoins de deux choses. la programmation orientée objet et quelques patrons de conception essentiels. - Des connaissances de base sur [Git](https://git-scm.com). Bien que techniquement non essentiel, c'est un outil qui vous facilitera grandement la vie. Cela inclut de savoir comment cloner des - dépôts et comment faire des commits. + dépôts et comment faire des commits. De bonnes ressources pour débuter sont la [documentation de Git](https://git-scm.com/doc) et la [documentation de GitHub](https://docs.github.com/en/get-started). -TODO: Is there anything more to be described here? + ## Comment Utiliser ce Wiki -TODO: Create example code repository and put it here +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) @@ -22,7 +22,17 @@ La plupart des pages contiennent des extraits de code, et des exemples complets 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. -TODO: Give an outline of all of the wiki articles once they're ready +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). + +Pour des ecplications plus générales, vous pouvez regarder dans la catégorie "Concepts" : + +- Dans [Aperçu des QSL et de la QFAPI](../concepts/qsl-qfapi) vous avez un apperçu des Quilt Standard Libraries et de la Quilted Fabric API, les APIs officielles de Quilt. + +De nombreux autres articles sont prévus mais pas encore réalisés ([Issue #69](https://github.com/QuiltMC/developer-wiki/issues/69)). Cette section sera mise à jour plus tard. + + ## Comment apprendre à Modder, pour les Débutants @@ -34,7 +44,9 @@ Poser des questions correctement (et en anglais), que ce soit sur notre forum ou une compétence essentielle à avoir. N'ayez jamais peur de poser des questions, nous sommes toujours prêts à aider, et on ne juge pas. -TODO: Methodology for asking questions here +Quand vous posez des questions, essayez d'inclure le contexte nécessaire dans le premier message et [ne demandez pas si vous pouvez poser une question](https://dontasktoask.com/). Décrivez votre problème, ce que vous avez déjà essayé pour le résoudre, et comment ces tentatives ont échouées. Assurez vous de ne pas poser de questions sur une partie spécifique d'une solution à votre problème mais de bien expliquer le problème en lui même (voir [XY problem](https://xyproblem.info/)). Quand vous déboguez, incluez votre `latest.log` et quand votre jeu crash, un crash log. De plus, un accès complet à votre code source peut vraiment aider, idéalement disponible en ligne sur un site tel que GitHub. + +Vous pouvez demander des questions liées au développement dans notre [Forum](https://forum.quiltmc.org/), ainsi que sur le salon de forum [mod-dev-help](https://discord.com/channels/817576132726620200/1047429688521396325) de notre [Discord](https://discord.quiltmc.org/). De nombreux problèmes liés au moddage ont déjà été résolus et sont disponibles publiquement afin que vous puissiez les voir et les réutiliser car la plupart des mods pour Quilt @@ -42,7 +54,9 @@ sont open source. Nous vous recommandons de regarder des exemples de comment fai dans des dépôts open source et parfois de "voler" du code. Les dépôts open source sont là pour que vous puissiez en apprendre, n'ayez pas peur de les utiliser ! -TODO: Levi write your thing about stealing code here +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". + + ## Les différences entre Fabric et Quilt diff --git a/wiki/introduction/setting-up/fr.md b/wiki/introduction/setting-up/fr.md index 32e43a79..20cef59d 100644 --- a/wiki/introduction/setting-up/fr.md +++ b/wiki/introduction/setting-up/fr.md @@ -5,7 +5,7 @@ Vous aurez besoin de deux choses avant de commencer. - Un Kit de Développement Java (JDK) pour Java 17 (recommandé) ou supérieur. Les Kits de Développement Temurin Adoptium sont facilement disponibles et recommandés. Vous pouvez les télécharger ici : -- Un IDE pour Java, comme [IntelliJ Idea](https://www.jetbrains.com/idea/) ou [Eclipse](https://www.eclipse.org/ide/). +- Un IDE pour Java, comme [IntelliJ IDEA](https://www.jetbrains.com/idea/) ou [Eclipse](https://www.eclipse.org/ide/). [Visual Studio Code](https://code.visualstudio.com/) peut fonctionner, mais cela demande plus de travail pour le mettre en place. - Nous recommandons d'utiliser IntelliJ IDEA car il possède plus d'intégrations et est plus facile à utiliser. @@ -129,19 +129,18 @@ vous pouvez trouver un exemple finalisé ci-dessous : 3. `"metadata"`: 1. `"name"` devrait correspondre au nom de votre mod. Pas besoin de format spécifique, contrairement à l'identifiant de votre mod. - . `"description"` devrait correspondre à une courte description de votre mod. - 2. `"contributors"` devrait contenir une liste des personnes ayant partcipé à la création du mod, accompagnées de leurs rôles. + 2. `"description"` devrait correspondre à une courte description de votre mod. + 3. `"contributors"` devrait contenir une liste des personnes ayant partcipé à la création du mod, accompagnées de leurs rôles. Ce champ n'a pas de structure spécifique, vous pouvez y mettre ce que vous voulez. Si vous ne savez pas quoi mettre vous pouvez simplement mettre votre nom comme clé avec la valeur `"Owner"`. - 3. `"contact"` n'a pas de structure spécifique, comme `"contributors"`. + 4. `"contact"` n'a pas de structure spécifique, comme `"contributors"`. Cependant les gens y mettent en général des champs `"homepage"`, `"sources"` et `"issues"` avec comme valeur des URLs vers les pages correspondantes. - 4. Remplacez `example_mod` par l'identifiant de votre mod dans `"icon"`. + 5. Remplacez `example_mod` par l'identifiant de votre mod dans `"icon"`. 4. Dans `"entrypoints"`, remplacez `com.example.example_mod` par votre groupe maven suivit de l'identifiant de votre mod, et le `ExampleMod` à la fin devrait correspondre au nom de la classe Java principale de votre Mod. - Le nom de la classe Java correspond généralement au nom du mod, écrit en `UpperCamelCase` - (sans espaces entre les mots et chaque mot commence avec une Majuscule). + Le nom de la classe Java correspond généralement au nom du mod, écrit en `UpperCamelCase`. Cela signifie qu'au lieu d'utiliser des espaces pour séparer les mots, chaque mot commence par une majuscule. Contrairement au `lowerCamelCase`, la première lettre devrait assui être une majuscule. Par exemple dans notre cas on utiliserait `io.github.bingus.bingus_mod.BingusMod`. 5. Dans `"mixin"`, remplacez `example_mod` dans le nom du fichier par l'identifiant de votre mod. diff --git a/wiki/items/armor/fr.md b/wiki/items/armor/fr.md index d855c904..43463b43 100644 --- a/wiki/items/armor/fr.md +++ b/wiki/items/armor/fr.md @@ -58,7 +58,7 @@ public int getEnchantability() { --- Nous allons maintenant définir le son d'équipement de l'armure. -Si vous voulez ajouter un son personalisé, référez vous à [Ajouter des Sons](../misc/sounds). +Si vous voulez ajouter un son personnalisé, référez vous à [Ajouter des Sons](../misc/sounds). Si vous voulez utiliser un son existant, vous pouvez utiliser `SoundEvents.ITEM_ARMOR_EQUIP_GENERIC`, comme dans l'exemple ci-dessous. @@ -133,7 +133,7 @@ donc on passe les paramètres par défaut. --- -Ensuite, on enregistre l'armure dans notre 'mod initializer' et on l'ajoute dans le groupe d'item de combat. +Ensuite, on enregistre l'armure dans notre `ModInitializer` et on l'ajoute dans le groupe d'item de combat. Il y a deux choses à noter par rapport à ça : 1. On nomme les items d'armure par le nom du matériau avec leur emplacement d'armure.