Traduzione del tutorial ufficiale.

1 – Informazioni

Questo tutorial è un’introduzione al mondo degli oggetti di Greenfoot.
Greenfoot è uno strumento software progettato per permettere ai principianti di sperimentare la programmazione orientata agli oggetti.
Greenfoot permette lo sviluppo di applicazioni grafiche tramite Java.

Greenfoot è stato progettato e realizzato da

• University of Kent, Inghilterra
• Deakin University, Melbourne, Australia.

Ulteriori informazioni su Greenfoot sono disponibili sul web: http://www.greenfoot.org.

2 – Obiettivi

Questo tutorial si rivolge a chi vuole farsi un’infarinatura su Greenfoot.
Il tutorial si prefigge di essere breve, più che completo, e si concentra sulle funzionalità dell’ambiente di sviluppo di Greenfoot.
Il tutorial non intende insegnare Java. Si assume che il lettore sappia già qualcosa di Java o che possa essere aiutato almeno per la seconda parte del tutorial.

Tutte le attività descritte si riferiscono ad uno scenario già esistente e spiegano come utilizzarlo e come modificarlo.

Se vuoi realizzare i tuoi scenari, o apportare modifiche sostanziali a scenari esistenti, dovresti leggere anche il Manuale del Programmatore.

3 – Copyright

Il software Greenfoot e questo tutorial sono disponibili gratuitamente, così come sono, per chiunque voglia utilizzarli e anche ridistribuirli ma gratuitamente.
Il disassemblaggio del software è proibito.

Nessuna parte di Greenfoot o della sua documentazione puo essere venduta o essere inclusa in altri prodotti per essere venduta senza l’autorizzazione scritta degli autori.

Il copyright © di Greenfoot appartiene a Poul Henriksen e Michael Kölling.

Installazione

Sono disponibili tre diverse versioni: una per Windows, una per MacOS X e una per tutti gli altri sistemi.

Per poter usare Greenfoot è necessario che sia installata una versione di Java SDK (5 o successiva).
La puoi scaricare dal sito web della Sun: http://java.sun.com/javase/.
Non scaricare le versioni denominate JRE (Java Runtime Environment) perché le versioni JRE non sono sufficienti.

(…)

4 – Installazione in Windows

Per i sistemi Microsoft Windows è sufficiente scaricare la versione Windows del programma di installazione. Fai doppio clic sul file di installazione e segui le istruzioni. L’installazione segue i passi standard.

(…)

7 – Lo scenario WOMBATS

Questo tutorial usa due scenari: wombats e wombats2.
Essi sono compresi nella distribuzione come questo tutorial.
Ciascuno scenario è contenuto in una cartella separata.

Come iniziare

8 – Apri un progetto Greenfoot

Probabilmente hai aperto questo tutorial dall’applicazione di Greenfoot. Se non l’hai ancora fatto aprila.

Il processo di installazione ha installato un’applicazione denominata Greenfoot. Lanciala. (Nei sistemi Linux e Unix si tratta di uno script di shell eseguibile.)

Una volta avviato Greenfoot, se lo scenario Wombats non viene aperto automaticamente seleziona Scenario>Apri... e seleziona quindi lo scenario wombats dagli scenari di esempio di Greenfoot.

A questo punto dovresti vedere sullo schermo qualcosa di simile alla Figura 1 (tranne per il fatto che non vedi ancora alcuna foglia o vombato).

L’area con un’ampia griglia che copre la maggior parte della finestra è chiamata il mondo. Poiché abbiamo uno scenario che ha a che fare con dei vombati, stiamo vedendo il mondo del vombato. (Il vombato è un animale nativo dell’Australia,http://it.wikipedia.org/wiki/Vombato.) Sul lato destro della finestra c’è il pannello delle classi. In questa area vedi tutte le classi Java coinvolte nel progetto.

Le classi World e Actor ci osno sempre perché fanno parte di Greenfoot. Le altre classi appartengono allo scenario wombats, e saranno diverse per scenari diversi.

Al di sotto del mondo ci sono i controlli di esecuzione (i pulsanti Azione e Esegui e il cursore).

9 – Informazioni sullo scenario

Nell’angolo in alto a destra della finestra c’è il pulsante Informazioni Scenario. Molti scenari, quando si clicca questo pulsante, mostreranno delle informazioni sullo scenario. Queste informazioni ti spiegano lo scopo dello scenario, come eseguirlo, cosa ci puoi fare, e magari ti danno suggerimenti su come modificarlo.

10 – Posiziona gli oggetti nel mondo

Posizionioneremo adesso degli oggetti nel mondo.

Clicca con il pulsante destro sulla classe Wombat presente nel pannello delle classi. Appare un menu contestuale, seleziona new Wombat().
Dopo clicca in un punto qualsiasi del mondo. Hai appena creato un vombato (in Java: un oggetto) e lo hai posizionato nel mondo.

I vombati mangiano foglie, quindi è giusto posizionare alcune foglie nel mondo. Agisci sulla classe Leaf e posiziona la foglia.

C’è un metodo più veloce per sistemare diversi oggetti: seleziona la classe Leaf e clicca diverse volte sul mondo mantenendo abbassato il tasto Shift. Posizionerai un oggetto della classe selezionata per ogni clic.

11 – Fai agire gli oggetti

Clicca sul pulsante Azione del pannello di esecuzione.
Ogni oggetto compierà un’azione cioè ogni oggetto farà quello che vuole fare.

Cosa vogliano fare gli oggetti dipende da come sono stati definiti ma ritorneremo dopo su questo punto.
Nel nostro esempio le foglie sono definite in modo che non facciano nulla, mentre i vombati sono definiti per muoversi in avanti.
Se non lo hai ancora fatto posiziona due vombati nel mondo e premi di nuovo Azione.
Entrambi si muoveranno.

I vombati amano mangiare le foglie, anche.
Se gli capita di incrociare una foglia, la mangiano.

12 – Lancia uno scenario

Clicca sul pulsante Esegui.
Questo è equivalente a cliccare ripetutamente il pulsante Azione, molto velocemente.
Noterai che il pulsante Esegui si trasforma nel pulsante Sospendi.
Se si clicca, si ferma tutto.

Il cursore a fianco dai pulsanti Azione e Esegui imposta la velocità di esecuzione.
Per capire cosa intendo, clicca sul pulsanteEsegui e poi muovi il cursore.

13 – Chiama i metodi direttamente

Piuttosto che eseguire l’intero scenario puoi anche chiamare i singoli metodi.
Un metodo è una singola azione che un oggetto può eseguire.

Assicurati che ci sia almeno un vombato nel mondo e che lo scenario non sia in esecuzione.
Clicca ora con il pulsante destro sul vombato e vedi che anche gli oggetti nel mondo hanno un menu contestuale.

Puoi scegliere uno qualsiasi dei metodi per chiedere al vombato di fare qualcosa.
Prova, per esempio, turnLeft().
Selezionando questo metodo dici al vombato di girare aalla sua sinistra.
Prova move().

Alcuni metodi ti danno una risposta: getLeavesEaten(), ad esempio, ti dirà quante foglie ha mangiato finora il vombato. Prova.

Noterai anche un metodo chiamato act().
Questo metodo viene chiamato ogni volta che clicchi sul pulsante Azione.
Se vuoi far agire un solo oggetto, invece che tutti gli oggetti del mondo, puoi farlo chiamando direttamente il metodo act() dell’oggetto.

14 – Crea un nuovo mondo

Se nel mondo hai molti oggetti che non vuoi più, e vuoi far ripartire tutto, c’è un modo semplice per farlo: butta via il mondo e creane uno nuovo. Questo si fa cliccando sul pulsante Resetta in basso. Otterrai un nuovo mondo vuoto. Il mondo precedente verra abbandonato (e con lui tutti gli oggetti che c’erano dentro) perché è possibile avere un solo mondo alla volta.

15 – Chiama un metodo del mondo

Abbiamo visto che gli oggetti nel mondo hanno dei metodi che puoi chiamare tramite il menu contestuale. Il mondo stesso è un oggetto con i propri metodi che tu puoi chiamare.

Nella sezione precedente abbiamo visto come creare un nuovo mondo. Ora vogliamo chiamare un metodo dell’oggetto mondo.

Sopra il pannello del mondo c’è un titolo che mostra il nome del mondo, nel nostro caso wombatWorld.
Clicca con il pulsante destro sul titolo e vedrai apparire il menu contestuale del mondo. (Stiamo parlando del titolo del mondo e non del nome della classe nel pannello a destra.)

Uno dei metodi del menu è populate().
Provalo. Questo metodo crea delle foglie e dei vombati e li posiziona nel mondo. Dopo lancia lo scenario.

Un altro metodo del mondo è randomLeaves(int howMany).
Questo metodo posa delle foglie nel mondo in posizioni casuali.
Nota che questo metodo ha, dopo il proprio nome, alcune parole tra parentesi: int howLeaves.
Questo è detto parametro.
Significa che devi specificare alcune informazioni aggiuntive quando chiami questo metodo.
Il termine int ti dice che si aspetta un numero intero, e howMany suggerisce che devi specificare quante foglie vuoi.

Chiama il metodo.
Comparirà una finestra di dialogo che ti permetterà di inserire un valore per il parametro.
Inserisci un numero, ad esempio 12, e cliccate su Ok.

(Potresti notare, se conti le foglie, che a volte ne appaiono meno di quelle specificate. Il motivo è che alcune foglie potrebbero essere nella stessa cella, e stanno quindi una sull’altra.)

Okay, forse ne hai abbastanza di vombati che girano in cerchio all’infinito… passiamo quindi alla parte veramente appassionante: programmare comportamenti più interessanti per i tuoi vombati!

Programmazione

Per la parte rimanente di questo tutorial si suppone che tu abbia qualche familiarità con le basi della programmazione in Java. Questa parte non è indicata per programmatori alle prime armi.

16 – Modifica il comportamento di un oggetto

Puoi programmare i tuoi oggetti, vombati o qualsiasi altro, scrivendo del codice Java per la classe dell’oggetto. È quello che faremo adesso.

Fai doppio clic sulla classe Wombat nel pannello delle classi. Si apre un editor e vedrai il codice sorgente Java della classe Wombat.

La prima cosa che vogliamo fare è modificare il comportamento del vombato in modo che, quando non può muoversi in avanti, giri in una direzione casuale piuttosto che girare sempre a sinistra. Per fare questo, aggiungiamo prima un metodoturnRandom().
Aggiungi alla classe Wombat il metodo seguente:

/**
 * Gira in una direzione a caso.
 */
public void turnRandom()
{
   int turns = Greenfoot.getRandomNumber(4);   // genera un numero casuale compreso tra 0 e 3...
   for(int i=0; i < turns; i++)                  // ...e gira a sinistra quel numero di volte.
   {
      turnLeft();
   }
}

Ora modifichiamo act() in modo che utilizzi turnRandom(). Il metodo act() è attualmente:

public void act()
{
   if(foundLeaf())
   {
      eatLeaf();
   }
   else if(canMove())
   {
      move();
   }
   else
   {
      turnLeft();
   }
}

Sostituisci la chiamata turnLeft() in fondo con una chiamata di turnRandom().

Okay, hai finito. Adesso mettilo alla prova. Clicca sul pulsante Compila nell'editor. Se dovesse essere visualizzato qualche errore, correggilo e compila di nuovo. Ripeti finché la classe non si compila senza errori. Ora puoi chiudere l'editor.

17 - Compila il tuo progetto

Prima di poter eseguire il tuo progetto devi compilarlo.
Puoi farlo direttamente dall'editor oppure dalla finestra principale di Greenfoot.

Dopo averlo compilato con successo, puoi di nuovo creare oggetti.
La compilazione (quando va bene) istanzia automaticamente un oggetto mondo.

18 - Modifica le immagini

Questa sezione deve essere revisionata

Ci sono due modalità per modificare le immagini degli oggetti:

• Puoi modificare l'immagine di una classe, questo provocherà la modifica dell'immagine predefinita di tutti gli oggetti della classe.
• Oppure un oggetto può modificare la sua immagine attraverso il suo codice, questo provocherà la modifica dell'immagine del singolo oggetto.
  Ciascun oggetto può modificare la propria immagine ogni volta che crede.

Per impostare l'immagine di una classe, seleziona Definisci Immagine... dal menu contestuale della classe. Prova con la classeLeaf: cambia l'immagine, ad esempio, con quella di una banana, il vombato 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 puoi usare a questo scopo, oppure puoi spostare le tue immagini nella cartellaimages all'interno della cartella dello scenario (wombats) e poi utilizzarle.

La seconda possibilità è quella di lasciare a ciascun oggetto la possibilità di modificare la propria immagine attraverso le azioni definite dal proprio codice. Si fa semplicemente chiamando il metodo setImage() ereditato dalla classe Actor.
Ci sono due versioni di setImage():

1. una prevede un parametro di tipo GreenfootImage,
2. l'altra riceve il nome di un file (e poi legge l'immagine dal file e l'assegna a un oggetto GreenfootImage).

Noi useremo la versione che legge un'immagine da file. L'obiettivo che vogliamo raggiungere è che i vombati non appaiano capovolti quando vanno a sinistra.
Il progetto wombats contiene già un file denominato wombat-left.gif nella sua sottocartella images. Si tratta di un file immagine in formato GIF che mostra un'immagine riflessa del vombato che abbiamo visto sinora: un vombato rivolto a sinistra.

Possiamo modificare l'immagine del vombato con la versione rivolta a sinistra scrivendo:

setImage("wombat-left.gif");

Useremo questo metodo quando il vombato cambia direzione. Per questo dobbiamo modificare il metodo turnLeft() del vombato. Cercalo nel codice sorgente del vombato.

Aggiungeremo ora alcune linee per impostare l'immagine giusta e la rotazione giusta quando impostiamo una direzione. Useremo l'immagine wombat-left quando procediamo verso ovest o verso nord, e l'immagine originale wombat quando procediamo verso est o verso sud. Nota che l'immagine wombat-left è rivolta verso ovest e quindi non occorre che sia ruotata quando procediamo verso ovest.

Ecco qui la nuova versione di setDirection():

/**
 * Definisce la direzione verso cui è rivolto.
 */
public void setDirection(int direction)
{
   this.direction = direction;
   switch(direction)
   {
      case SOUTH : setImage(wombatRight); setRotation(90); break;
      case EAST  : setImage(wombatRight); setRotation(0);  break;
      case NORTH : setImage(wombatLeft);  setRotation(90); break;
      case WEST  : setImage(wombatLeft);  setRotation(0);  break;
   }
}

Adesso funziona abbastanza bene. Se avessimo voluto fare più sul serio, avremmo dovuto caricare da file gli oggetti di tipo immagine una sola volta (nel costruttore) e memorizzarli in campi di tipo GreenfootImage. E poi usare i due oggetti immagine per cambiare l'immagine ripetutamente.

Ora forse dovremmo aggiungere immagini diverse anche per gli spostamenti verso l'alto e verso il basso ma lasciamo questo impegno al lettore volenteroso.

19 - Le classi di Greenfoot

Per apportare cambiamenti al comportamento degli oggetti, avrai bisogno di usare una delle classi standard di Greenfoot. Greenfoot fornisce quattro classi che tu dovresti conoscere: World, Actor, GreenfootImage e Greenfoot.

Le prima due classi sono visibili nell'interfaccia, e costituiscono le superclassi per il mondo e per le classi degli oggetti nello scenario. GreenfootImage viene usata per lavorare con le immagini e Greenfoot fornisce l'accesso all'ambiente di Greenfoot stesso.

Il modo più semplice per ottenere informazioni su queste classi è quello di consultare la documentazione online di Greenfoot:http://www.greenfoot.org/doc/.

Da questa pagina puoi consultare la versione online della descrizione delle classi (detta Greenfoot API) e puoi scaricarla come un singolo documento stampabile.

20 - Ispezionare un oggetto

Chiama la funzione Ispeziona dal menu contestuale di un vombato presente nel mondo. Questo ti permette di guardare dentro l'oggetto e ispezionare i valori dei suoi campi. Questo aiuta nella verifica delle classi durante il loro sviluppo.

Noterai che ci sono alcuni campi che sono stati definiti nel codice della classe Wombat (come leavesEaten()) e alcuni che invece non sono definiti nella classe Wombat. I campi aggiuntivi (come x, y e rotation) sono ereditati da 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 e cliccando Ispeziona).

21 - Crea una nuova classe

È giunto il momento di rendere la vita dei nostri vombati un po' più interessante aggiugendo degli ostacoli: i massi. (Creeremo dei massi così grandi che i vombati non potranno superarli.)

Per fare questo, creiamo una nuova classe Actor. Seleziona Nuova sottoclasse dal menu contestuale di Actor. Questo creerà una nuova classe come sottoclasse di Actor. Quando ti viene richiesto il nome della classe, digita Rock. Ti viene anche chiesto di selezionare un'immagine per la classe.

Puoi cercare (con Google...) o creare (con un programma di grafica) un'immagine e salvarla nella cartella images del progetto prima di creare la classe. L'immagine verrà quindi mostrata nella finestra di dialogo per la creazione della nuova classe. Noi abbiamo reso le cose più veloci inserendo già nel progetto un file immagine rock.gif.

Seleziona l'immagine, clicca su Ok, ed ecco che è stata creata una nuova classe Rock.

Apri ora l'editor della classe. Noterai che è stato generato automaticamente uno scheletro per il codice sorgente. In questo momento non abbiamo niente da scrivere. (Le rocce non hanno nessun comportamento particolare.)

Chiudi l'editor, compila e prova (crea un oggetto..). Ecco, adesso ci sono i massi!

Ora popola un po' lo scenario e metti alla prova i vombati. (Potresti usare i metodi del mondo populate() e randomLeaves, e poi aggiungere manualmente dei massi.) Noterai che adesso ci sono i massi ma i vombati ci passano sopra. Bene, c'è ancora del lavoro da fare.

22 - Crea i tuoi scenari

In questo tutorial non viene affrontato il problema di come apportare modifiche rilevanti agli scenari o come creare scenari completamente nuovi.
Se vuoi fare questo, hai due possibilità:

1. studiare scenari già esistenti
2. leggere il Manuale del Programmatore.

Naturalmente devi avere disponibile la documentazione delle classi di Greenfoot (le API), come abbiamo visto.

L'ultima cosa che faremo, in questa veloce introduzione, è apportare un'ulteriore modifica perché i vombati non passino attraverso i massi.

Apri l'editor con la classe Wombat e cerca il metodo canMove().
Attualmente questo metodo controlla se siamo sul bordo del mondo.
Dobbiamo modificarlo in modo che restituisca false anche quando abbiamo un masso davanti.

Sostituisci l'ultima istruzione return

return true;

con il seguente codice:

List rocks=myWorld.getObjectsAt(x, y, Rock.class);

if(rocks.isEmpty())
{
   return true;
}
else
{
   return false;
}

Questa porzione di codice ottiene una lista di tutti i massi nella cella di fronte. Se questa lista è vuota, possiamo spostarci in avanti, altrimenti non possiamo.

Il progetto wombats2, compreso nell'installazione, comprende tutte le modifiche discusse finora.

23 - E adesso?

1. Apri qualcuno degli scenari inclusi nell'installazione di Greenfoot.
   Quale ti incuriosisce di più?

1. Vai sul sito di Greenfoot e cerca altri scenari.
2. La cosa migliore che puoi fare? Discutine con altri utenti di Greenfoot!
3. Per saperne di più su Greenfoot ed entrare in contatto con la comunità di Greenfoot:
   1. Iscriviti alla mailing list.
   2. Leggi e scrivi sul blog: On Walkabout with Greenfoot
   3. Cerca altri scenari nella Greenfoot Gallery
   4. Cerca materiali didattici sul wiki: GreenRoom.

Buon divertimento!