[Java] Créons un Minecraft Mod 1.14.4 [4. Ajouter des outils]

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

Premier article: Introduction Article précédent: 3. Add Creative Tab Article suivant: 5. Add Armor

Ajouter des outils

Dans 1. Ajouter des éléments, nous avons ajouté un élément simple qui n'a aucune fonction. Ajoutons maintenant des outils qui ont des rôles tels que des épées et des pickels.

\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

Créez un dossier ʻitems` et créez une classe pour chaque élément. À ce stade, c'est presque la même chose que la classe héritée, il n'est donc presque pas nécessaire de créer une nouvelle classe, mais j'ai décidé d'en faire une classe distincte en supposant qu'elle sera personnalisée de différentes manières plus tard.

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

Les arguments à transmettre au constructeur de la source d'héritage sont les suivants dans l'ordre. Seules les «propriétés» sont passées au moment de l'instanciation, et le reste est décidé ici. Voir également la section "Développement" ci-dessous.

ʻI Niveau d'objet: Niveau d'objet (appelé rareté / qualité). ʻInt attack DamageIn ou float attackDamageIn: puissance d'attaque. Pour une raison quelconque, int et float sont différents selon l'outil. Non présent à Hoe. float attackSpeedIn: vitesse d'attaque. Générateur de propriétés: propriétés de l'élément. Celui que j'ai utilisé pour configurer l'onglet Création.

Je vais l'ajouter à la liste d'articles et l'enregistrer.

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

Ensuite, nous effectuerons les réglages.

\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": "Exemple de hache",
  "item.example_mod.example_hoe": "Exemple de houe",
  "item.example_mod.example_pickaxe": "Exemple de pickel",
  "item.example_mod.example_shovel": "Exemple de scoop",
  "item.example_mod.example_sword": "Exemple d'épée",
}

~~ (C'est devenu un nom comme une arme avec beaucoup d'excitation ...) ~~

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

En spécifiant ʻitem / handheld pour parent`, il devient un type d'élément à tenir dans votre main.

Après avoir placé la texture, démarrez le jeu. (Depuis qu'il a été pris de manière créative, la durabilité n'a pas diminué)

** Des outils ont été ajoutés! ** **

développement

Q. Les paramètres de puissance d'attaque et de vitesse d'attaque sont-ils différents des valeurs? Q. Pourquoi la vitesse d'attaque est-elle négative? ** A. La puissance d'attaque semble être calculée par [valeur ʻIItemTier] + [valeur dans chaque outil] + 1, et la vitesse d'attaque est de 4,0 + [valeur dans chaque outil]. ** ** Jetons un coup d'œil à l'une des classes source d'héritage de la classe d'outils ajoutée cette fois, 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();
   }
   //...
}

Vous pouvez voir qu'il est calculé comme (float) attackDamageIn + tier.getAttackDamage (). (Notez que je n'ai trouvé aucun code pour comprendre pourquoi l'affichage sur l'interface graphique est en fait +1. Cependant, l'élément vanille correspondait également à la valeur calculée par une telle expression. Il est +1 sur l'affichage. On ne sait pas s'il s'agit ou non de +1 dans le calcul interne.) (De même, la partie calculée à partir du décalage 4.0 n'a pas été trouvée pour la vitesse d'attaque.)

Ensuite, jetons un œil à ʻ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);
   }
   //...
}

De cette manière, la valeur est fixée pour chaque niveau.

Par exemple, dans ʻExample Sword ajouté cette fois, il s'agit de ʻItem Tier.IRON, donc Puissance offensive [IItemTier value] + [Value for each tool] +1 = 2 + 3 + 1 = 6 Vitesse d'attaque 4,0+ [valeur pour chaque outil] = 4,0 --2,4 = 1,6 Ce sera.

Q. Je veux en faire un matériau unique, pas de la pierre ou du fer. Q. Où est définie la valeur de durabilité? ** A. Créons un nouveau ʻItem Tier. ** ** Définissez un nouvel Enum pour le ʻItem Tier mentionné ci-dessus.

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

Les arguments sont, dans l'ordre, le niveau de collection, la durabilité, l'efficacité, la puissance d'attaque, l'efficacité de l'enchantement et la (liste des) matériaux de réparation. J'ai essayé de le rendre meilleur que le diamant DIAMANT (3, 1561, 8.0F, 3.0F, 10, ...).

Changez le Tier de la classe d'outils.

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

La puissance d'attaque et la valeur de durabilité augmentent correctement. (F3 peut être utilisé pour afficher le débogage, et F3 + H peut être utilisé pour afficher la valeur de durabilité, etc.)

Q. Je veux faire une épée à laquelle je pense quand le tonnerre et les flammes sortent! ** R. Je suis encore difficile à comprendre, alors étudions ensemble. ** (Aucun commentaire prévu)

référence

Minecraft 1.14.4 Forge Mod Creation Part 6 [Ajout de 5 outils]

Article suivant

5. Ajout d'une armure