Un'armatura fornisce al giocatore una difesa migliore contro attacchi di mob e di altri giocatori.

Creare una Classe per un Materiale delle Armature

Tecnicamente, non serve una classe apposita per il materiale della tua armatura, ma comunque è buona pratica data la quantità di attributi statici di cui avrai bisogno.

Per questo esempio, creeremo una classe GuiditeArmorMaterial che memorizzi i nostri attributi statici.

Durabilità di Base

Questa costante verrà usata nel metodo Item.Settings#maxDamage(int damageValue) quando si creano gli oggetti della nostra armatura, ed è anche necessaria come parametro nel costruttore ArmorMaterial quando creeremo successivamente il nostro oggetto ArmorMaterial.

public static final int BASE_DURABILITY = 15;

Se fai fatica a determinare una durabilità di base bilanciata, puoi far riferimento alle istanze dei materiali di armature vanilla che trovi nell'interfaccia ArmorMaterials.

Chiave di Registry per gli Asset Indossati

Anche se non dobbiamo registrare il nostro ArmorMaterial in alcuna registry, è in genere buona pratica memorizzare le chiavi di registry come costanti, poiché il gioco userà queste per trovare le texture adatte alla nostra armatura.

public static final RegistryKey<EquipmentAsset> GUIDITE_ARMOR_MATERIAL_KEY = RegistryKey.of(EquipmentAssetKeys.REGISTRY_KEY, Identifier.of(FabricDocsReference.MOD_ID, "guidite"));

Dopo passeremo questo al costruttore di ArmorMaterial.

Istanza di ArmorMaterial

Per creare il nostro materiale, dobbiamo creare una nuova istanza del record ArmorMaterial, in cui useremo le costanti di durabilità di base e chiave di registry del materiale.

public static final ArmorMaterial INSTANCE = new ArmorMaterial(
		BASE_DURABILITY,
		Map.of(
				EquipmentType.HELMET, 3,
				EquipmentType.CHESTPLATE, 8,
				EquipmentType.LEGGINGS, 6,
				EquipmentType.BOOTS, 3
		),
		5,
		SoundEvents.ITEM_ARMOR_EQUIP_IRON,
		0.0F,
		0.0F,
		REPAIRS_GUIDITE_ARMOR,
		GUIDITE_ARMOR_MATERIAL_KEY
);

Il costruttore di ArmorMaterial accetta i parametri seguenti, in questo ordine:

Parametro	Descrizione
durability	La durabilità di base di tutti i pezzi d'armatura, questa viene usata nel calcolare la durabilità totale di ciascun pezzo individuale di armatura che usa questo materiale. Questa dovrebbe essere la costante di durabilità di base che hai creato pocanzi.
defense	Una mappa da EquipmentType (un enum che rappresenti ogni casella d'armatura) a un valore intero, che indica il valore di difesa del materiale se usato nella casella d'armaturà corrispondente.
enchantmentValue	L'"incantabilità" degli oggetti d'armatura che usano questo materiale.
equipSound	Una voce di registry di un evento sonoro da riprodurre appena indossato un pezzo d'armatura che usa questo materiale. Per maggiori informazioni sui suoni, dai un'occhiata alla pagina Suoni Personalizzati.
toughness	Un valore float che rappresenti l'attributo "tenacità" del materiale d'armatura - in altre parole quanto l'armatura assorba bene il danno.
knockbackResistance	Un valore float che rappresenti la quantità di resistenza al contraccolpo che il materiale d'armatura offre a chi la indossa.
repairIngredient	Un tag di oggetti che rappresenta tutti gli oggetti che possono essere usati per riparare gli oggetti dell'armatura di questo materiale in un'incudine.
assetId	Una chiave di registry EquipmentAsset, questa dovrebbe essere la costante di chiave di registry per l'asset indossato creata in precedenza.

Se fai fatica a determinare valori adatti per ciascuno di questi parametri, puoi consultare le istanze dei ArmorMaterial vanilla che trovi nell'interfaccia ArmorMaterials.

Creare gli Oggetti dell'Armatura

Ora che hai registrato il materiale, puoi creare gli oggetti dell'armatura nella tua classe ModItems:

Ovviamente, un set di armatura non deve per forza essere completo, puoi avere un set con solo stivali, o solo gambiere... - il carapace di tartaruga vanilla è un buon esempio di un set di armatura con elementi mancanti.

A differenza di ToolMaterial, ArmorMaterial non memorizza alcuna informazione riguardo alla durabilità degli oggetti. Per questo motivo la durabilità di base deve essere aggiunta manualmente a Item.Settings degli oggetti dell'armatura quando li si registra.

Questo si ottiene passando la costante BASE_DURABILITY che abbiamo creato sopra nel metodo maxDamage nella classe Item.Settings.

public static final RegistryKey<Item> GUIDITE_HELMET_KEY = RegistryKey.of(RegistryKeys.ITEM, Identifier.of(FabricDocsReference.MOD_ID, "guidite_helmet"));
public static final Item GUIDITE_HELMET = register(new ArmorItem(GuiditeArmorMaterial.INSTANCE, EquipmentType.HELMET, new Item.Settings().registryKey(GUIDITE_HELMET_KEY).maxDamage(EquipmentType.HELMET.getMaxDamage(GuiditeArmorMaterial.BASE_DURABILITY))), GUIDITE_HELMET_KEY);

public static final RegistryKey<Item> GUIDITE_CHESTPLATE_KEY = RegistryKey.of(RegistryKeys.ITEM, Identifier.of(FabricDocsReference.MOD_ID, "guidite_chestplate"));
public static final Item GUIDITE_CHESTPLATE = register(new ArmorItem(GuiditeArmorMaterial.INSTANCE, EquipmentType.CHESTPLATE, new Item.Settings().registryKey(GUIDITE_CHESTPLATE_KEY).maxDamage(EquipmentType.CHESTPLATE.getMaxDamage(GuiditeArmorMaterial.BASE_DURABILITY))), GUIDITE_CHESTPLATE_KEY);

public static final RegistryKey<Item> GUIDITE_LEGGINGS_KEY = RegistryKey.of(RegistryKeys.ITEM, Identifier.of(FabricDocsReference.MOD_ID, "guidite_leggings"));
public static final Item GUIDITE_LEGGINGS = register(new ArmorItem(GuiditeArmorMaterial.INSTANCE, EquipmentType.LEGGINGS, new Item.Settings().registryKey(GUIDITE_LEGGINGS_KEY).maxDamage(EquipmentType.LEGGINGS.getMaxDamage(GuiditeArmorMaterial.BASE_DURABILITY))), GUIDITE_LEGGINGS_KEY);

public static final RegistryKey<Item> GUIDITE_BOOTS_KEY = RegistryKey.of(RegistryKeys.ITEM, Identifier.of(FabricDocsReference.MOD_ID, "guidite_boots"));
public static final Item GUIDITE_BOOTS = register(new ArmorItem(GuiditeArmorMaterial.INSTANCE, EquipmentType.BOOTS, new Item.Settings().registryKey(GUIDITE_BOOTS_KEY).maxDamage(EquipmentType.BOOTS.getMaxDamage(GuiditeArmorMaterial.BASE_DURABILITY))), GUIDITE_BOOTS_KEY);

Dovrai anche aggiungere gli oggetti ad un gruppo se vorrai che essi siano accessibili dall'inventario in creativa.

Come per tutti gli oggetti, dovresti creare chiavi di traduzione anche per questi.

Texture e Modelli

Dovremo creare un insieme di texture per gli oggetti, e un insieme di texture per l'armatura effettiva quando indossata da un'entità "umanoide" (giocatori, zombie, scheletri...).

Texture e Modello dell'Oggetto

Queste texture non differiscono da quelle di altri oggetti - devi creare le texture, e creare un modello di oggetto generico generato - tutto questo è coperto dalla guida Creare il Tuo Primo Oggetto.

Come esempio, puoi usare le seguenti texture e modelli JSON come riferimento.

INFO

Ti serviranno modelli in file JSON per tutti gli oggetti, non solo l'elmo, stesso principio di altri modelli di oggetti.

{
  "parent": "minecraft:item/generated",
  "textures": {
    "layer0": "fabric-docs-reference:item/guidite_helmet"
  }
}

Come puoi notare, gli oggetti dell'armatura avranno i modelli appropriati nel gioco:

Texture dell'Armatura

Quando un'entità indossa la tua armatura, non si vedrà nulla. Questo perché ti mancano le definizioni di texture e di modello indossato.

Ci sono due strati per le texture dell'armatura, entrambi devono essere presenti.

Abbiamo prima creato una costante RegistryKey<EquipmentAsset> chiamata GUIDITE_ARMOR_MATERIAL_KEY, che avevamo passato nel nostro costruttore ArmorMaterial. Si consiglia di nominare la texture similmente, per cui nel nostro caso sarà guidite.png

• assets/mod-id/textures/entity/equipment/humanoid/guidite.png - Contiene texture della parte superiore del corpo e degli stivali.
• assets/mod-id/textures/entity/equipment/humanoid_leggings/guidite.png - Contiene texture per il gambiere.

TIP

Se stai passando a 1.21.4 da una versione meno recente del gioco, è nella cartella humanoid che si mette la tua texture d'armatura layer0.png, mentre la cartella humanoid_leggings contiene la tua texture layer1.png.

Poi, dovrai creare una definizione del modello indossato ad essa associata. Queste vanno nella cartella /assets/mod-id/equipment/.

La costante RegistryKey<EquipmentAsset> creata più sopra determinerà il nome del file JSON. In questo caso sarà guidite.json.

Poiché vogliamo solo aggiungere i pezzi d'armatura "umanoidi" (elmo, corazza, gambiere, stivali...), la definizione del nostro modello indossato sarà come segue: la definizione del nostro modello indossato sarà come segue:

{
  "layers": {
    "humanoid": [
      {
        "texture": "fabric-docs-reference:guidite"
      }
    ],
    "humanoid_leggings": [
      {
        "texture": "fabric-docs-reference:guidite"
      }
    ]
  }
}

Quando sia le texture sia le definizioni dei modelli indossati sono presenti, dovresti poter vedere la tua armatura sulle entità che la indossano: