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 di blocchi si trovano nella cartella assets/example-mod/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 RotatedPillarBlock permette di piazzare il blocco lungo gli assi X, Y o Z.

public static final Block CONDENSED_OAK_LOG = register(
		"condensed_oak_log",
		RotatedPillarBlock::new,
		BlockBehaviour.Properties.of().sound(SoundType.WOOD),
		true
);

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

Come sempre, con tutte le texture dei blocchi, i file di texture si trovano in assets/example-mod/textures/block

Scarica le Texture

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

• condensed_oak_log_horizontal.json che estende il modello block/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": "example-mod:block/condensed_oak_log_top",
    "side": "example-mod:block/condensed_oak_log"
  }
}

INFO

Questo file si dovrebbe trovare nella cartella assets/example-mod/blockstates, e il suo nome dovrebbe combaciare con l'ID del blocco usato quando hai registrato il blocco nella classe ModBlocks. Per esempio, se l'ID è condensed_oak_log, il file dovrebbe chiamarsi 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": "example-mod:block/condensed_oak_log_horizontal",
      "x": 90,
      "y": 90
    },
    "axis=y": {
      "model": "example-mod:block/condensed_oak_log"
    },
    "axis=z": {
      "model": "example-mod: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.create.

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

}

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

@Override
protected void createBlockStateDefinition(StateDefinition.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(Properties settings) {
	super(settings);

	// Set the default state of the block to be deactivated.
	registerDefaultState(defaultBlockState().setValue(ACTIVATED, false));
}

Usare la Proprietà

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

@Override
protected InteractionResult useWithoutItem(BlockState state, Level level, BlockPos pos, Player player, BlockHitResult hit) {
	if (!player.getAbilities().mayBuild) {
		// Skip if the player isn't allowed to modify the level.
		return InteractionResult.PASS;
	} else {
		// Get the current value of the "activated" property
		boolean activated = state.getValue(ACTIVATED);

		// Flip the value of activated and save the new blockstate.
		level.setBlockAndUpdate(pos, state.setValue(ACTIVATED, !activated));

		// Play a click sound to emphasise the interaction.
		level.playSound(player, pos, SoundEvents.COMPARATOR_CLICK, SoundSource.BLOCKS, 1.0F, 1.0F);

		return InteractionResult.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.

Scarica le Texture

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:

{
  "variants": {
    "activated=false": {
      "model": "example-mod:block/prismarine_lamp"
    },
    "activated=true": {
      "model": "example-mod:block/prismarine_lamp_on"
    }
  }
}

TIP

Non dimenticare di aggiungere un oggetto per il client 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 lightLevel 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 lightLevel:

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

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

public static final Block PRISMARINE_LAMP = register(
		"prismarine_lamp",
		PrismarineLampBlock::new,
		BlockBehaviour.Properties.of()
				.sound(SoundType.LANTERN)
				.lightLevel(PrismarineLampBlock::getLuminance),
		true
);

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