Introduzione
- Informazioni su Greenfoot
Questo tutorial è un'introduzione al Mondo degli
Oggetti di Greenfoot.
Greenfoot è un software studiato per permettere
a principianti di sperimentare la programmazione orientata agli
oggetti. Greenfoot supporta lo sviluppo di applicazioni grafiche
tramite il Linguaggio di Programmazione Java™.
Greenfoot è stato progettato e realizzato dalla
University of Kent, Inghilterra, e dalla Deakin University,
Melbourne, Australia.
Ulteriori informazioni su Greenfoot sono disponibili
sul sito web www.greenfoot.org.
- Obiettivi e audience
Questo tutorial si rivolge a coloro che vogliano
familiarizzare con Greenfoot. L'obiettivo del tutorial è la
brevità più che la completezza e il focus è sulle funzionalità
dell'ambiente Greenfoot. Il tutorial non ha alcuna pretesa di
insegnare Java. Si assume infatti che il lettore abbia già familiarità
con Java o che possa disporre di supporto soprattutto nella
seconda metà di questo tutorial.
Tutte le attività descritte si riferiscono ad
uno scenario già esistente e illustrano come usare lo scenario
e come modificarlo.
Gli utenti che intendano costruire un proprio
scenario, o apportare modifiche sostanziali a scenari esistenti,
possono leggere il Greenfoot Programmer’s Manual.
- Copyright, licenza e ridistribuzione
Greenfoot e questo tutorial sono resi disponibili
'così come sono', gratuitamente per poter essere usati da chiunque
e possono essere ridistribuiti purchè in maniera gratuita. Il
disassemblaggio del sistema è proibito.
Nessuna parte di Greenfoot o della sua documentazione
può essere venduta a scopo commerciale o essere inclusa in pacchetti
venduti a scopo commerciale senza esplicita autorizzazione scritta
da parte degli autori.
Il copyright © di Greenfoot è detenuto da Poul
Henriksen e Michael Kölling.
Installazione
Il software Greenfoot
può essere scaricato dal sito www.greenfoot.org.
Sono disponibili tre diverse versioni: una per
Windows, una per MacOS X e una per tutti gli altri sistemi.
Prerequisiti
Per poter usare Greenfoot è necessario che Java
5 (JDK 1.5) o una versione successiva sia installato sul proprio
PC. Si raccomanda, in generale, di aggiornare il proprio sistema
alla più recente versione stabile (non-beta) di Java. Se sul
tuo PC non è installato il JDK potete scaricarlo dal sito web
della Sun alla pagina http://java.sun.com/j2se/ . Non scaricate
le versioni denominate “JRE” (Java Runtime Environment) – le
versioni JRE non sono infatti sufficienti. Ciò che vi occorre
è una versione il cui nome contenga JDK.
In MacOS X è già pre-installata una versione
recente di J2SE - non occorre quindi che voi la installiate
di nuovo.
- Installazione in Windows
Per i sistemi basati su Microsoft Windows, è
sufficiente scaricare la versione Windows del programma di installazione.
Fate doppio click sul file dell'installatore e seguite le istruzioni.
L'installazione non si discosta dalle normali installazioni
standard.
- Installazione in Mac OS X
Per i sistemi basati su Mac OS X, scaricate la
versione Mac OS del software. Il file scaricato è un file zip.
Il vostro browser potrebbe scompattare il file automaticamente.
Se questo non accade, fate doppio click sul file zip per scompattarlo.
La cartella risultante conterrà l'applicazione
Greenfoot e gli scenari di esempio. Entrambi possono essere
spostati dove preferite. In generale l'applicazione Greenfoot
potrà essere posizionata nella cartella Applicazioni e gli ‘scenari’
nella cartella Documenti.
- Installazione in altri sistemi
L'Installatore per tutti gli altri sistemi è
un file jar eseguibile. Potete eseguire l'installatore scrivendo
in una finestra a linea di comando
java -jar greenfoot-installer-XX.jar
(dove XX è il numero della versione del vostro
file di installazione). In alcuni sistemi potrebbe essere anche
possibile cliccare due volte sul file jar. (Si noti che il comando
descritto suppone che il comando ‘java’ sia in una cartella
che compare nel percorso dei comandi. Nel caso in cui non sia
così, installate e configurate java prima di procedere.)
- Lo scenario WOMBATS
Questo tutorial usa due scenari, denominati
‘wombats’ e ‘wombats2’ . Entrambi
gli scenari possono essere scaricati come un unico file zip
cliccando qui.
Una volta estratto il file zip, ciascuno scenario è contenuto
in una cartella separata.
Figura 1: Lo scenario Wombat mostrato in Greenfoot
Come iniziare
- Aprire un progetto Greenfoot
E' possibile che abbiate già aperto questo tutorial
direttamente dall'applicazione Greenfoot. Nel caso in cui non
fosse così, lanciate Greenfoot ora.
Il processo di installazione ha installato un'applicazione
denominata ‘greenfoot’. Lanciatela. (Nei sistemi Linux e Unix,
‘greenfoot’ è uno shell script eseguibile.)
Una volta avviato Greenfoot, se lo scenario Wombats
non viene aperto automaticamente, selezionate ‘Apri...’ dal
menu ‘Project’ e selezionate quindi lo scenario ‘wombats’ dagli
scenari di esempio di Greenfoot.
Dovreste a questo punto vedere qualcosa di simile
a quanto mostrato in Figura 1 (tranne per il fatto che non vedrete
ancora nessuna foglia o wombat).
L'ampia area coperta da una griglia che
riempie la maggior parte della finestra è chiamata “il mondo”.
Poichè abbiamo uno scenario che ha a che fare con dei wombat
(vedi Nota 1), stiamo vedendo un mondo di wombat.
Alle destra della finestra c'è il visualizzatore
delle classi. In questa area potete vedere tutte
le classi Java usate nel progetto.
Le classi “World” e “Actor” sono sempre presenti
– fanno parte di Greenfoot. Le classi rimanenti fanno parte
dello scenario wombat, e risulteranno diverse se usate uno scenario
diverso.
Sotto al mondo trovate i Controlli di Esecuzione
(l'area con i pulsanti ‘Azione’ e ‘Esegui’ e il cursore).
- Informazioni sullo scenario
Vicino all'angolo superiore destro della finestra
trovate il pulsante "Informazioni Scenario". Molti
scenari, quando si clicca questo pulsante, mostreranno alcune
informazioni sullo scenario. Queste informazioni riguardano
di solito lo scopo dello scenario, come eseguirlo, come usarlo,
e talvolta danno suggerimenti su come modificarlo.
- Posizionare oggetti nel mondo
Posizioniamo ora degli oggetti nel mondo.
Cliccate con il pulsante destro (per il Mac:
Control-click) la classe Wombat presente nel visualizzatore
delle classi. Nel menu contestuale selezionate ‘New Wombat()’.
Quindi cliccate in un punto qualsiasi del mondo. Avete appena
creato un wombat (nei termini Java: un oggetto) e lo avete posizionato
nel mondo.
Siccome i Wombat mangiano foglie, posizioniamo
anche alcune foglie nel mondo. Cliccate ora la classe Foglia
e posizionate la foglia.
E' possibile posizionare più oggetti in maniera
un po' più veloce: cliccando più volte nel mondo tenendo al
contempo premuto il pulsante MAIUSC. Assicuratevi che la classe
Foglia sia selezionata, quindi mantenete premuto il tasto MAIUSC
e cliccate alcune volte di seguito nel mondo. Ad ogni click
un oggetto della classe selezionata verrà posizionato nel mondo.
- Far agire gli oggetti
Cliccate il pulsante ‘Azione’ che trovate tra
i controlli di esecuzione. Ogni oggetto compierà un'azione –
cioè: ogni oggetto fa quello che vuol fare.
Cosa gli oggetti vogliano fare dipende da come
sono stati definiti – ritorneremo su questo punto tra un po'.
Nel nostro esempio, le foglie sono definite in modo che non
facciano nulla, mentre i wombat sono definiti in modo da muoversi
in avanti. Se ancora non lo avete fatto, posizionate due wombat
nel mondo e premete Azione di nuovo. Si muoveranno entrambi.
I Wombat amano anche mangiare le foglie. Se gli
accade di incrociare una foglia nel loro percorso, la mangiano.
- Eseguire uno scenario
Cliccate ora il pulsante ‘Esegui’. Questa azione
equivale a cliccare ripetutamente il pulsante Azione, molto
velocemente. Noterete che il pulsante Esegui si trasforma nel
pulsante ‘Sospendi’. Cliccandolo si blocca ogni azione.
Il cursore a fianco ai pulsanti Azione e Esegui
definisce la velocità di esecuzione. Per vedere cosa intendiamo,
cliccate sul pulsante Esegui e poi modificate la posizione del
cursore.
- Chiamare i metodi direttamente
Invece di eseguire l'intero scenario, potete
anche chiamare i singoli metodi. Un metodo è una singola azione
che può essere eseguita da un oggetto.
Assicuratevi che ci sia almeno un wombat nel
mondo e che lo scenario non sia in esecuzione. Cliccate ora
con il pulsante destro sul wombat. Vedrete che gli oggetti del
mondo hanno anche un menu contestuale (Figura 2).
Figura 2: Il menu contestuale di un oggetto
Potete selezionare uno qualunque dei metodi mostrati
per chiedere al wombat di fare qualcosa. Provate, per esempio,
giroASinistra(). La selezione di questo metodo dal menu dice
al wombat di girare a sinistra. Provate ora miSposto().
Alcuni metodi vi forniscono una risposta. comunicaFoglieMangiate(),
ad esempio, vi dirà quante foglie il wombat ha mangiato sinora.
Provatelo.
Noterete anche un metodo chiamato ‘act()’. Questo
metodo viene chiamato ogni volta che cliccate sul pulsante Azione.
Se volete far agire un solo oggetto invece di tutti gli oggetti
del mondo potete chiamare direttamente il metodo act dell'oggetto.
- Creare un nuovo mondo
Se nel mondo ci sono molti oggetti che non volete
più, e volete iniziare da capo, c'è un modo semplice per farlo:
gettare via il mondo e crearne uno nuovo.
Potete farlo cliccando con il pulsante destro
sulla classe MondoWombat e selezionando ‘new MondoWombat()’.
Otterrete un mondo nuovo e vuoto. Il mondo precedente verrò
scartato (e con lui tutti gli oggetti in esso contenuti) – è
possibile avere soltanto un mondo alla volta.
- Chiamare un metodo del mondo
Abbiamo visto che gli oggetti nel mondo hanno
dei metodi che è possibile chiamare usando il menu contestuale.
Anche il mondo è un oggetto con dei propri metodi che è possibile
chiamare.
Abbiamo visto nella sezione precedente come creare
un nuovo mondo. Ora vogliamo chiamare un metodo dell'oggetto
mondo.
Sopra al visualizzatore del mondo è visibile
un titolo che mostra il nome del mondo – “MondoWombat” nel nostro
caso. Cliccate con il pulsante destro sul titolo e vedrete comparire
il menu del mondo.
Uno dei metodi del menu è ‘popola()’. Provatelo.
Questo metodo crea alcune foglie e alcuni wombats e li posiziona
nel mondo. Una volta fatto, potete eseguire lo scenario.
Un'altro metodo del mondo è ‘foglieCasuali(int
quanteFoglie)’. Questo metodo piazza nel mondo alcune foglie
in posizioni casuali. Notate che subito dopo il proprio nome
questo metodo presenta alcune parole tra parentesi : int quanteFoglie
. Questo è quello che viene chiamato ‘parametro’. Ciò
che questo significa è che occorre specificare alcune informazioni
aggiuntive quando chiamate il metodo. Il termine ‘int’ vi dice
innanzitutto che ciò che ci si aspetta è un numero intero
, e ‘quanteFoglie’ suggerisce che dovreste specificare quante
foglie volete piazzare nel mondo.
Chiamate il metodo. Comparirà una finestra di
dialogo che vi permetterà di inserire un valore per questo parametro.
Inserite un numero – ad esempio 12 – e cliccate su Ok.
(Potreste notare, se vi è capitato di contare
le foglie, che talvolta sembra che venga creato un numero di
foglie inferiore a quello specificato. Il motivo è che alcune
foglie potrebbero essere piazzate esattamente nella stessa cella,
e si trovano quindi una sull'altra.)
Okay, forse ne avete avuto abbastanza di wombat
che girano in cerchio all'infinito – passiamo quindi alla parte
davvero interessante: come programmare un comportamento più
interessante per i vostri wombat!
Programmazione
La parte restante di questo tutorial assume che
il lettore abbia qualche familiarità con la programmazione Java.
Non è stato pensato come un'attività iniziale per studenti alle
prime armi.
- Modificare il comportamento di un oggetto
Potete programmare i vostri oggetti – wombat,
o qualunque altra cosa vogliate – scrivendo del codice Java
per la classe del vostro oggetto. E' quello che faremo proprio
ora.
Cliccate due volte sulla classe Wombat nel visualizzatore
delle classi. Si aprirà un editor e potrete vedere il codice
sorgente Java della classe Wombat.
La prima cosa che vogliamo fare è quella di modificare
il comportamento del wombat in modo che, quando non può mouversi
in avanti, giri in una direzione casuale invece di girare sempre
a sinistra. Per far ciò, aggiungiamo prima un metodo ‘giroACaso()’.
Aggiungete alla classe Wombat il metodo seguente:
/**
* Gira in una direzione a caso.
*/
public void giroACaso()
{
// genera un numero casuale compreso tra
0 e 3...
int svolte = Greenfoot.getRandomNumber(4);
// ...e gira a sinistra quel preciso numero
di volte.
for(int i=0; i<svolte; i++) {
giroASinistra();
}
}
Ora modifichiamo ‘act()’ in modo che usi giroACaso.
Il metodo act() è attualmente definito come segue:
public void act()
{
if(hoTrovatoUnaFoglia()) {
mangioLaFoglia();
}
else if(possoSpostarmi()) {
miSposto();
}
else {
giroASinstra();
}
}
Sostituite la chiamata a ‘giroASinistra()’ che
trovate alla fine del metodo con una chiamata a ‘giroACaso()’.
Okay, abbiamo finito. Proviamo ora cosa succede.
Cliccate il pulsante ‘Compila’ che trovate nell'editor. Se dovesse
comparire qualche errore, correggetelo e compilate di nuovo.
Ripetete queste operazioni fino a che la classe verrà compilata
senza errori. Ora potete chiudere l'editor.
- Compilare il progetto
Prima di poter eseguire un progetto è necessario
compilarlo. Potete farlo direttamente dall'editor, oppure dalla
finestra principale di Greenfoot.
Una volta che la compilazione si sia conclusa
con successo, potete creare nuovamente degli oggetti. La compilazione
(quando si conclude con successo) instanzia automaticamente
un nuovo mondo.
- Modificare le immagini
Ci sono due modi di modificare le immagini degli
oggetti: Potete modificare l'immagine della classe, che comporterà
la modifica dell'immagine predefinita di tutti gli oggetti della
classe. Oppure un oggetto può modificare la propria immagine
tramite il proprio programma, che il comporterà la modifica
dell'immagine soltanto del singolo oggetto. Ciascun oggetto
può modificare la propria immagine ogni volta che crede.
Per modificare l'immagine di una classe, selezionate
‘Definisci Immagine...’ dal menu contestuale della classe. Potete
fare una prova con la classe Foglia – cambiando l'immagine,
ad esempio, con quella di una banana, il wombat raccoglierà
banane. (Probilmente non è qualcosa che il guardiano del vostro
zoo raccomanderebbe, ma è proprio per questo che stiamo usando
una simulazione...) Greenfoot include una libreria di immagini
che potete usare a questo scopo, oppure potete mettere le vostre
immagini nella cartella ‘images’ (contenuta all'interno della
cartella dello scenario, ‘wombats’) e usare una di queste.
La seconda possibilità è quella di lasciare a
ciascun oggetto la possibilità di modificare la propria immagine
attraverso le azioni definite nel proprio programma. Per farlo
è sufficiente che l'oggetto chiami il metodo ‘setImage’ ereditato
dalla classe Actor. Ci sono due versioni di ‘setImage’: una
si aspetta un parametro di tipo GreenfootImage, l'altra usa
il nome di un file (e usa l'immagine dopo aver letto il file
in un oggetto GreenfootImage).
In questo tutorial useremo la seconda alternativa,
quella che legge un'immagine da un file. L'effetto che vogliamo
raggiungere è che i wombat non appaiano a testa in giù quando
camminano verso sinistra. Il progetto ‘wombats’ contiene già
un file denominato ‘wombat-sinistra.gif’ nella sua sottocartella
‘images’. Questo è un file immagine in formato GIF che mostra
un'immagine a specchio del wombat che abbiamo visto sinora:
un wombat rivolto a sinistra.
Possiamo modificare l'immagine del wombat con
la versione rivolta a sinistra scrivendo:
setImage("wombat-sinistra.gif");
Useremo questo metodo quando il wombat cambia
direzione. Per far questo dobbiamo modificare il metodo ‘voltatiVerso(int
Direzione)’ del Wombat. Cercatelo nel codice sorgente del Wombat.
Aggiungeremo ora alcune linee per definire l'immagine
e la rotazione corrette quando definiamo una direzione. Useremo
l'immagine ‘wombat-sinistra’ quando procediamo verso ovest o
verso nord, e useremo invece l'immagine originale ‘wombat’ quando
procediamo verso est o verso sud. Notate che l'immagine ‘wombat-sinistra’
come impostazione predefinita è rivolta verso ovest – non occorre
che sia ruotata quando procediamo verso ovest.
Ecco qui la nuova versione di ‘voltatiVerso’:
/**
* Definisce la direzione in cui si vuole andare.
*/
public void voltatiVerso(int direzione)
{
this.direzione = direzione;
switch(direzione) {
case SUD :
setImage("wombat.gif");
setRotation(90);
break;
case EST :
setImage("wombat.gif");
setRotation(0);
break;
case NORD :
setImage("wombat-sinistra.gif");
setRotation(90);
break;
case OVEST :
setImage("wombat-sinistra.gif");
setRotation(0);
break;
default :
break;
}
}
Ora il metodo funziona come dovrebbe. Qualora
volessimo programmarlo in maniera più precisa, dovremmo caricare
dal file gli oggetti di tipo immagine una sola volta (nel costruttore)
e memorizzarli in campi di tipo GreenfootImage.
A questo punto potremmo usare i due oggetti immagine per cambiare
l'immagine tutte le volte che vogliamo.
Forse dovremmo ora aggiungere immagini separate
anche per gli spostamenti verso l'alto e verso il basso – ma
lasciamo questo utile esercizio ai lettori entusiasti.
- Informazioni sulle classi Greenfoot
Per apportare cambiamenti al comportamento degli
oggetti, è spesso necessario fare uso di classi standard messe
a disposizione da Greenfoot. Greenfoot rende disponibili quattro
classi che è importante conoscere: World, Actor, GreenfootImage
e Greenfoot.
Le prima due classi sono visibili nell'interfaccia,
e costituiscono le superclassi per il mondo e le classi degli
oggetti dello scenario. GreenfootImage viene usata per lavorare
con le immagini, e infine Greenfoot rende possibile l'accesso
all'ambiente Greenfoot stesso.
Il modo più semplice per ottenere informazioni
su queste classi è quello di consultare la documentazione online
di Greenfoot. La potete trovare all'indirizzo
http://www.greenfoot.org/doc/
Da
questa pagina potete consultare la versione online della descrizione
delle classi (chiamata “Greenfoot API”), o potete scaricare
la descrizione come un singolo documento stampabile.
- Ispezionare gli oggetti
Grazie alla funzione ‘Ispeziona’ del menu contestuale
di un qualunque wombat presente nel mondo, potete guardare all'interno
dell'oggetto e ispezionare i valori di tutti i suoi campi. Può
rivelarsi molto utile per poter fare delle verifiche durante
la creazione delle vostre classi.
Noterete che ci sono alcuni campi che sono stati
definiti nel codice della classe Wombat (come ‘foglieMangiate’)
e alcuni che invece non sono definiti nella classe Wombat. I
campi aggiuntivi (come x, y e rotation) sono ereditati dalla
classe Actor e sono presenti in tutti gli oggetti di Greenfoot.
Se un valore viene mostrato come una freccia,
allora il campo contiene un riferimento ad un'altro oggetto,
che può essere ispezionato a sua volta (selezionando la freccia
e cliccando su ‘Ispeziona’).
- Creare una nuova classe
E' ora giunto il momento di rendere la vita del
nostro wombat un po' più interessante aggiugendo degli ostacoli:
le rocce. (Le rocce che creeremo saranno così grandi che i wombat
non potranno arrampicarvici sopra.)
Per far ciò, creiamo una nuova classe di tipo
actor. Selezionate ‘Nuova sottoclasse’ dal menu contestuale
della classe Actor. Questo creerà una nuova classe che sarà
una sottoclasse di Actor. Quando vi sarà richiesto il nome della
classe, digitate ‘Roccia’. Vi verrà anche richiesto di selezionare
un'immagine per la classe.
Potete trovare (grazie al vostro amico Google!)
o creare (usando un qualunque programma di grafica) un'immagine
e salvarla nella cartella ‘images’ del vostro progetto prima
di creare la classe. L'immagine verrà quindi mostrata nella
finestra di dialogo per la creazione della nuova classe. Nel
nostro caso, abbiamo semplificato le cose inserendo già nel
progetto un file di immagine chiamato ‘roccia.gif’.
Selezionate l'immagine, cliccate su Ok, ed ecco
che una nuova classe denominata Roccia è stata creata.
Aprite ora l'editor della classe. Noterete che
uno scheletro per il codice sorgente è gia presente. Non abbiamo
bisogno per ora di scrivere alcun codice aggiuntivo. (Le rocce
non hanno nessun comportamento particolare.)
Chiudete l'editor, compilate e testate (creando
un oggetto). Voilá – ecco qui le vostre rocce!
Ora popolate lo scenario con un po' di oggetti
e testate i wombat. (Potete usare ad esempio i metodi ‘popola’
e ‘foglieCasuali’ del mondo, quindi potete aggiungere alcune
rocce a mano.) Noterete che pur essendo ora presenti delle rocce,
i wombat le attraversano. Bene – c'è ancora del lavoro da fare.
- Creare i propri scenari
In questo tutorial viene affrontato il problema
di come apportare modifiche rilevanti agli scenari o come creare
scenari completamente nuovi. Se siete interessati a questo,
avete due alternative: Esaminare gli scenari esistenti o leggere
il Greenfoot Programmer’s Manual.
(Nota: In realtà potete farlo solo parzialmente.
Per ora, il Programmer’s Manual è ancora molto incompleto...
spiacenti.)
Naturalmente vi occorre disporre anche della
documentazione delle classi di Greenfoot (la Greenfoot API),
come discusso in precedenza.
L'ultima cosa che vi mostreremo quindi in questo
tutorial, per fornirvi una veloce carrellata, è come apportare
un'ulteriore modifica per far si che i wombat smettano di camminare
attraverso le rocce.
Aprite l'editor per la classe Wombat e cercate
il metodo ‘possoSpostarmi’. Per ora questo metodo controlla
se siamo di fronte ai confini del mondo. Dobbiamo modificarlo
in modo che restituisca false (falso, ossia non
posso spostarmi nella direzione attuale) anche quando abbiamo
una roccia proprio di fronte a noi.
Sostituite l'ultimo comando return, che al momento
appare come segue
return true;
con il seguente:
List rocce = myWorld.getObjectsAt(x, y,
Roccia.class);
if(rocce.isEmpty()) {
return true;
}
else {
return false;
}
Questa porzione di codice ricava una lista di
tutte le rocce che si trovano nella cella di fronte a noi. Se
la lista è vuota, possiamo spostarci in avanti, altrimenti non
possiamo.
Il progetto ‘wombats2’, incluso nel download
di questo tutorial, include tutti i cambiamenti
che abbiamo discusso sinora.
- E ora?
Aprite qualcuno degli scenari che sono stati
installati insieme a Greenfoot. Vedete quali vi sembrano più
interessanti e cercate di capire come sono stati realizzati.
Andate sul sito di Greenfoot e cercate altri
scenari.
Meglio di tutto: discutete con altri utenti di
Greenfoot.
Ci sono due modi per saperne di più su Greenfoot
ed entrare in contatto con la comunità di Greenfoot :
