Fare coding con Minecraft, ecco da dove iniziare

Cosa farai

Con questa risorsa imparerai alcuni principi del coding esplorando il mondo virtuale di Minecraft Pi, l’edizione speciale di Minecraft per Raspberry Pi che è istallata sul tuo Microninja.
Imparerai a controllare i movimenti del giocatore, a costruire blocchi e a usare l’interfaccia di Python per manipolare il mondo attorno a te.

Cosa imparerai

Imparerai a:

  • Lanciare Minecraft Pi e creare un Mondo
  • Usare Python per connetterti a Minecraft Pi
  • Usare Python per scrivere messaggi nella finestra di chat di Minecraft Pi, determinare la posizione che il giocatore occupa nel mondo, trasportarlo in una posizione differente a scelta, costruire blocchi e strutture di blocchi
  • Usare le variabili per archiviare le ID di diversi tipi di blocchi
  • Utilizzare differenti tipi di blocchi con attributi speciali

Lanciare Minecraft Pi

Per lanciare Minecraft Pi, fai clic sull’icona di Minecraft che trovi sulla scrivania.

Nella finestra che si apre, fai clic su Start Game, e quindi su Create New.

Nota come la nuova finestra è leggermente decentrata. Per trascinarla in una posizione diversa devi usare la barra del titolo della finestra nera sottostante.

Sei dentro Minecraft!
Usa il mouse per guardarti attorno e i seguenti tasti per svolgere le azioni riportate nella colonna di destra:

Tasto Azione
W Vai avanti
A Vai a sinistra
S Vai indietro
D Vai a destra
E Inventory
Spazio Salta
Due volte spazio Vola/Atterra
Esc Metti in pausa / Accedi al menù
Tab Libera il cursore del mouse

Puoi selezionare un blocco dal pannello nella parte inferiore della finestra usando i numeri della tastiera che vanno da 1 a 8, o, se preferisci, premi E per accedere alla lista completa dei blocchi:

Se premi due volte Spazio (mantenendolo premuto la seconda volta), inizierai a volare:

Premi Spazio altre due volte per atterrare.
Quando hai in mano la spada, puoi colpire i blocchi di fronte a te per rimuoverli (o per scavare) facendo clic con il tasto sinistro del mouse. Quando invece hai in mano un blocco, lo puoi depositare davanti a te facendo clic con il tasto destro del mouse. Per rimuoverlo fai clic con il tasto sinistro.

Python

Python è un linguaggio di programmazione adatto ai principianti perché è molto facile da leggere e da scrivere.
Ne esistono due versioni: Python 2.7 e 3. Questa risorsa fa uso della versione 2.7.

Per scrivere e testare il nostro codice useremo Geany, una IDE di Python che hai a disposizione nel tuo Microninja.

Lasciando il gioco in azione, accedi al menù di Minecraft facendo clic sul tasto Esc.

Apri Geany.
Si trova nella cartella Coding del menù di avvio.

Sposta la sua finestra e mettila di fianco a quella di Minecraft.

Puoi digitare le istruzioni direttamente nella finestra dell’editor di Geany e salvarle in un file per poterle utilizzare in un secondo momento.

Per iniziare, scrivi queste righe di codice:

from mcpi.minecraft import Minecraft
mc = Minecraft.create()
mc.postToChat("Ciao Mondo")

Salva il programma premendo File e Salva con nome. Quindi lancialo premendo l’icona Run.

Torna a Minecraft: vedrai il messaggio Ciao Mondo sullo schermo.

La prima riga che hai scritto dice al computer di importare il modulo Minecraft, la seconda, di creare un collegamento fra il programma che stai scrivendo e il gioco.
Dovrai scrivere queste due righe all’inizio di ogni programma che vuoi che interagisca con Minecraft.

La terza, usa la funzione postToChat() per visualizzare il messaggio Ciao Mondo nella finestra di chat di Minecraft.

Una funzione è un blocco di codice riutilizzabile che compie specifiche azioni.
Come hai appena visto, la funzione postToChat() dice al computer di visualizzare nella finestra di chat di Minecraft quanto è scritto nelle parentesi tonde (nel nostro caso “Ciao Mondo”).

Le funzioni sono raccolte nei moduli.
Per poterle utlizzare devi importare nel tuo programma il modulo che le contiene: è quello che abbiamo fatto nella prima riga del nostro esempio

from mcpi.minecraft import Minecraft

La posizione del giocatore

Minecraft è un mondo costruito da singoli blocchi di dimensione 1x1x1. Il giocatore e ogni blocco occupano una posizione determinata da specifici valori di x, y e z, dove x e z indicano la posizione sul piano orizzontale, y quella sul piano verticale.

x, y e z vengono chiamate coordinate.

La posizione iniziale del giocatore è nell’origine del sistema di coordinate definito dai valori: x=0, y=0, z=0.
Quando il giocatore si muove nel mondo di Minecraft, cambia la sua posizione, e quindi cambiano i valori delle coordinate x, y e z che la definiscono.

Per muovere il giocatore puoi usare la tastiera del tuo Microninja oppure scrivere un programma con Python. In quest’ultimo caso, devi creare tre variabili x, y e z e scrivere un comando che dica al giocatore di raggiungere la posizione definita dal loro valore.
Prova a scrivere:

from mcpi.minecraft import Minecraft
mc = Minecraft.create()

x = 15
y = 10
z = 14

mc.player.setTilePos(x,y,z)

Lancia il programma facendo click sull’icona Run.

Cos’è successo? Il giocatore si è spostato nella posizione definita dalle coordinate (15, 10, 14).

Prova a cambiare i valori delle variabili nel tuo programma per vedere cosa succede.
Puoi anche usare valori negativi… evita solo di utilizzare valori maggiori di 127: il mondo di Minecraft è piccolo! Se usi valori troppo grandi, il programma andrà in crash!

Le variabili servono a salvare i dati nella memoria del computer.
Ogni variabile ha un nome e un valore. Quando viene definita, il nome si trova alla sinistra del simbolo =, il valore alla sua destra. Quindi l’espressione:

x = 15

Definisce la variabile di nome x e le assegna il valore 15.

Nel programma precedente, abbiamo definito le variabili x, y e z.
Nota che avremmo potuto usare nomi differenti: infatti alle variabili possono essere dati dei nomi qualsiasi.
Prova, ad esempio, a lanciare questo programma:

from mcpi.minecraft import Minecraft
mc = Minecraft.create()

cane = 15
gatto = 20
elefante = 14

mc.player.setTilePos(cane,gatto,elefante)

Che cosa è successo?
Il giocatore si è spostato verso l’alto di 10 blocchi!
Le istruzioni sono le stesse date in precedenza… e quindi il risultato è lo stesso…ma adesso è un po’ più difficile leggerle: quando definiamo le variabili, è meglio dare dei nomi che aiutino a capire a cosa servono e rendano il più leggibile possibile il nostro programma.
Dunque, se vogliamo definire le coordinate di un punto in un sistema tridimensionale, è meglio usate i nomi x, y e z piuttosto che cane, gatto ed elefante!

La funzione setTilePos(x,y,z) dice al computer di spostare il giocatore nella posizione definita dal valore delle variabili x, y e z. Questa funzione fa uso di valori interi delle variabili, ma Minecraft ti permette di essere più preciso: se usi la funzione setPos(x,y,z) puoi infatti associare alle variabili valori decimali.

Come abbiamo detto in precedenza, le variabili servono a salvare i dati nella memoria del computer.
I dati possono essere di tipi diversi: numeri interi, numeri decimali, stringhe di testo e valori booleani (spiegheremo in seguito di cosa si tratta).

Ogni funzione fa uso di un certo tipo di dati. La funzione setTilePos() usa i numeri interi, mentre la funzione setPos() usa i numeri decimali. Quindi, usando setPos() possiamo scrivere un programma del tipo:

from mcpi.minecraft import Minecraft
mc = Minecraft.create()

x = 15.1
y = 10.5
z = 14.2

mc.player.setPos(x,y,z)

Prova a lanciarlo.

Il giocatore viene trasportato nella posizione di coordinate (15.1, 10.5, 14.2)!

Se, infine, non vuoi spostare il giocatore in una certa posizione, ma vuoi conoscere quella che occupa in quel momento, puoi utilizzare la funzione getPos():

x, y, z = mc.player.getPos()

Questa istruzione definisce le variabili x, y e z e assegna loro il valore delle coordinate del punto in cui si trova il giocatore in quel momento.

Teletrasporto

Per trasportare il giocatore dalla sua posizione corrente in un punto a tua scelta puoi usare un codice del tipo:

x, y, z = mc.player.getPos()
mc.player.setPos(x, y+100, z)

Queste istruzioni lo trasportano nel bel mezzo del cielo, 100 blocchi verticalmente sopra la posizioni in cui si trova.
Ricadrà poi immediatamente nel punto di partenza.

Prova a trasportare il giocatore in un altro posto!

E se, invece, volessi trasportare i giocatore prima in un punto e, dopo qualche secondo, in un punto diverso?
In questo caso dovresti scrivere un programma che contiene due gruppi di istruzioni simili a quelle che hai scritto prima per spostare il giocatore in una posizione determinata, e che aspetta un certo tempo fra l’esecuzione del primo gruppo di istruzioni e quella del secondo.

In Python esiste la funzione time.sleep() che dice al computer proprio di aspettare un certo intervallo di tempo prima di continuare a esiguire un programma. Per usarla bisogna importare il modulo time nel quale è contenuta.
Scrivi questo programma:

from mcpi.minecraft import Minecraft
from time import sleep

mc = Minecraft.create()

x = 15
y = 10
z = 14

mc.player.setTilePos(x,y,z)

time.sleep(3)

x = 25
y = 13
z = 24

mc.player.setTilePos(x,y,z)

Prova a leggerlo e a vedere se riesci a capire quello che fa. Tieni in mente che Python legge il programma riga per riga partendo dall’alto e procedendo verso il basso.

Adesso eseguilo.

Cosa è successo?
Dalla sua posizione iniziale, il giocatore è stato trasportato alla posizione di coordinate (15, 10, 14) e, dopo 3 secondi, a quella di coordinate (25, 13, 24)!
Eri riuscito a capirlo?

Vediamolo insieme in ogni caso:

from mcpi.minecraft import Minecraft
from time import sleep

importa nel programma i moduli Minecraft e sleep.

mc = Minecraft.create()

crea un collegamento fra il programma e Minecraft.

x = 15
y = 10
z = 14

definisce le variabili x, y e z.

mc.player.setTilePos(x,y,z)

dice al computer di portare il giocatore nella posizione nel mondo di Minecraft le cui coordinate corrispondono al valore delle variabili x, y e z, e cioè: (15, 10, 14).

time.sleep(3)

dice al computer di aspettare 3 secondi.

x = 25
y = 13
z = 24

Assegna nuovi valori alle variabili x, y e z.

I valori delle variabili possono essere cambiati in qualunque momento: i valori vecchi vengono semplicemente sostituiti da quelli nuovi.

mc.player.setTilePos(x,y,z)

dice ancora una volta al computer di portare il giocatore nella posizione nel mondo di Minecraft le cui coordinate corrispondono al valore delle variabili x, y e z… ma ora questa posizione è quella di coordinate (25, 13, 24)!

Creare un blocco

Per creare un blocco in una certa posizione del mondo di Minecraft puoi usare la funzione setBlock().
In modo analogo a setPos() e setTilePos(), setBlock() usa le coordinate x, y, e z per determinare dove creare il blocco; in aggiunta, però, fa uso anche di un altro valore per definire il tipo di blocco da creare, e cioè se il blocco deve essere di pietra, di lava, d’erba, d’aria e così via.
I tipi di blocco sono rappresentati da un numero intero; per esempio il valore dell’Aria è 0, della Pietra è 1, dell’Erba è 2, della Terra 3, dell’Acqua 8.

Dunque, il programma:

from mcpi.minecraft import Minecraft

mc = Minecraft.create()

mc.setBlock(10, 11, 12, 1)

crea un blocco di pietra alle coordinate (10, 11, 12).

Avremmo potuto ottenere lo stesso risultato definendo le variabili x, y e z per le coordinate e una variabile che chiamiamo tipo_di_blocco per il tipo di blocco da utilizzare:

from mcpi.minecraft import Minecraft

mc = Minecraft.create()

x = 10
y = 11
z = 12
tipo_di_blocco = 1

mc.setBlock(x, y, z, tipo_di_blocco)

E se volessimo creare un nuovo blocco di pietra sopra il primo?

Ci basterebbe usare l’operatore + per cambiare il valore della variabile y:

from mcpi.minecraft import Minecraft

mc = Minecraft.create()

x = 10
y = 11
z = 12
tipo_di_blocco = 1

mc.setBlock(x, y, z, tipo_di_blocco)

y = y + 1
mc.setBlock(x, y, z, tipo_di_blocco)

Dopo aver creato il primo blocco di pietra nella posizione (10, 11, 12), il valore della variabile y viene aumentato di 1 e quindi viene creato un nuovo blocco di pietra nella posizione (10, 12, 12), esattamente sopra il primo.

Prova invece a scrivere:

from mcpi.minecraft import Minecraft

mc = Minecraft.create()

x, y, z = mc.player.getPos()

mc.setBlock(x+1, y, z, 1)

Lancia il programma.

Cosa è successo?

Un blocco di pietra è apparso di fronte al giocatore.

I valori delle variabili x, y e z sono infatti quelli definiti dalla funzione getPos(), che determina la posizione del giocatore, e la funzione mc.setBlock() crea un blocco di pietra alle coordinate (x+1, y, z), cioè direttamente di fronte al giocatore.

Ora prova a scrivere 2 al posto di 1 nell’istruzione:

mc.setBlock(x+1, y, z, 2)

ed esegui di nuovo il programma.

Ora il blocco è diventato d’erba!

Saresti in grado di creare un blocco di pietra direttamente sotto il giocatore?
Prova!

Blocchi predefiniti

Puoi usare delle variabili predefinite per richiamare il tipo di blocco da usare. Per farlo, ti serve però conoscere il loro nome.

Devi prima di tutto importare il modulo block:

from mcpi import block

Puoi quindi creare un blocco scrivendo un codice del tipo:

mc.setBlock(x+3, y, z, block.STONE.id)

Prova a scrivere questo programma:

from mcpi.minecraft import Minecraft
from mcpi import block

mc = Minecraft.create()

x, y, z = mc.player.getPos()

mc.setBlock(x+3, y, z, block.STONE.id)


STONE è l’ID di un blocco di pietra.

Il programma precedente dice al computer di creare un blocco di pietra a una distanza di 3 blocchi di fronte al giocatore.

Tutte le ID dei blocchi ricordano i loro nomi nella lingua inglese e sono sempre scritti con le lettere maiuscole.
Alcuni esempi sono:

WOOD_PLANKS
WATER_STATIONARY
GOLD_ORE
GOLD_BLOCK
DIAMOND_BLOCK
NETHER_REACTOR_CORE

Prova a usare queste ID al posto di STONE nel programma precedente e vedi cosa succede.

Blocchi speciali

Alcuni blocchi hanno proprietà speciali. Ad esempio WOOL ti permette di specificare il suo colore. Per sceglierlo utilizza il parametro opzionale di setBlock():

from mcpi.minecraft import Minecraft
from mcpi import block

mc = Minecraft.create()

x, y, z = mc.player.getPos()
lana = 35

mc.setBlock(x, y, z, lana, 1)


Il numero 1 indica il colore arancione. Se non scegli alcun numero, viene inserito di default il valore 0, che indica il bianco. Altri colori sono rappresentati dai numeri seguenti:

2: Magenta
3: Azzurro
4: Giallo

Prova a usare alcuni numeri e guarda come viene modificato il blocco!

Creare volumi

Se vuoi riempire un intero volume in un colpo solo, usa la funzione setBlocks():

from mcpi.minecraft import Minecraft
from mcpi import block

mc = Minecraft.create()

x, y, z = mc.player.getPos()
pietra = 1

mc.setBlocks(x+1, y+1, z+1, x+11, y+11, z+11, pietra)

Queste istruzioni riempiono di pietra un cubo di 10x10x10 direttaemente davanti al giocatore:

Come hai visto, la funzione setBlocks() usa due set di coordinate. Il primo x+1, y+1, z+1 definisce la posizione di un vertice del cubo, il secondo x+11, y+11, z+11 quella del vertice opposto.

Puoi riempire anche volumi più grandi, ma considera che più sono grandi, più tempo ci vorrà per generarli!

Creare blocchi mentre il giocatore si muove

Il codice seguente lascia dei fiori alle spalle del giocatore mentre si muove:

from mcpi.minecraft import Minecraft
from time import sleep
mc = Minecraft.create()

fiore = 38

while True:
	x, y, z = mc.player.getPos()
	mc.setBlock(x, y, z, fiore)
	sleep(0.1)

Prova a camminare per vedere cosa succede.

In questo programma abbiamo usato un loop while:

while True:
	x, y, z = mc.player.getPos()
	mc.setBlock(x, y, z, fiore)
	sleep(0.1)

Un loop ti permette di ripetere il codice in esso contenuto.
Nel nostro caso vengono ripetute le istruzioni:

x, y, z = mc.player.getPos()
mc.setBlock(x, y, z, fiore)
sleep(0.1)

E cioè:

  1. Vengono definite le variabili x, y e z con valori corrispondenti alle coordinate della posizione in cui si trova il giocatore (ottenuti usando la funzione getPos()).
  2. Viene creato un fiore nella posizione in cui si trova il giocatore.
  3. Il computer attende 0.1 secondi e riparte dal punto 1.

Poiché abbiamo usato il loop while True, il ciclo andrà avanti all’infinito.
Il nostro programma dice quindi al computer di creare un fiore nella posizione occupata dal giocatore. Se il giocatore si muove, il fiore verrà creato nella nuova posizione occupata… e così via… il giocatore lascerà sempre fiori alle sue spalle mentre cammina.

Se vuoi che non vengano più creati fiori, devi interrompere manualmente l’esecuzione del programma.

Prova ora a volare e guarda i fiori che lasci alle tue spalle.

E se volessi creare fiori solo quando il giocatore cammina sull’erba?

Per farlo dovresti riuscire a determinare il tipo di blocco sul quale il giocatore si sta muovendo.
A tal fine puoi utilizzare la funzione getBlock().

Scrivi questo programma:

from mcpi.minecraft import Minecraft
from time import sleep

mc = Minecraft.create()

x, y, z = mc.player.getPos()
questo_blocco = mc.getBlock(x, y, z)

print(questo_blocco)

Eseguilo per vedere cosa fa.

Il risultato di queste istruzioni sarà: 0. Lo puoi visualizzare nella finestra interattiva di Geany.

Visualizzare il risultato nella finestra interattiva della IDE che si sta usando è esattamente quello che fa la funzione print().
Nel nostro programma l’attributo della funzione print() è il valore assunto dalla variabile questo_blocco

questo_blocco = mc.getBlock(x, y, z)

ossia il tipo di blocco che si trova alle coordinate corrispondenti ai valori che in quel momento assumono le variabili x, y e z

x, y, z = mc.player.getPos()

e cioè le coordinate del punto in cui si trova il giocatore.

Nel nostro caso il risultato è 0 perché il giocatore sta volando nell’aria e la ID dell’aria è 0.

Se vogliamo capire su che tipo di blocco si muove il giocatore, dobbiamo determinare il tipo di blocco immediatamente sotto quello che occupa. Ci basterà a tal fine definire una nuova variabile che chiamiamo blocco_sotto e sostituire y-1 a y nel programma che abbiamo appena scritto.

from mcpi.minecraft import Minecraft
from time import sleep

mc = Minecraft.create()

x, y, z = mc.player.getPos()
blocco_sotto = mc.getBlock(x, y-1, z)

print(blocco_sotto)

E, in maniera analoga a quanto abbiamo fatto prima, possiamo scrivere un loop per determinare il tipo di blocco sopra il quale il giocatore successivamente si trova mentre si muove:

while True:
	x, y, z = mc.player.getPos()
	blocco_sotto = mc.getBlock(x, y-1, z)
	print(blocco_sotto)

Ora, quindi, il programma:

from mcpi.minecraft import Minecraft
from time import sleep

mc = Minecraft.create()

x, y, z = mc.player.getPos()
blocco_sotto = mc.getBlock(x, y-1, z)

while True:
	x, y, z = mc.player.getPos()
	blocco_sotto = mc.getBlock(x, y-1, z)
	print(blocco_sotto)

Visualizzerà nella finestra interattiva di Geany le ID dei blocchi sotto il giocatore mentre si muove.

Prova a muovere il giocatore su diverse superfici e vedi cosa succede!

Ora ritorniamo al problema che ci siamo posti in partenza: come facciamo a fare in modo che i fiori vengano creati solo quando il giocatore si trova sull’erba?

Adesso che abbiamo imparato a determinare il tipo di blocco che si trova sotto il giocatore, dobbiamo scrivere un programma che dica al computer di creare un fiore se il blocco sotto il giocatore è di erba, e di non fare nulla in caso contrario.
Eccolo:

from mcpi.minecraft import Minecraft
from time import sleep

mc = Minecraft.create()

x, y, z = mc.player.getPos()
blocco_sotto = mc.getBlock(x, y-1, z)

erba = 2
fiore = 38

while True:
	x, y, z = mc.player.getPos()
	blocco_sotto = mc.getBlock(x, y-1, z)
	if blocco_sotto == erba:
		mc.setBlock(x, y, z, fiore)
	sleep(0.1)

Prova a eseguirlo e controlla che tutto funzioni come ci aspettavamo.

Leggi con attenzione il programma che abbiamo scritto.

Prima di tutto abbiamo definito le variabili erba e fiore. Poi abbiamo usato l’operatore condizionale if per scegliere se creare o meno un fiore; abbiamo cioè posto una condizione da verificare all’interno del loop while True:

if blocco_sotto == erba:

Questa condizione, tradotta nel linguaggio parlato, sarebbe: se le variabili blocco_sotto e erba assumono lo stesso valore. E, visto che la variabile blocco_sotto ha come valore il tipo di blocco al di sotto del giocatore, questa condizione significa: se il blocco sotto il giocatore è di erba.
Se viene soddisfatta, allora:

mc.setBlock(x, y, z, fiore)

crea un fiore nel punto in cui si trova il giocatore.
Se invece non viene soddisfatta, non succede niente.

Potremmo fare in modo che, se la condizione non viene soddisfatta, succeda qualcosa: per esempio, potremmo fare il blocco che si trova sotto il giocatore venga trasformato in un blocco di erba:

else:
	mc.setBlock(x, y-1, z, erba)

Il nostro programma diventa:

from mcpi.minecraft import Minecraft
from time import sleep

mc = Minecraft.create()

x, y, z = mc.player.getPos()
blocco_sotto = mc.getBlock(x, y-1, z)

erba = 2
fiore = 38

while True:
	x, y, z = mc.player.getPos()
	blocco_sotto = mc.getBlock(x, y-1, z)
	if blocco_sotto == erba:
		mc.setBlock(x, y, z, fiore)
	else:
		mc.setBlock(x, y-1, z, erba)
	sleep(0.1)

Ora, quando il giocatore si muove, lascerà un fiore alle sue spalle se sta camminando su un blocco d’erba e, in caso contrario, il blocco sul quale si muove verrà trasformato in blocco di erba.

I blocchi TNT

Per creare un blocco TNT scrivi:

from mcpi.minecraft import Minecraft

mc = Minecraft.create()

x, y, z = mc.player.getPos()
tnt = 46

mc.setBlock(x, y, z, tnt)


Il blocco TNT ha un parametro opzionale. Prova a scrivere:

from mcpi.minecraft import Minecraft

mc = Minecraft.create()

x, y, z = mc.player.getPos()
tnt = 46

mc.setBlock(x, y, z, tnt, 1)

Ora usa la spada e fai clic (con il tasto sinistro) sul blocco TNT: si attiverà ed esploderà dopo pochi secondi!

Adesso prova a costruire un cubo di blocchi TNT:

from mcpi.minecraft import Minecraft

mc = Minecraft.create()

x, y, z = mc.player.getPos()
tnt = 46

mc.setBlocks(x+1, y+1, z+1, x+11, y+11, z+11, tnt, 1)


Ora attiva uno dei blocchi, corri via… e goditi lo spettacolo!

Il render sarà un po’ lento, perché stai chiedendo a Microninja di svolgere molte operazioni contemporaneamente!

Il blocco Lava

Un altro blocco con cui è divertente fare esperimenti è lava:

from mcpi.minecraft import Minecraft

mc = Minecraft.create()

x, y, z = mc.player.getPos()
lava = 10

mc.setBlock(x+3, y+3, z, lava)

Trova il blocco che hai appena creato: dovresti vedere la lava sgorgare dal terreno!

La cosa bella è che la lava diventa roccia una volta che si raffredda.

Ora scegli un’altra posizione nel mondo e prova a vedere cosa fa il seguente codice:

from mcpi.minecraft import Minecraft
from time import sleep

mc = Minecraft.create()

x, y, z = mc.player.getPos()

lava = 10
acqua = 8
aria = 0

mc.setBlock(x+3, y+3, z, lava)
sleep(20)
mc.setBlock(x+3,y+5, z, acqua)
sleep(4)
mc.setBlock(x+3, y+5, z, aria)


Puoi cambiare l’attributo 20 di sleep per far fluire più o meno lava.


This learning resource is provided for free by the Raspberry Pi Foundation under a Creative Commons licence.
Find more at raspberrypi.org/resources and github.com/raspberrypilearning.