[Java] Erstellen wir einen Minecraft Mod 1.14.4 [4. Tools hinzufügen]
(Dieser Artikel gehört zu einer Reihe von Kommentaren)
Erster Artikel: Einführung Vorheriger Artikel: 3. Registerkarte "Creative hinzufügen" Nächster Artikel: 5. Rüstung hinzufügen
Werkzeuge hinzufügen
In 1. Elemente hinzufügen haben wir ein einfaches Element hinzugefügt, das keine Funktion hat. Fügen wir nun Werkzeuge hinzu, die Rollen wie Schwerter und Pickel haben.
\src\main\java\jp\koteko\example_mod\
├ items
│ ├ ItemExampleAxe.java
│ ├ ItemExampleHoe.java
│ ├ ItemExamplePickaxe.java
│ ├ ItemExampleShovel.java
│ └ ItemExampleSword.java
├ lists
│ └ ItemList.java
├ ExampleItemGroup.java
└ ExampleMod.java
Erstellen Sie einen Ordner "Elemente" und erstellen Sie eine Klasse für jedes Element. Zu diesem Zeitpunkt ist es fast dasselbe wie die geerbte Klasse, sodass es fast nicht erforderlich ist, eine neue Klasse zu erstellen. Ich habe mich jedoch entschlossen, sie zu einer separaten Klasse zu machen, vorausgesetzt, sie wird später auf verschiedene Arten angepasst.
ItemExampleAxe.java
package jp.koteko.example_mod.items;
import net.minecraft.item.AxeItem;
import net.minecraft.item.ItemTier;
public class ItemExampleAxe extends AxeItem {
public ItemExampleAxe(Properties properties) {
super(ItemTier.IRON, 5, -3.0F, properties);
}
}
ItemExampleHoe.java
package jp.koteko.example_mod.items;
import net.minecraft.item.HoeItem;
import net.minecraft.item.ItemTier;
public class ItemExampleHoe extends HoeItem {
public ItemExampleHoe(Properties properties) {
super(ItemTier.IRON, 0, properties);
}
}
ItemExamplePickaxe.java
package jp.koteko.example_mod.items;
import net.minecraft.item.ItemTier;
import net.minecraft.item.PickaxeItem;
public class ItemExamplePickaxe extends PickaxeItem {
public ItemExamplePickaxe(Properties properties) {
super(ItemTier.IRON, 1, -2.8F, properties);
}
}
ItemExampleShovel.java
package jp.koteko.example_mod.items;
import net.minecraft.item.ItemTier;
import net.minecraft.item.ShovelItem;
public class ItemExampleShovel extends ShovelItem {
public ItemExampleShovel(Properties properties) {
super(ItemTier.IRON, 1.5F, -3.0F, properties);
}
}
ItemExampleSword.java
package jp.koteko.example_mod.items;
import net.minecraft.item.ItemTier;
import net.minecraft.item.SwordItem;
public class ItemExampleSword extends SwordItem {
public ItemExampleSword(Properties properties) {
super(ItemTier.IRON, 3, -2.4F, properties);
}
}
Die an den Vererbungsquellenkonstruktor übergebenen Argumente lauten wie folgt. Zum Zeitpunkt der Instanziierung wird nur "Eigenschaften" übergeben, und der Rest wird hier entschieden. Siehe auch den Abschnitt "Entwicklung" weiter unten.
IItemTier Tier: Item Tier (sogenannte Rarität / Klasse).
int attackDamageIn oder float attackDamageIn: Angriffskraft. Aus irgendeinem Grund unterscheiden sich int und float je nach Werkzeug. In Hoe nicht vorhanden.
float attackSpeedIn: Angriffsgeschwindigkeit.
Properties Builder: Elementeigenschaften. Die, mit der ich die Registerkarte "Creative" eingerichtet habe.
Ich werde es der Artikelliste hinzufügen und registrieren.
ItemList.java
package jp.koteko.example_mod.lists;
import jp.koteko.example_mod.ExampleItemGroup;
import jp.koteko.example_mod.ExampleMod;
import jp.koteko.example_mod.items.*;
import net.minecraft.item.Item;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.event.RegistryEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.common.Mod;
@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
public class ItemList {
public static Item ExampleIngot = new Item(new Item.Properties().group(ExampleItemGroup.DEFAULT))
.setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_ingot"));
public static Item ExampleAxe = new ItemExampleAxe(new Item.Properties().group(ExampleItemGroup.DEFAULT))
.setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_axe"));
public static Item ExampleHoe = new ItemExampleHoe(new Item.Properties().group(ExampleItemGroup.DEFAULT))
.setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_hoe"));
public static Item ExamplePickaxe = new ItemExamplePickaxe(new Item.Properties().group(ExampleItemGroup.DEFAULT))
.setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_pickaxe"));
public static Item ExampleShovel = new ItemExampleShovel(new Item.Properties().group(ExampleItemGroup.DEFAULT))
.setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_shovel"));
public static Item ExampleSword = new ItemExampleSword(new Item.Properties().group(ExampleItemGroup.DEFAULT))
.setRegistryName(new ResourceLocation(ExampleMod.MOD_ID, "example_sword"));
@SubscribeEvent
public static void registerItems(RegistryEvent.Register<Item> event) {
event.getRegistry().registerAll(
ExampleIngot,
ExampleAxe,
ExampleHoe,
ExamplePickaxe,
ExampleShovel,
ExampleSword
);
}
}
Als nächstes werden wir Einstellungen vornehmen.
\src\main\resources\assets\example_mod
├ blockstates
├ lang
│ └ en_us.json
│ └ ja_jp.json
├ models
│ ├ block
│ └ item
│ ├ example_axe.json
│ ├ example_hoe.json
│ ├ example_pickaxe.json
│ ├ example_shovel.json
│ └ example_sword.json
└ textures
├ blocks
└ items
├ example_axe.png
├ example_hoe.png
├ example_pickaxe.png
├ example_shovel.png
└ example_sword.png
en_us.json
{
"item.example_mod.example_axe": "Example Axe",
"item.example_mod.example_hoe": "Example Hoe",
"item.example_mod.example_pickaxe": "Example Pickaxe",
"item.example_mod.example_shovel": "Example Shovel",
"item.example_mod.example_sword": "Example Sword"
}
ja_jp.json
{
"item.example_mod.example_axe": "Beispiel ax",
"item.example_mod.example_hoe": "Beispiel Hacke",
"item.example_mod.example_pickaxe": "Beispiel Pickel",
"item.example_mod.example_shovel": "Beispielschaufel",
"item.example_mod.example_sword": "Beispiel Schwert",
}
~~ (Es ist ein Name wie eine Waffe mit viel Aufregung geworden ...) ~~
example_axe.json
{
"parent": "item/handheld",
"textures": {
"layer0": "example_mod:items/example_axe"
}
}
example_hoe.json
{
"parent": "item/handheld",
"textures": {
"layer0": "example_mod:items/example_hoe"
}
}
example_pickaxe.json
{
"parent": "item/handheld",
"textures": {
"layer0": "example_mod:items/example_pickaxe"
}
}
example_shovel.json
{
"parent": "item/handheld",
"textures": {
"layer0": "example_mod:items/example_shovel"
}
}
example_sword.json
{
"parent": "item/handheld",
"textures": {
"layer0": "example_mod:items/example_sword"
}
}
Wenn Sie "Artikel / Handheld" für "Eltern" angeben, wird dies zu einer Art Artikel, den Sie in der Hand halten können.
Nachdem Sie die Textur platziert haben, starten Sie das Spiel.
(Seit es kreativ aufgenommen wurde, hat sich die Haltbarkeit nicht verringert)
** Tools wurden hinzugefügt! ** ** **
Entwicklung
F. Unterscheiden sich die Einstellungen für Angriffskraft und Angriffsgeschwindigkeit von den Werten?
F. Warum ist die Angriffsgeschwindigkeit negativ?
** A. Die Angriffskraft scheint mit [IItemTier-Wert] + [Wert in jedem Werkzeug] + 1 berechnet zu werden, und die Angriffsgeschwindigkeit beträgt 4,0 + [Wert in jedem Werkzeug]. ** ** **
Werfen wir einen Blick auf eine der Vererbungsquellenklassen der diesmal hinzugefügten Werkzeugklasse, "SwordItem.java".
SwordItem.java
//...
public class SwordItem extends TieredItem {
private final float attackDamage;
private final float attackSpeed;
public SwordItem(IItemTier tier, int attackDamageIn, float attackSpeedIn, Item.Properties builder) {
super(tier, builder);
this.attackSpeed = attackSpeedIn;
this.attackDamage = (float)attackDamageIn + tier.getAttackDamage();
}
//...
}
Sie können sehen, dass es als "(float) attackDamageIn + tier.getAttackDamage ()" berechnet wird. (Beachten Sie, dass ich keinen Code finden konnte, um zu verstehen, warum die Anzeige auf der GUI tatsächlich +1 ist. Das Vanille-Element stimmte jedoch auch mit dem durch einen solchen Ausdruck berechneten Wert überein. Es ist +1 auf der Anzeige. Es ist nicht bekannt, ob es in der internen Berechnung +1 ist oder ist.) (In ähnlicher Weise wurde der aus dem 4.0-Offset berechnete Teil für die Angriffsgeschwindigkeit nicht gefunden.)
Als nächstes werfen wir einen Blick auf "Item Tier".
ItemTier.java
//...
public enum ItemTier implements IItemTier {
WOOD(0, 59, 2.0F, 0.0F, 15, () -> {
return Ingredient.fromTag(ItemTags.PLANKS);
}),
STONE(1, 131, 4.0F, 1.0F, 5, () -> {
return Ingredient.fromItems(Blocks.COBBLESTONE);
}),
IRON(2, 250, 6.0F, 2.0F, 14, () -> {
return Ingredient.fromItems(Items.IRON_INGOT);
}),
DIAMOND(3, 1561, 8.0F, 3.0F, 10, () -> {
return Ingredient.fromItems(Items.DIAMOND);
}),
GOLD(0, 32, 12.0F, 0.0F, 22, () -> {
return Ingredient.fromItems(Items.GOLD_INGOT);
});
//...
private ItemTier(int harvestLevelIn, int maxUsesIn, float efficiencyIn, float attackDamageIn, int enchantabilityIn, Supplier<Ingredient> repairMaterialIn) {
this.harvestLevel = harvestLevelIn;
this.maxUses = maxUsesIn;
this.efficiency = efficiencyIn;
this.attackDamage = attackDamageIn;
this.enchantability = enchantabilityIn;
this.repairMaterial = new LazyLoadBase<>(repairMaterialIn);
}
//...
}
Auf diese Weise wird der Wert für jede Stufe festgelegt.
In dem diesmal hinzugefügten "Beispielschwert" heißt es beispielsweise "ItemTier.IRON" Offensivkraft [IItemTier-Wert] + [Wert für jedes Werkzeug] +1 = 2 + 3 + 1 = 6 Angriffsgeschwindigkeit 4.0+ [Wert für jedes Werkzeug] = 4.0 --2.4 = 1.6 Es wird sein.
F. Ich möchte es zu einem einzigartigen Material machen, nicht zu Stein oder Eisen. F. Wo ist der Haltbarkeitswert eingestellt? ** A. Erstellen wir eine neue "Gegenstandsstufe". ** ** ** Definieren Sie eine neue Aufzählung für die oben erwähnte "Gegenstandsstufe".
\src\main\java\jp\koteko\example_mod\
├ items
│ └ ExampleItemTier.java
├ lists
├ ExampleItemGroup.java
└ ExampleMod.java
ExampleItemTier.java
package jp.koteko.example_mod.items;
import jp.koteko.example_mod.lists.ItemList;
import net.minecraft.item.IItemTier;
import net.minecraft.item.crafting.Ingredient;
import net.minecraft.util.LazyLoadBase;
import java.util.function.Supplier;
public enum ExampleItemTier implements IItemTier {
EXAMPLE(4, 3122, 10.0F, 4.0F, 25, () -> {
return Ingredient.fromItems(ItemList.ExampleIngot);
});
private final int harvestLevel;
private final int maxUses;
private final float efficiency;
private final float attackDamage;
private final int enchantability;
private final LazyLoadBase<Ingredient> repairMaterial;
private ExampleItemTier(int harvestLevelIn, int maxUsesIn, float efficiencyIn, float attackDamageIn, int enchantabilityIn, Supplier<Ingredient> repairMaterialIn) {
this.harvestLevel = harvestLevelIn;
this.maxUses = maxUsesIn;
this.efficiency = efficiencyIn;
this.attackDamage = attackDamageIn;
this.enchantability = enchantabilityIn;
this.repairMaterial = new LazyLoadBase<>(repairMaterialIn);
}
public int getMaxUses() {
return this.maxUses;
}
public float getEfficiency() {
return this.efficiency;
}
public float getAttackDamage() {
return this.attackDamage;
}
public int getHarvestLevel() {
return this.harvestLevel;
}
public int getEnchantability() {
return this.enchantability;
}
public Ingredient getRepairMaterial() {
return this.repairMaterial.getValue();
}
}
Die Argumente sind in der Reihenfolge Sammlungsgrad, Haltbarkeit, Effizienz, Angriffskraft, Verzauberungseffizienz und (Liste von) Reparaturmaterialien. Ich habe versucht, es besser zu machen als der Diamant "DIAMOND (3, 1561, 8.0F, 3.0F, 10, ...)".
Ändern Sie die Stufe der Werkzeugklasse.
ItemExampleSword.java
package jp.koteko.example_mod.items;
import net.minecraft.item.SwordItem;
public class ItemExampleSword extends SwordItem {
public ItemExampleSword(Properties properties) {
super(ExampleItemTier.EXAMPLE, 3, -2.4F, properties);
}
}
Angriffskraft und Haltbarkeitswert steigen richtig an. (F3 kann verwendet werden, um das Debug anzuzeigen, und F3 + H kann verwendet werden, um den Haltbarkeitswert usw. anzuzeigen.)
F. Ich möchte ein Schwert machen, an das ich denke, wenn Donner und Flammen herauskommen! ** A. Ich bin immer noch schwer zu verstehen, also lass uns zusammen lernen. ** (Kein Kommentar geplant)
Referenz
Minecraft 1.14.4 Forge Mod Creation Teil 6 [Hinzufügen von 5 Tools]
Nächster Artikel
Recommended Posts