Uno stato di un blocco è un dato relativo a un singolo blocco nel mondo di Minecraft che contiene informazioni riguardanti il blocco sotto forma di proprietà - ecco alcuni esempi di proprietà che in vanilla sono memorizzate come stati:

• Rotazione: Usato principalmente per i tronchi e per altri blocchi naturali.
• Attivo: Fondamentale nei componenti della redstone, e blocchi come la fornace e l'affumicatore.
• Età: Usato per colture, piante, arboscelli, alghe...

Probabilmente hai capito perché sono così utili - per evitare di immagazzinare dati NBT in un blocco-entità, riducendo dunque le dimensioni del mondo e migliorando i TPS!

Le definizioni degli stati dei blocchi si trovano nella cartella assets/mod-id/blockstates.

Esempio: Pilastro

Minecraft ha già delle classi che permettono di creare velocemente alcuni tipi di blocco - questo esempio mostra la creazione di un blocco con la proprietà asse, con un blocco "Tronco di Quercia Condensato".

La classe vanilla PillarBlock permette di piazzare il blocco lungo gli assi X, Y o Z.

public static final RegistryKey<Block> CONDENSED_OAK_LOG_KEY = RegistryKey.of(
		RegistryKeys.BLOCK,
		Identifier.of(FabricDocsReference.MOD_ID, "condensed_oak_log")
);

public static final Block CONDENSED_OAK_LOG = register(
		new PillarBlock(
				AbstractBlock.Settings.create()
						.registryKey(CONDENSED_OAK_LOG_KEY)
						.sounds(BlockSoundGroup.WOOD)
		), CONDENSED_OAK_LOG_KEY, true
);

I pilastri hanno due texture diverse, superiore e laterale - e usano il modello block/cube_column.

Ovviamente, come per tutte le altre texture dei blocchi, i file si trovano nella cartella assets/mod-id/textures/blocks

Dato che un pilastro ha due posizioni, orizzontale e verticale, dobbiamo creare due file di modelli separati:

• 'condensed_oak_log_horizontal.jsonche estende il modelloblock/cube_column_horizontal\`.
• condensed_oak_log.json che estende il modello block/cube_column.

Un esempio di come deve essere il file condensed_oak_log_horizontal.json:

{
  "parent": "minecraft:block/cube_column_horizontal",
  "textures": {
    "end": "fabric-docs-reference:block/condensed_oak_log_top",
    "side": "fabric-docs-reference:block/condensed_oak_log"
  }
}

INFO

Remember, blockstate files can be found in the assets/mod-id/blockstates folder, the name of the blockstate file should match the block ID used when registering your block in the ModBlocks class. For instance, if the block ID is condensed_oak_log, the file should be named condensed_oak_log.json.

Se vuoi vedere tutti i modificatori disponibili nel file degli stati, leggi la pagina Minecraft Wiki - Models (Block States).

Ora dobbiamo creare un file per lo stato. Il file dello stato è dove avviene la magia—i pilastri hanno tre assi e quindi useremo modelli specifici per i seguenti casi:

• axis=x - Quando il blocco è piazzato sull'asse X, ne ruoteremo il modello in modo che guardi verso la parte positiva delle X.
• axis=y - Quando il blocco è piazzato sull'asse Y, useremo il modello verticale normale.
• axis=z - Quando il blocco è piazzato sull'asse Z, ne ruoteremo il modello in modo che guardi verso la parte positiva delle X.

{
  "variants": {
    "axis=x": {
      "model": "fabric-docs-reference:block/condensed_oak_log_horizontal",
      "x": 90,
      "y": 90
    },
    "axis=y": {
      "model": "fabric-docs-reference:block/condensed_oak_log"
    },
    "axis=z": {
      "model": "fabric-docs-reference:block/condensed_oak_log_horizontal",
      "x": 90
    }
  }
}

Come sempre, dovrai creare una traduzione per il tuo blocco, oltre ad un modello dell'oggetto il quale deve essere figlio di uno dei due modelli.

Stati del Blocco Personalizzati

Gli stati del blocco personalizazti sono ottimi se il tuo blocco ha proprietà uniche - a volte è anche possibile che il tuo blocco riusi proprietà vanilla.

Questo esempio creerà una proprietà booleana chiamata activated - quando un giocatore clicca con il tasto destro il blocco, il blocco passerà dall'essere activated=false ad activated=true - cambiando la texture in maniera appropriata.

Creare la Proprietà

Anzitutto, dovrai creare la proprietà in sé - poiché questo è un booleano, useremo il metodo BooleanProperty.of.

public class PrismarineLampBlock extends Block {
	public static final BooleanProperty ACTIVATED = BooleanProperty.of("activated");

}

Dopo di che, dovremo aggiungere la proprietà al gestore degli stati del blocco nel metodo appendProperties. Dovrai fare override del metodo per accedere al costruttore:

@Override
protected void appendProperties(StateManager.Builder<Block, BlockState> builder) {
	builder.add(ACTIVATED);
}

Dovrai anche impostare un valore predefinito per la proprietà activated nel costruttore del tuo blocco personalizzato.

public PrismarineLampBlock(Settings settings) {
	super(settings);

	// Set the default state of the block to be deactivated.
	setDefaultState(getDefaultState().with(ACTIVATED, false));
}

Usare la Proprietà

Questo esempio invertirà la proprietà booleana activated quando il giocatore interagisce con il blocco. Possiamo fare override del metodo onUse per questo:

@Override
protected ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit) {
	if (!player.getAbilities().allowModifyWorld) {
		// Skip if the player isn't allowed to modify the world.
		return ActionResult.PASS;
	} else {
		// Get the current value of the "activated" property
		boolean activated = state.get(ACTIVATED);

		// Flip the value of activated and save the new blockstate.
		world.setBlockState(pos, state.with(ACTIVATED, !activated));

		// Play a click sound to emphasise the interaction.
		world.playSound(player, pos, SoundEvents.BLOCK_COMPARATOR_CLICK, SoundCategory.BLOCKS, 1.0F, 1.0F);

		return ActionResult.SUCCESS;
	}
}

Visualizzare la Proprietà

Prima di creare il file degli stati del blocco, dovrai fornire texture per entrambi gli stati del blocco, sia attivo sia inattivo, e con quelle anche il modello del blocco.

Sfrutta la tua conoscenza dei modelli dei blocchi per creare due modelli per il blocco: uno per lo stato attivo ed uno per quello inattivo. Quando avrai fatto ciò, puoi iniziare la creazione del file degli stati del blocco.

Poiché hai aggiunto una nuova proprietà, dovrai aggiornare il file degli stati di quel blocco per tenere quella proprietà in considerazione.

Se hai proprietà multiple su un blocco, dovrai tenere in conto tutte le possibili combinazioni. Per esempio, activated e axis porterebbero a 6 combinazioni (due valori possibili per activated e tre valori possibili per axis).

Poiché questo blocco ha solo due possibili varianti, dato che ha solo una proprietà (activated), il file JSON degli stati del blocco avrà il seguente aspetto:

Not Found: /home/runner/work/fabric-docs/fabric-docs/reference/latest/src/main/resources/assets/fabric-docs-reference/blockstates/prismarine_lamp.json

TIP

Non dimenticare di aggiungere una Descrizione del Modello d'Oggetto per il blocco così che appaia nell'inventario!

Poiché il blocco nell'esempio è una lampada, dovremo anche fargli emettere luce quando la proprietà activated è true. Questo si può ottenere tramite le impostazioni del blocco, passate al costruttore durante la registrazione del blocco.

Puoi usare il metodo luminance per impostare il livello di luce emessa dal blocco, possiamo creare un metodo statico nella classe PrismarineLampBlock per restituire il livello di luce in base alla proprietà activated, e passarlo come riferimento a un metodo nel metodo luminance:

public static int getLuminance(BlockState currentBlockState) {
	// Get the value of the "activated" property.
	boolean activated = currentBlockState.get(PrismarineLampBlock.ACTIVATED);

	// Return a light level if activated = true
	return activated ? 15 : 0;
}

public static final RegistryKey<Block> PRISMARINE_LAMP_KEY = RegistryKey.of(
		RegistryKeys.BLOCK,
		Identifier.of(FabricDocsReference.MOD_ID, "prismarine_lamp")
);
public static final Block PRISMARINE_LAMP = register(
		new PrismarineLampBlock(
				AbstractBlock.Settings.create()
						.registryKey(PRISMARINE_LAMP_KEY)
						.sounds(BlockSoundGroup.LANTERN)
						.luminance(PrismarineLampBlock::getLuminance)
		), PRISMARINE_LAMP_KEY, true
);

Quando avrai completato tutto, il risultato finale dovrebbe avere il seguente aspetto: