Armature Personalizzate 1.21.1

Impara come creare i tuoi set di armature personalizzati.

WARNING

Questa pagina si applica alla versione 1.21.1. La documentazione delle versioni meno recenti potrebbe essere incompleta.

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

Creare una Classe per un Materiale delle Armature

Proprio come gli oggetti e i blocchi, i materiali delle armature devono essere registrati. Per mettere ordine, creeremo una classe ModArmorMaterials in cui memorizzare il nostro materiale personalizzato.

Dovrai aggiungere un metodo statico initialize() a questa classe, e chiamarlo dall'initializer della tua mod perché i materiali vengano registrati.

// Within the ModArmorMaterials class
public static void initialize() {};

WARNING

Assicurati di chiamare questo metodo prima di registrare i tuoi oggetti, poiché sarà necessario che i materiali siano registrati prima che gli oggetti vengano creati.

@Override
public void onInitialize() {
  ModArmorMaterials.initialize();
}

All'interno di questa classe ModArmorMaterials, dovrai creare un metodo statico che registrerà il materiale dell'armatura. Questo metodo dovrebbe restituire una voce di registry per il materiale, perché questa voce verrà usata dal costruttore di ArmorItem per creare le componenti dell'armatura.

public static Holder<ArmorMaterial> registerMaterial(String id, Map<ArmorItem.Type, Integer> defensePoints, int enchantability, Holder<SoundEvent> equipSound, Supplier<Ingredient> repairIngredientSupplier, float toughness, float knockbackResistance, boolean dyeable) {
	// Get the supported layers for the armor material
	List<ArmorMaterial.Layer> layers = List.of(
		// The ID of the texture layer, the suffix, and whether the layer is dyeable.
		// We can just pass the armor material ID as the texture layer ID.
		// We have no need for a suffix, so we'll pass an empty string.
		// We'll pass the dyeable boolean we received as the dyeable parameter.
		new ArmorMaterial.Layer(ResourceLocation.fromNamespaceAndPath(ExampleMod.MOD_ID, id), "", dyeable)
	);

	ArmorMaterial material = new ArmorMaterial(defensePoints, enchantability, equipSound, repairIngredientSupplier, layers, toughness, knockbackResistance);
	// Register the material within the ArmorMaterials registry.
	material = Registry.register(BuiltInRegistries.ARMOR_MATERIAL, ResourceLocation.fromNamespaceAndPath(ExampleMod.MOD_ID, id), material);

	// The majority of the time, you'll want the RegistryEntry of the material - especially for the ArmorItem constructor.
	return Holder.direct(material);
}

Proprietà dei Materiali delle Armature

TIP

Se ti è difficile decidere un buon valore per queste proprietà, potresti prendere ispirazione ai materiali delle armature vanilla nella classe ArmorMaterials.

Durante la creazione di un materiale delle armature, dovrai definire le seguenti proprietà:

Punti Difesa

WARNING

Assicurati di assegnare un valore a ogni pezzo di armatura che intendi creare e registrare come oggetto. Se creassi un oggetto per un pezzo di armatura senza impostare un valore per i punti di difesa, il gioco andrà in crash.

La mappa defensePoints viene usata per definire il numero di punti difesa che ciascun pezzo dell'armatura fornirà. Più alto è il numero, maggiore la protezione fornita dal pezzo di armatura. La mappa dovrebbe contenere una voce per ciascun tipo di pezzo di armatura.

Incantabilità

La proprietà enchantability definisce la facilità con cui l'armatura può essere incantata. Più alto è il numero, maggiore la quantità di incantesimi che può ricevere l'armatura.

Suono Appena Indossata

La proprietà equipSound è il suono che verrà riprodotto quando l'armatura viene indossata. Questo suono dovrebbe essere una voce di registry di un SoundEvent. Potresti voler dare un'occhiata alla pagina sui SoundEvent personalizzati se avessi in mente di creare suoni personalizzati invece di affidarti ai suoni vanilla dalla classe SoundEvents.

Ingredienti per il Riparo

La proprietà repairIngredientSupplier fornisce un Ingredient che viene usato per riparare l'armatura. Questo ingrediente può essere quasi qualsiasi cosa, consigliamo di sceglierlo in modo che sia lo stesso materiale con cui si creano gli oggetti dell'armatura.

Tenacità

La proprietà toughness definisce quanto danno l'armatura assorbirà. Più alto è il numero, maggiore il danno che l'armatura assorbirà.

Resistenza al Contraccolpo

La proprietà knockbackResistance definisce quanto contraccolpo verrà riflesso dal giocatore quando viene colpito. Più alto è il numero, minore il contraccolpo che riceverà il giocatore.

Tingibile

La proprietà dyeable è un booleano che definisce se l'armatura può essere tinta. Se fosse true, l'armatura potrebbe essere tinta coi coloranti in un banco da lavoro.

Se scegliessi di rendere la tua armatura tingibile, lo strato della tua armatura e le texture degli oggetti devono essere pensati per essere tinti, poiché il colorante si sovrapporrà alla texture, non la sostituirà. Prendi per esempio l'armatura di cuoio vanilla: le texture sono in scala di grigi e il colorante viene applicato in sovrapposizione, il che cambia il colore dell'armatura.

Registrare il Materiale dell'Armatura

Ora che hai creato un metodo di utilità che può essere usato per registrare materiali di armature, puoi registrare i tuoi materiali di armature personalizzati come attributo statico nella classe ModArmorMaterials.

Per questo esempio, creeremo l'armatura di Guidite, con le seguenti proprietà:

public static final Holder<ArmorMaterial> GUIDITE = registerMaterial("guidite",
		// Defense (protection) point values for each armor piece.
		Map.of(
			ArmorItem.Type.HELMET, 3,
			ArmorItem.Type.CHESTPLATE, 8,
			ArmorItem.Type.LEGGINGS, 6,
			ArmorItem.Type.BOOTS, 3
		),
		// Enchantability. For reference, leather has 15, iron has 9, and diamond has 10.
		5,
		// The sound played when the armor is equipped.
		SoundEvents.ARMOR_EQUIP_IRON,
		// The ingredient(s) used to repair the armor.
		() -> Ingredient.of(ModItems.SUSPICIOUS_SUBSTANCE),
		0.0F,
		0.0F,
		// Guidite is NOT dyeable, so we will pass false.
		false);

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.

Durabilità

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

Questo si fa con il metodo maxDamage nella classe Item.Properties. Le varie parti dell'armatura hanno durabilità base diverse, solitamente ottenute come prodotto di un fattore condiviso a livello del materiale dell'armatura, ma si possono anche scegliere valori fissi.

Per l'armatura di Guidite useremo un fattore condiviso memorizzato assieme al materiale dell'armatura:

public static final int GUIDITE_DURABILITY_MULTIPLIER = 15;

Possiamo quindi creare gli oggetti dell'armatura con la costante di durabilità:

public static final Item GUIDITE_HELMET = register(new ArmorItem(ModArmorMaterials.GUIDITE, ArmorItem.Type.HELMET, new Item.Properties().durability(ArmorItem.Type.HELMET.getDurability(ModArmorMaterials.GUIDITE_DURABILITY_MULTIPLIER))), "guidite_helmet");
public static final Item GUIDITE_CHESTPLATE = register(new ArmorItem(ModArmorMaterials.GUIDITE, ArmorItem.Type.CHESTPLATE, new Item.Properties().durability(ArmorItem.Type.CHESTPLATE.getDurability(ModArmorMaterials.GUIDITE_DURABILITY_MULTIPLIER))), "guidite_chestplate");
public static final Item GUIDITE_LEGGINGS = register(new ArmorItem(ModArmorMaterials.GUIDITE, ArmorItem.Type.LEGGINGS, new Item.Properties().durability(ArmorItem.Type.LEGGINGS.getDurability(ModArmorMaterials.GUIDITE_DURABILITY_MULTIPLIER))), "guidite_leggings");
public static final Item GUIDITE_BOOTS = register(new ArmorItem(ModArmorMaterials.GUIDITE, ArmorItem.Type.BOOTS, new Item.Properties().durability(ArmorItem.Type.BOOTS.getDurability(ModArmorMaterials.GUIDITE_DURABILITY_MULTIPLIER))), "guidite_boots");

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

Dovrai creare due insiemi di texture:

• Texture e modelli per gli oggetti stessi.
• Texture per l'armatura in sé, visibile quando un'entità la indossa.

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.

Scarica Texture degli Oggetti

INFO

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

{
  "parent": "item/generated",
  "textures": {
    "layer0": "example-mod:item/guidite_helmet"
  }
}

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

Texture e Modello dell'Armatura

Quando un'entità indossa la tua armatura, per ora apparirà la texture mancante:

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

Poiché il nome del materiale dell'armatura è nel nostro caso guidite, i percorsi delle texture saranno:

• assets/example-mod/textures/models/armor/guidite_layer_1.png
• assets/example-mod/textures/models/armor/guidite_layer_2.png

Scarica Texture dei Modelli delle Armature

Il primo strato contiene texture per elmo e corazza, mentre il secondo strato contiene texture per gambiere e stivali.

Quando queste texture sono presenti, dovresti poter vedere la tua armatura sulle entità che la indossano: