[Java] Créons un Minecraft Mod 1.14.4 [9. Ajouter et générer des arbres]

(Cet article fait partie d'une série d'articles de commentaires)

Premier article: Introduction Article précédent: 8. Ajout et génération de minerai Article suivant: 99. Sortie Mod

Ajouter un arbre

Dans ce qui précède, nous avons appris comment ajouter du minerai. Ensuite, ajoutons un arbre et laissons le monde le générer. Cela devient compliqué, alors faisons de notre mieux ensemble.

Ajout de bois brut

Tout d'abord, ajoutez les blocs de journal qui composent Qi. Nous ajouterons des blocs en faisant référence à 2. Ajouter des blocs, mais il y a quelques différences, alors regardons-les dans l'ordre.

BlockList.java

//...
public class BlockList {
    public static Block ExampleLog = new LogBlock(
            MaterialColor.CYAN,
            Block.Properties.create(Material.WOOD, MaterialColor.BLUE)
                    .hardnessAndResistance(2.0F)
                    .sound(SoundType.WOOD)
                    .lightValue(6))
            .setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_log"));

    @SubscribeEvent
    public static void registerBlocks(RegistryEvent.Register<Block> event) {
        event.getRegistry().registerAll(
                ExampleLog
        );
    }

    @SubscribeEvent
    public static void registerBlockItems(RegistryEvent.Register<Item> event) {
        event.getRegistry().registerAll(
                new BlockItem(ExampleLog, new Item.Properties().group(ExampleItemGroup.DEFAULT))
                        .setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_log"))
        );
    }
}

C'est fondamentalement la même chose, mais ce n'est pas seulement une classe Block, c'est une classe LogBlock. Ceci est une sous-classe de RotatedPillarBlock, une sous-classe de la classe Block. RotatedPillarBlock est Block avec l'ajout de la rotation. Et il semble que LogBlock ait ajouté quelque chose lié à l'affichage sur la carte. L'argument du constructeur est incrémenté de 1 et passe la couleur à afficher sur la carte dans la classe MaterialColor. Block.Properties.create () a également plus d'arguments et transmet la couleur, mais c'est la couleur sur la carte au moment de l'installation non verticale, et il semble que la précédente soit la couleur au moment de l'installation verticale. Choisissez-les de manière appropriée.

Comme dans l'exemple, nous définirons resources, mais comme la texture du bloc de journal diffère selon la surface, ce paramètre est indiqué ci-dessous. Ceux-ci sont basés sur le bloc de journal de minecraft, donc cela ne pose pas de problème à moins que vous ne fassiez quelque chose de spécial.

\src\main\resources
   ├ assets
   │  └ example_mod
   │     ├ blockstates
   │     │  └ example_log.json
   │     ├ lang
   │     │  └ en_us.json
   │     │  └ ja_jp.json
   │     ├ models
   │     │  ├ block
   │     │  │  └ example_log.json
   │     │  └ item
   │     │     └ example_log.json
   │     └ textures
   │        ├ blocks
   │        │  ├ example_log.png
   │        │  └ example_log_top.png
   │        └ items
   └ data
      └ example_mod
         └ loot_tables
            └ blocks
               └ example_log.json

blockstates\example_log.json

{
  "variants": {
    "axis=y": { "model": "example_mod:block/example_log" },
    "axis=z": { "model": "example_mod:block/example_log", "x": 90 },
    "axis=x": { "model": "example_mod:block/example_log", "x": 90, "y": 90 }
  }
}

En écrivant comme ceci, la variable membre ʻaxis(direction du plan) de la classeLogBlock (à proprement parler, RotatedPillarBlock`) sera branchée conditionnellement en fonction de x, y ou z. Je suis. (Document officiel dit également quelque chose comme ça.) Des descriptions telles que «x»: 90 »« y »: 90» sont des angles de rotation. En bref, il est tourné de sorte que l'affichage soit une bûche inclinée en fonction de l'état d'installation verticale.

models\block\example_log.json

{
  "parent": "block/cube_column",
  "textures": {
    "end": "example_mod:blocks/example_log_top",
    "side": "example_mod:blocks/example_log"
  }
}

Spécifiez block / cube_column pour parent. Cela vous permet d'appliquer des textures cubiques et de faire la distinction entre le haut et le bas et les côtés. Spécifions le chemin vers chaque fichier de texture.

models\item\example_log.json

{
  "parent": "example_mod:block/example_log"
}

Cela peut être fait en héritant du fichier modèle de block comme auparavant.

en_us.jp

{
  "block.example_mod.example_log": "Example Log"
}

ja_jp.json

{
  "block.example_mod.example_log": "Exemple de journal"
}

Le fichier de langue est le même que précédemment.

\loot_table\blocks\example_log.json

{
  "type": "minecraft:block",
  "pools": [
    {
      "rolls": 1,
      "entries": [
        {
          "type": "minecraft:item",
          "name": "example_mod:example_log"
        }
      ]
    }
  ]
}

Comme d'habitude.

Vous avez ajouté un bloc avec des directions comme celle-ci.

** Il y a encore une chose à faire concernant les blocs de journaux. ** ** L'ajout de bloc lui-même a été terminé jusqu'à présent, mais il sera nécessaire au stade de la construction de l'arbre plus tard, alors faisons-le ici.

Ajoutez le bloc de journal que vous venez d'ajouter à la balise minecraft: logs. Comme je l'ai mentionné brièvement dans 6. Ajout de recettes, les "tags" sont un groupe d'objets qui ont des facteurs communs. Dans minecraft, il existe une balise qui résume l'équivalent du bois brut, et elle est utilisée lors du traitement lié aux arbres. Par conséquent, si vous incluez ce bloc de journal dans cette balise, vous pouvez éviter une implémentation inutile.

\src\main\resources
   ├ assets
   └ data
      ├ example_mod
      └ minecraft
         └ tags
            └ blocks
               └ logs.json

** Créez un dossier ** \ src \ main \ resources \ data \ minecraft \ tags \ blocks dans votre dossier de projet et placez-y logs.json. Assurez-vous que ce nom est le même.

logs.json

{
  "replace": false,
  "values": [
    "example_mod:example_log"
  ]
}

En donnant «false» à «remplacer», la description dans ce fichier sera intégrée dans «minecraft: logs» du même nom. Spécifions le bloc dans values.

Lorsque vous déplacez le curseur vers le bloc en mode débogage, si #minecraft: logs s'affiche comme la partie soulignée en rouge, vous avez terminé.

Ajouter des feuilles

Ensuite, ajoutez les blocs de feuilles qui composent l'arbre. Encore une fois, regardons la base dans l'ordre, en nous référant à 2. Ajout de blocs.

BlockList.java

//...
public class BlockList {
    public static Block ExampleLeaves = new LeavesBlock(
            Block.Properties.create(Material.LEAVES)
                    .hardnessAndResistance(0.2F)
                    .tickRandomly()
                    .sound(SoundType.PLANT)
                    .lightValue(8))
            .setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_leaves"));

    @SubscribeEvent
    public static void registerBlocks(RegistryEvent.Register<Block> event) {
        event.getRegistry().registerAll(
                ExampleLeaves
        );
    }

    @SubscribeEvent
    public static void registerBlockItems(RegistryEvent.Register<Item> event) {
        event.getRegistry().registerAll(
                new BlockItem(ExampleLeaves, new Item.Properties().group(ExampleItemGroup.DEFAULT))
                        .setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_leaves"))
        );
    }
}

Les blocs de feuilles sont fabriqués avec «Leaves Block». D'autres sont comme d'habitude.

Configurez resources.

\src\main\resources
   ├ assets
   │  └ example_mod
   │     ├ blockstates
   │     │  └ example_leaves.json
   │     ├ lang
   │     │  └ en_us.json
   │     │  └ ja_jp.json
   │     ├ models
   │     │  ├ block
   │     │  │  └ example_leaves.json
   │     │  └ item
   │     │     └ example_leaves.json
   │     └ textures
   │        ├ blocks
   │        │  └ example_leaves.png
   │        └ items
   └ data
      └ example_mod
         └ loot_tables
            └ blocks
               └ example_leaves.json

blockstates\example_leaves.json

{
  "variants": {
    "": { "model": "example_mod:block/example_leaves" }
  }
}

models\block\example_leaves.json

{
  "parent": "block/leaves",
  "textures": {
    "all": "example_mod:blocks/example_leaves"
  }
}

Spécifiez «bloc / feuilles» pour «parent». Vous pouvez appliquer des textures translucides (en fonction de vos paramètres graphiques).

models\item\example_leaves.json

{
  "parent": "example_mod:block/example_leaves"
}

en_us.jp

{
  "block.example_mod.example_leaves": "Example Leaves"
}

ja_jp.json

{
  "block.example_mod.example_leaves": "Exemple de feuille"
}

Ce sont comme d'habitude.

\loot_table\blocks\example_log.json

{
  "type": "minecraft:block",
  "pools": [
    {
      "rolls": 1,
      "entries": [
        {
          "type": "minecraft:alternatives",
          "children": [
            {
              "type": "minecraft:item",
              "conditions": [
                {
                  "condition": "minecraft:alternative",
                  "terms": [
                    {
                      "condition": "minecraft:match_tool",
                      "predicate": {
                        "item": "minecraft:shears"
                      }
                    },
                    {
                      "condition": "minecraft:match_tool",
                      "predicate": {
                        "enchantments": [
                          {
                            "enchantment": "minecraft:silk_touch",
                            "levels": {
                              "min": 1
                            }
                          }
                        ]
                      }
                    }
                  ]
                }
              ],
              "name": "example_mod:example_leaves"
            },
            {
              "type": "minecraft:item",
              "conditions": [
                {
                  "condition": "minecraft:survives_explosion"
                },
                {
                  "condition": "minecraft:table_bonus",
                  "enchantment": "minecraft:fortune",
                  "chances": [
                    0.05,
                    0.0625,
                    0.083333336,
                    0.1
                  ]
                }
              ],
              "name": "example_mod:example_sapling"
            }
          ]
        }
      ]
    }
  ]
}

Le fichier loot_table est assez différent jusqu'à présent. Les blocs de feuilles (que j'ai ignorés jusqu'à présent) ont plusieurs gouttes et dépendent des enchantements et des outils, donc lorsqu'ils sont mis en œuvre correctement, ils ressemblent à ceci. Pour plus de détails, voir [Page de référence](https://minecraft-ja.gamepedia.com/%E3%83%AB%E3%83%BC%E3%83%88%E3%83%86%E3%83%BC% Je laisserai l'explication à E3% 83% 96% E3% 83% AB), mais je l'expliquerai brièvement. C'est "une goutte d'un bloc, le nombre est un, il renvoie l'un des" enfants ". Il y a deux" enfants ", et il retourne le bloc de feuille lorsqu'il est cassé pour la première fois avec des ciseaux ou l'outil Silk Touch I. Choses. Ensuite, les plants sont renvoyés avec une probabilité aléatoire (probabilité accrue avec enchantement chanceux) dans d'autres cas. " Ici, il sortira en premier et l'ordre changera, mais nous ajouterons des semis dans la section suivante. Ceci est basé sur les feuilles orks de Minecraft. Regardons chacun d'eux et écrivons comme vous le souhaitez.

Enfin, définissez le paramètre «MaterialColor». Cela a pour effet que les feuilles et l'herbe changent de couleur en fonction du biome. Vous pouvez ignorer cela si cela vous gêne. Si vous l'ignorez, la même couleur sera affichée pour tous les biomes, alors préparez une texture avec cette couleur.

BlockList.java

//...
public class BlockList {
    //...
    @SubscribeEvent
    public static void registerBlockColors(ColorHandlerEvent.Block event) {
        event.getBlockColors().register((p_210229_0_, p_210229_1_, p_210229_2_, p_210229_3_) -> {
            return p_210229_1_ != null && p_210229_2_ != null ? BiomeColors.getFoliageColor(p_210229_1_, p_210229_2_) : FoliageColors.getDefault();
        }, ExampleLeaves);
    }

    @SubscribeEvent
    public static void registerBlockItemColors(ColorHandlerEvent.Item event) {
        event.getItemColors().register((p_210235_1_, p_210235_2_) -> {
            BlockState blockstate = ((BlockItem)p_210235_1_.getItem()).getBlock().getDefaultState();
            return event.getBlockColors().getColor(blockstate, (IEnviromentBlockReader)null, (BlockPos)null, p_210235_2_);
        }, ExampleLeaves);
    }
}

Ceci est également enregistré en même temps avec BlockList.java qui est déclaré et enregistré. Il y a quelque chose qui s'appelle ColorHandlerEvent, donc cela sera reflété en utilisant register (). Faites-le pour chaque bloc et élément. Les variables, etc. sont une liste de caractères qui n'ont pas de sens, mais cela peut être changé car il est simplement extrait du code minecraft obscurci. Pour un bloc, BiomeColors.getFoliageColor () obtient la couleur en fonction du biome dans lequel le bloc existe et l'enregistre. Pour les éléments, la couleur par défaut est récupérée et enregistrée. Dans les deux cas, passez la couleur (obtenue par l'expression lambda) comme premier argument de register () et l'objet qui définit la couleur comme deuxième argument. Vous n'avez pas besoin de comprendre ce domaine en profondeur à moins d'essayer de faire des choses difficiles.

Pour la couleur réelle, [Page de référence](https://minecraft-ja.gamepedia.com/%E3%83%90%E3%82%A4%E3%82%AA%E3%83%BC%E3% 83% A0 # .E3.83.90.E3.82.A4.E3.82.AA.E3.83.BC.E3.83.A0.E3.82.AB.E3.83.A9.E3.83.BC Il est décrit en détail dans .E3.81.AE.E6.B1.BA.E5.AE.9A). Fondamentalement, il semble qu'une texture de bloc de feuilles en échelle de gris soit préparée et que la couleur y soit appliquée, mais lorsque j'ai préparé un fichier teinté cette fois, le bloc réel est également devenu cette teinte, donc probablement en interne Je me demande s'ils ajoutent.

Ajout de la classe TreeFeature et de la classe Tree

Celles-ci sont difficiles à expliquer avec des mots, mais les deux sont des classes qui gèrent les arbres. La classe Tree est une classe qui gère l'arbre lui-même et est requise en relation avec les plants qui seront ajoutés plus tard. D'autre part, la classe TreeFeature ne gère que les choses liées à la génération d'arbres, et vous pouvez également obtenir la TreeFeature correspondante de la classe Tree.

\src\main\java\jp\koteko\example_mod\
   ├ blocks
   │   └ trees
   │      └ ExampleTree.java
   ├ items
   ├ lists
   ├ world
   │   └ features
   │      └ ExampleTreeFeature.java
   └ ExampleMod.java

(Je vais me référer à la mise en page du fichier de différentes manières, mais si vous êtes inquiet, c'est tout à fait approprié.)

ExampleTreeFeature.java

package jp.koteko.example_mod.world.features;

import jp.koteko.example_mod.lists.BlockList;
import net.minecraft.world.gen.feature.NoFeatureConfig;
import net.minecraft.world.gen.feature.TreeFeature;
import net.minecraftforge.common.IPlantable;

public class ExampleTreeFeature extends TreeFeature {
    public ExampleTreeFeature() {
        super(NoFeatureConfig::deserialize, false, 4, BlockList.ExampleLog.getDefaultState(), BlockList.ExampleLeaves.getDefaultState(), false);
        setSapling((IPlantable) BlockList.ExampleSapling);
    }
}

Créez une classe ʻExampleTreeFeature en héritant de la classe TreeFeature. Les arguments à transmettre au constructeur de la source d'héritage sont les suivants dans l'ordre. Le premier argument n'est probablement pas particulièrement utile dans une instance de NoFeatureConfig. Le deuxième argument est la valeur booléenne qui détermine si une notification est possible ou non, et elle a été imitée parce qu'elle était fausse dans d'autres arbres. Je l'ajouterai quand je comprendrai quelque chose. Le troisième argument est la valeur ʻint qui détermine la hauteur minimale de l'arbre. Le quatrième argument est le «BlockState» du bloc de jonction. Le cinquième argument est le «BlockState» du bloc feuille. Le sixième argument est la valeur «booléenne» qui détermine s'il faut ou non faire pousser les vignes sur l'arbre. De plus, setSapling () définit les semis et transmet l'instance de semis ici. Les semis seront mis en œuvre dans la section suivante.

ExampleTree.java

package jp.koteko.example_mod.blocks.trees;

import jp.koteko.example_mod.world.features.ExampleTreeFeature;
import net.minecraft.block.trees.Tree;
import net.minecraft.world.gen.feature.AbstractTreeFeature;
import net.minecraft.world.gen.feature.NoFeatureConfig;

import javax.annotation.Nullable;
import java.util.Random;

public class ExampleTree extends Tree {
    @Nullable
    protected AbstractTreeFeature<NoFeatureConfig> getTreeFeature(Random random) {
        return new ExampleTreeFeature();
    }
}

Créez une classe ʻExampleTree en héritant de la classe abstraiteTree. Définissez une méthode appelée getTreeFeature. Retournons une instance de ʻExampleTreeFeature que nous avons définie précédemment. Je ne reçois pas un nombre aléatoire comme argument et je l'utilise, mais cela est utilisé lorsqu'un chêne, etc. est susceptible d'être divisé en une espèce normale et une espèce énorme.

Ajouter des semis

Ensuite, nous ajouterons des plants. Tout d'abord, préparez une classe de semis.

\src\main\java\jp\koteko\example_mod\
   ├ blocks
   │   ├ trees
   │   └ ExampleSapling.java
   ├ items
   ├ lists
   ├ world
   └ ExampleMod.java

BlockExampleSapling.java

package jp.koteko.example_mod.blocks;

import net.minecraft.block.Block;
import net.minecraft.block.BlockState;
import net.minecraft.block.BushBlock;
import net.minecraft.block.IGrowable;
import net.minecraft.block.trees.Tree;
import net.minecraft.state.IntegerProperty;
import net.minecraft.state.StateContainer;
import net.minecraft.state.properties.BlockStateProperties;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.shapes.ISelectionContext;
import net.minecraft.util.math.shapes.VoxelShape;
import net.minecraft.world.IBlockReader;
import net.minecraft.world.IWorld;
import net.minecraft.world.World;

import java.util.Random;

public class BlockExampleSapling extends BushBlock implements IGrowable {
    public static final IntegerProperty STAGE = BlockStateProperties.STAGE_0_1;
    protected static final VoxelShape SHAPE = Block.makeCuboidShape(2.0D, 0.0D, 2.0D, 14.0D, 12.0D, 14.0D);
    private final Tree tree;

    public BlockExampleSapling(Tree p_i48337_1_, Block.Properties properties) {
        super(properties);
        this.tree = p_i48337_1_;
        this.setDefaultState(this.stateContainer.getBaseState().with(STAGE, Integer.valueOf(0)));
    }

    public VoxelShape getShape(BlockState state, IBlockReader worldIn, BlockPos pos, ISelectionContext context) {
        return SHAPE;
    }

    public void tick(BlockState state, World worldIn, BlockPos pos, Random random) {
        super.tick(state, worldIn, pos, random);
        if (!worldIn.isAreaLoaded(pos, 1)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light
        if (worldIn.getLight(pos.up()) >= 9 && random.nextInt(7) == 0) {
            this.grow(worldIn, pos, state, random);
        }

    }

    public void grow(IWorld worldIn, BlockPos pos, BlockState state, Random rand) {
        if (state.get(STAGE) == 0) {
            worldIn.setBlockState(pos, state.cycle(STAGE), 4);
        } else {
            if (!net.minecraftforge.event.ForgeEventFactory.saplingGrowTree(worldIn, rand, pos)) return;
            this.tree.spawn(worldIn, pos, state, rand);
        }

    }

    /**
     * Whether this IGrowable can grow
     */
    public boolean canGrow(IBlockReader worldIn, BlockPos pos, BlockState state, boolean isClient) {
        return true;
    }

    public boolean canUseBonemeal(World worldIn, Random rand, BlockPos pos, BlockState state) {
        return (double)worldIn.rand.nextFloat() < 0.45D;
    }

    public void grow(World worldIn, Random rand, BlockPos pos, BlockState state) {
        this.grow(worldIn, pos, state, rand);
    }

    protected void fillStateContainer(StateContainer.Builder<Block, BlockState> builder) {
        builder.add(STAGE);
    }
}

En ce qui concerne ce code, ** (presque) tous sont les mêmes que le code pour les semis de minecraft **. La raison pour laquelle je l'ai fait est que le constructeur de la classe Sapling de minecraft est protégé et que je ne pouvais pas l'utiliser directement depuis le code du mod. Je n'ai pas eu assez de temps pour comprendre comment le côté minecraft gère cela, donc je ne l'envisagerai pas ici, mais je pense qu'il existe probablement une meilleure façon de l'implémenter d'une manière qui lui convient. Modifiez uniquement le nom du package, le nom de la classe et le constructeur.

BlockList.java

//...
public class BlockList {
    public static Block ExampleSapling = new BlockExampleSapling(
            new ExampleTree(),
            Block.Properties.create(Material.PLANTS)
                    .doesNotBlockMovement()
                    .tickRandomly()
                    .hardnessAndResistance(0.0F)
                    .sound(SoundType.PLANT))
            .setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_sapling"));

    @SubscribeEvent
    public static void registerBlocks(RegistryEvent.Register<Block> event) {
        event.getRegistry().registerAll(
                ExampleSapling
        );

    }

    @SubscribeEvent
    public static void registerBlockItems(RegistryEvent.Register<Item> event) {
        event.getRegistry().registerAll(
                new BlockItem(ExampleSapling, new Item.Properties().group(ExampleItemGroup.DEFAULT))
                        .setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_sapling"))
        );
    }
}

Ajoutez des blocs dans la classe de semis que vous avez préparée plus tôt. Puisque le premier argument passe l'arborescence correspondante, passez l'instance de la classe ʻExampleTree` créée précédemment.

Définissez resources comme d'habitude. L'explication est omise pour ceux qui ne changent pas en particulier.

\src\main\resources
   ├ assets
   │  └ example_mod
   │     ├ blockstates
   │     │  └ example_sapling.json
   │     ├ lang
   │     │  └ en_us.json
   │     │  └ ja_jp.json
   │     ├ models
   │     │  ├ block
   │     │  │  └ example_sapling.json
   │     │  └ item
   │     │     └ example_sapling.json
   │     └ textures
   │        ├ blocks
   │        │  └ example_sapling.png
   │        └ items
   └ data
      └ example_mod
         └ loot_tables
            └ blocks
               └ example_sapling.json

blockstates\example_sapling.json

{
  "variants": {
    "": { "model": "example_mod:block/example_sapling" }
  }
}

models\block\example_sapling.json

{
    "parent": "block/cross",
    "textures": {
        "cross": "example_mod:blocks/example_sapling"
    }
}

Spécifiez block / cross pour parent. Cela vous permet d'appliquer la texture comme si les plans se croisaient (vous pouvez voir ce que cela signifie en regardant réellement la forme).

models\item\example_sapling.json

{
    "parent": "item/generated",
    "textures": {
        "layer0": "example_mod:blocks/example_sapling"
    }
}

Au lieu d'hériter du fichier modèle de block, spécifiez-le avec ʻitem / generated`.

en_us.jp

{
  "block.example_mod.example_sapling": "Example Sapling"
}

ja_jp.json

{
  "block.example_mod.example_sapling": "Exemple de semis"
}

\loot_table\blocks\example_sapling.json

{
  "type": "minecraft:block",
  "pools": [
    {
      "rolls": 1,
      "entries": [
        {
          "type": "minecraft:item",
          "name": "example_mod:example_sapling"
        }
      ]
    }
  ]
}

Commençons le jeu et vérifions-le. Des semis seront ajoutés et vous pouvez voir que la poudre d'os fait pousser l'arbre. De plus, si vous enlevez le tronc de l'arbre, vous pouvez voir que les blocs de feuilles commencent à disparaître naturellement et font tomber les semis lorsqu'ils disparaissent.

Génération d'arbres

Il est presque temps de venir ici. Faisons en sorte que l'arbre implémenté jusqu'à présent soit généré automatiquement lorsque le monde est généré. Cela fait presque la même chose que 8. Ajout et génération de minerai, veuillez donc vous y référer également.

\src\main\java\jp\koteko\example_mod\
   ├ blocks
   ├ items
   ├ lists
   ├ world
   │   ├ WorldGenOres.java
   │   └ WorldGenTrees.java
   └ ExampleMod.java

Placez WorldGenTrees.java.

WorldGenOres.java

package jp.koteko.example_mod.world;

import jp.koteko.example_mod.world.features.ExampleTreeFeature;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.feature.Feature;
import net.minecraft.world.gen.feature.IFeatureConfig;
import net.minecraft.world.gen.feature.NoFeatureConfig;
import net.minecraft.world.gen.placement.AtSurfaceWithExtraConfig;
import net.minecraft.world.gen.placement.Placement;
import net.minecraftforge.registries.ForgeRegistries;

public class WorldGenTrees {
    public static void setup() {
        addTreeToOverworld(new ExampleTreeFeature());
    }

    private static void addTreeToOverworld(Feature<NoFeatureConfig> featureIn) {
        for(Biome biome : ForgeRegistries.BIOMES) {
            if (!biome.getCategory().equals(Biome.Category.NETHER) && !biome.getCategory().equals(Biome.Category.THEEND)) {
                biome.addFeature(
                        GenerationStage.Decoration.VEGETAL_DECORATION,
                        Biome.createDecoratedFeature(
                                featureIn,
                                IFeatureConfig.NO_FEATURE_CONFIG,
                                Placement.COUNT_EXTRA_HEIGHTMAP,
                                new AtSurfaceWithExtraConfig(2, 0.1F, 1)
                        )
                );
            }
        }
    }
}

Les arguments de ʻAtSurfaceWithExtraConfig` sont le nombre de loteries par bloc, la possibilité d'une loterie supplémentaire et le nombre de loteries supplémentaires. Dans le cas de cet exemple, «la loterie aura lieu à deux endroits par tranche, et il y a 10% de chances qu'une autre loterie ait lieu».

Enfin, appelez le WorldGenOres.setup () juste défini dans setup dans le fichier principal.

ExampleMod.java

//...
public class ExampleMod
{
    //...
    private void setup(final FMLCommonSetupEvent event)
    {
        WorldGenTrees.setup();
    }
    //...
}

Démarrez le jeu et créez un nouveau monde. Je l'ai fait briller d'une manière ou d'une autre, donc il se démarque encore plus la nuit.

** Vous avez ajouté et généré des arbres! ** **

référence

1.14.3 Tags help - Modder Support - Forge Forums [Biome-Minecraft Wiki](https://minecraft-ja.gamepedia.com/%E3%83%90%E3%82%A4%E3%82%AA%E3%83%BC%E3%83%A0# .E3.83.90.E3.82.A4.E3.82.AA.E3.83.BC.E3.83.A0.E3.82.AB.E3.83.A9.E3.83.BC.E3.81 .AE.E6.B1.BA.E5.AE.9A) [Route Table - Minecraft Wiki](https://minecraft-ja.gamepedia.com/%E3%83%AB%E3%83%BC%E3%83%88%E3%83%86%E3%83%BC % E3% 83% 96% E3% 83% AB) [Format d'élément de carte - Wiki Minecraft](https://minecraft-ja.gamepedia.com/%E5%9C%B0%E5%9B%B3%E3%82%A2%E3%82%A4%E3%83% 86% E3% 83% A0% E3% 83% 95% E3% 82% A9% E3% 83% BC% E3% 83% 9E% E3% 83% 83% E3% 83% 88)

Article suivant

99. Sortie Mod