[Java] Erstellen wir einen Minecraft Mod 1.14.4 [9. Bäume hinzufügen und generieren]

(Dieser Artikel gehört zu einer Reihe von Kommentaren)

Erster Artikel: Einführung Vorheriger Artikel: 8. Zugabe und Erzeugung von Erz Nächster Artikel: 99. Mod Output

Baum hinzufügen

In oben haben wir gelernt, wie man Erz hinzufügt. Als nächstes fügen wir einen Baum hinzu und lassen die Welt ihn erzeugen. Es wird kompliziert, also lasst uns gemeinsam unser Bestes geben.

Zugabe von Rohholz

Fügen Sie zunächst die Protokollblöcke hinzu, aus denen Qi besteht. Wir werden Blöcke unter Bezugnahme auf 2. Hinzufügen von Blöcken hinzufügen, aber es gibt einige Unterschiede. Schauen wir sie uns also der Reihe nach an.

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"))
        );
    }
}

Es ist im Grunde das gleiche, aber es ist nicht nur eine "Block" -Klasse, es ist eine "LogBlock" -Klasse. Dies ist eine Unterklasse des "RotatedPillarBlock", einer Unterklasse der "Block" -Klasse. RotatedPillarBlock ist Block mit zusätzlicher Rotation. Und es scheint, dass LogBlock etwas hinzugefügt hat, das mit der Anzeige auf der Karte zusammenhängt. Das Argument des Konstruktors wird um 1 erhöht und übergibt die Farbe, die auf der Karte in der Klasse "MaterialColor" angezeigt werden soll. Block.Properties.create () hat auch mehr Argumente und übergibt die Farbe, aber dies ist die Farbe auf der Karte zum Zeitpunkt der nicht vertikalen Installation, und es scheint, dass die vorherige die Farbe zum Zeitpunkt der vertikalen Installation ist. Wählen Sie diese entsprechend aus.

Wie im Beispiel werden wir "Ressourcen" festlegen, aber da die Textur des Protokollblocks je nach Oberfläche unterschiedlich ist, wird diese Einstellung unten gezeigt. Diese basieren auf dem Protokollblock von Minecraft. Dies ist also in Ordnung, es sei denn, Sie tun etwas Besonderes.

\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 }
  }
}

Wenn Sie so schreiben, wird die Elementvariable "Achse" (Richtung der Ebene) der Klasse "LogBlock" (genau genommen "RotatedPillarBlock") bedingt verzweigt, je nachdem, ob es sich um x, y oder z handelt. Ich bin. (Offizielles Dokument sagt auch so etwas.) Beschreibungen wie "x": 90 "y": 90 sind Drehwinkel. Kurz gesagt, es wird gedreht, sodass die Anzeige ein geneigtes Protokoll ist, das auf dem vertikalen Installationsstatus basiert.

models\block\example_log.json

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

Geben Sie "block / cube_column" für "parent" an. Auf diese Weise können Sie kubische Texturen anwenden, die zwischen Ober- und Unterseite sowie Seiten unterscheiden. Geben Sie den Pfad zu jeder Texturdatei an.

models\item\example_log.json

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

Dies kann durch Erben der Modelldatei von "Block" wie zuvor erfolgen.

en_us.jp

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

ja_jp.json

{
  "block.example_mod.example_log": "Beispielprotokoll"
}

Die Sprachdatei ist dieselbe wie zuvor.

\loot_table\blocks\example_log.json

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

Wie gewöhnlich.

Sie haben einen Block mit Anweisungen wie diesen hinzugefügt.

** Bei Protokollblöcken gibt es noch etwas zu tun. ** **. Die Blockaddition selbst wurde bisher abgeschlossen, wird jedoch in der Phase der späteren Erstellung des Baums erforderlich sein. Lassen Sie es uns hier tun.

Fügen Sie den Protokollblock hinzu, den Sie gerade zum Tag "minecraft: logs" hinzugefügt haben. Wie ich in 6. Hinzufügen von Rezepten kurz erwähnt habe, sind "Tags" eine Gruppe von Objekten, die gemeinsame Faktoren haben. In Minecraft gibt es ein Tag, das das Äquivalent von Rohholz zusammenfasst. Dieses Tag wird bei der Verarbeitung von Bäumen verwendet. Wenn Sie diesen Protokollblock in dieses Tag aufnehmen, können Sie daher eine unnötige Implementierung vermeiden.

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

** Erstellen Sie einen ** \ src \ main \ resources \ data \ minecraft \ tags \ blocks-Ordner in Ihrem Projektordner und platzieren Sie logs.json darin. Stellen Sie sicher, dass dieser Name identisch ist.

logs.json

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

Wenn Sie "false" für "replace" angeben, wird die Beschreibung in dieser Datei in "minecraft: logs" mit demselben Namen integriert. Geben wir den Block in values an.

Wenn Sie den Cursor im Debug-Modus auf den Block bewegen und "#minecraft: logs" wie der unterstrichene Teil in Rot angezeigt wird, sind Sie fertig.

Blätter hinzufügen

Fügen Sie als Nächstes die Blattblöcke hinzu, aus denen der Baum besteht. Schauen wir uns die Basis noch einmal der Reihe nach an und verweisen auf 2. Hinzufügen von Blöcken.

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"))
        );
    }
}

Blattblöcke werden mit "Leaves Block" hergestellt. Andere sind wie immer.

Richten Sie "Ressourcen" ein.

\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"
  }
}

Geben Sie "Block / Blätter" für "Eltern" an. Sie können durchscheinende Texturen anwenden (abhängig von Ihren Grafikeinstellungen).

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": "Beispielblatt"
}

Diese sind wie gewohnt.

\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"
            }
          ]
        }
      ]
    }
  ]
}

Die loot_table-Datei ist bisher ganz anders. Blattblöcke (die ich bisher übersprungen habe) haben mehrere Tropfen und hängen von Verzauberungen und Werkzeugen ab. Wenn sie also richtig implementiert werden, sehen sie so aus. Weitere Informationen finden Sie unter [Referenzseite](https://minecraft-ja.gamepedia.com/%E3%83%AB%E3%83%BC%E3%83%88%E3%83%86%E3%83%BC% Ich werde die Erklärung E3% 83% 96% E3% 83% AB) überlassen, aber ich werde sie kurz erklären. Dies ist "ein Tropfen aus einem Block, die Zahl ist eins, es gibt eines der" Kinder "zurück. Es gibt zwei" Kinder "und es gibt den Blattblock zurück, wenn er zum ersten Mal mit einer Schere oder dem Silk Touch I-Werkzeug gebrochen wird. Dinge. Als nächstes werden die Sämlinge in anderen Fällen mit einer zufälligen Wahrscheinlichkeit (erhöhte Wahrscheinlichkeit mit glücklicher Verzauberung) zurückgegeben. " Hier wird es zuerst herauskommen und die Reihenfolge wird sich ändern, aber wir werden im nächsten Abschnitt Sämlinge hinzufügen. Dies basiert auf den Ork-Blättern von Minecraft. Schauen wir uns jeden an und schreiben, wie Sie wollen.

Zum Schluss stellen Sie die MaterialColor ein. Dies hat zur Folge, dass die Blätter und das Gras je nach Biom ihre Farbe ändern. Sie können dies ignorieren, wenn es problematisch ist. Wenn Sie es ignorieren, wird für alle Biome dieselbe Farbe angezeigt. Bereiten Sie daher eine Textur mit dieser Farbe vor.

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);
    }
}

Dies wird gleichzeitig mit BlockList.java registriert, das deklariert und registriert wird. Es gibt etwas namens "ColorHandlerEvent", also wird es mit "register ()" wiedergegeben. Tun Sie es für jeden Block und Gegenstand. Variablen usw. sind eine Liste von Zeichen, die keinen Sinn ergeben. Dies kann jedoch geändert werden, da sie nur aus dem verschleierten Minecraft-Code gezogen werden. Für einen Block erhält "BiomeColors.getFoliageColor ()" die Farbe entsprechend dem Biom, in dem der Block vorhanden ist, und registriert sie. Für Elemente wird die Standardfarbe abgerufen und registriert. Übergeben Sie in beiden Fällen die Farbe (erhalten durch den Lambda-Ausdruck) als erstes Argument von "register ()" und das Objekt, das die Farbe als zweites Argument festlegt. Sie müssen diesen Bereich nicht genau verstehen, es sei denn, Sie versuchen, schwierige Dinge zu tun.

Die tatsächliche Farbe finden Sie unter [Referenzseite](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 Es ist ausführlich in .E3.81.AE.E6.B1.BA.E5.AE.9A) beschrieben. Grundsätzlich scheint es, dass eine Graustufen-Blattblocktextur vorbereitet und die Farbe darauf aufgetragen wird, aber als ich diesmal eine getönte Datei vorbereitete, wurde der eigentliche Block auch zu dieser Tönung, also wahrscheinlich intern Ich frage mich, ob sie hinzufügen.

Hinzufügen der TreeFeature-Klasse und der Tree-Klasse

Diese sind schwer in Worten zu erklären, aber beide sind Klassen, die Bäume verwalten. Die Tree-Klasse ist eine Klasse, die den Baum selbst verwaltet und in Verbindung mit den Sämlingen benötigt wird, die später hinzugefügt werden. Andererseits verwaltet die TreeFeature-Klasse nur Dinge, die mit der Baumgenerierung zusammenhängen, und Sie können das entsprechende TreeFeature auch aus der Tree-Klasse abrufen.

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

(Ich werde auf verschiedene Weise auf das Dateilayout verweisen, aber wenn Sie sich Sorgen machen, ist es durchaus angemessen.)

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);
    }
}

Erstellen Sie eine "ExampleTreeFeature" -Klasse, indem Sie die "TreeFeature" -Klasse erben. Die Argumente, die an den Vererbungsquellenkonstruktor übergeben werden sollen, lauten wie folgt. Das erste Argument ist in einer Instanz von "NoFeatureConfig" wahrscheinlich nicht besonders nützlich. Das zweite Argument ist der "boolesche" Wert, der bestimmt, ob eine Benachrichtigung möglich ist oder nicht, und er wurde nachgeahmt, weil er in anderen Bäumen falsch war. Ich werde es hinzufügen, wenn ich etwas verstehe. Das dritte Argument ist der Wert "int", der die Mindesthöhe des Baums bestimmt. Das vierte Argument ist der "BlockState" des Trunk-Blocks. Das fünfte Argument ist der "BlockState" des Blattblocks. Das sechste Argument ist der boolesche Wert, der bestimmt, ob die Reben auf dem Baum wachsen sollen oder nicht. Außerdem setzt setSapling () die Sämlinge und übergibt hier die Sämlingsinstanz. Sämlinge werden im nächsten Abschnitt implementiert.

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();
    }
}

Erstellen Sie eine "ExampleTree" -Klasse, indem Sie die abstrakte Klasse "Tree" erben. Definieren Sie eine Methode namens "getTreeFeature". Lassen Sie uns eine Instanz des zuvor definierten "ExampleTreeFeature" zurückgeben. Ich benutze es nicht, indem ich eine Zufallszahl als Argument erhalte, aber dies wird verwendet, wenn eine Eiche usw. wahrscheinlich in eine normale Art und eine riesige Art unterteilt wird.

Sämlinge hinzufügen

Als nächstes werden wir Sämlinge hinzufügen. Bereiten Sie zuerst eine Sämlingsklasse vor.

\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);
    }
}

In Bezug auf diesen Code sind ** (fast) alle dieselben wie der Code für Minecraft-Sämlinge **. Der Grund, warum ich es gemacht habe, ist, dass der Konstruktor der "Sapling" -Klasse von Minecraft "geschützt" ist und ich es nicht direkt aus dem Mod-Code heraus verwenden konnte. Ich hatte nicht genug Zeit, um zu verstehen, wie die Minecraft-Seite damit umgeht, daher werde ich hier nicht darauf eingehen, aber ich denke, es gibt wahrscheinlich einen besseren Weg, es so zu implementieren, wie es passt. Ändern Sie nur den Paketnamen, den Klassennamen und den Konstruktor.

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"))
        );
    }
}

Fügen Sie Blöcke in der zuvor vorbereiteten Sämlingsklasse hinzu. Da das erste Argument den entsprechenden Baum übergibt, übergeben Sie die zuvor erstellte Instanz der Klasse "ExampleTree".

Stellen Sie "Ressourcen" wie gewohnt ein. Die Erklärung wird für diejenigen weggelassen, die sich insbesondere nicht ändern.

\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"
    }
}

Geben Sie "block / cross" für "parent" an. Auf diese Weise können Sie die Textur so anwenden, als ob sich die Ebenen schneiden würden (Sie können sehen, was dies bedeutet, indem Sie die Form tatsächlich betrachten).

models\item\example_sapling.json

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

Anstatt die Modelldatei von "block" zu erben, geben Sie sie mit "item / generate" an.

en_us.jp

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

ja_jp.json

{
  "block.example_mod.example_sapling": "Beispiel Sämling"
}

\loot_table\blocks\example_sapling.json

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

Lass uns das Spiel starten und es überprüfen. Sämlinge werden hinzugefügt und Sie können sehen, dass das Knochenpulver den Baum wachsen lässt. Wenn Sie den Stamm des Baumes entfernen, können Sie auch sehen, dass die Blattblöcke auf natürliche Weise verschwinden und Sämlinge fallen lassen, wenn sie verschwinden.

Baumgenerierung

Es ist fast Zeit, hierher zu kommen. Lassen Sie uns den bisher implementierten Baum automatisch generieren, wenn die Welt generiert wird. Dies entspricht fast 8. Zugabe und Erzeugung von Erz. Bitte beziehen Sie sich auch darauf.

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

Platziere 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)
                        )
                );
            }
        }
    }
}

Die Argumente von "AtSurfaceWithExtraConfig" sind die Anzahl der Lotterien pro Block, die Möglichkeit einer zusätzlichen Lotterie und die Anzahl der zusätzlichen Lotterien. In diesem Beispiel wird "eine Lotterie an zwei Orten pro Block abgehalten, und es besteht eine 10% ige Chance, dass eine weitere Lotterie abgehalten wird."

Rufen Sie abschließend das gerade definierte "WorldGenOres.setup ()" im "Setup" in der Hauptdatei auf.

ExampleMod.java

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

Starte das Spiel und erschaffe eine neue Welt. Ich habe es irgendwie zum Leuchten gebracht, damit es nachts noch besser zur Geltung kommt.

** Sie haben Bäume hinzugefügt und generiert! ** **.

Referenz

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) [Routentabelle - 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) [Kartenelementformat - Minecraft-Wiki](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)

Nächster Artikel

99. Mod-Ausgabe