Vombati

Lo scenario vombati1 (vombati1)

  1. Scarica vombati1.zip e salva la cartella vombati1 dove preferisci.
  2. Lancia l’applicazione Greenfoot.
  3. Una volta avviato Greenfoot seleziona Scenario>Apri... e seleziona lo scenario vombati1
    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 sono sempre perché fanno parte di Greenfoot.
    Le altre classi appartengono allo scenario vombati, e saranno diverse in scenari diversi.
    Al di sotto del mondo ci sono i controlli di esecuzione (i pulsanti Azione e Esegui e il cursore).
    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.
  4. Posizioneremo adesso degli oggetti nel mondo.
    Clicca con il pulsante destro del mouse sulla classe Vombato presente nel pannello delle classi.
    Appare un menu contestuale, seleziona new Vombato().
    Dopo clicca in un punto qualsiasi del mondo.
    Hai appena creato un vombato e lo hai posizionato nel mondo.
  5. I vombati mangiano foglie, quindi è giusto posizionare alcune foglie nel mondo.
    Agisci sulla classe Foglia e posiziona una foglia.
    C’è un metodo più veloce per sistemare diversi oggetti: seleziona la classe Foglia e clicca diverse volte sul mondo mantenendo abbassato il tasto Shift.
    Ogni clic posizionerà un oggetto della classe selezionata,
  6. Clicca sul pulsante Azione del pannello di esecuzione.
    Ogni oggetto compierà un’azione cioè ogni oggetto farà qualcosa che sa fare.
    Nel nostro esempio le foglie sono programmate per non fare nulla, mentre i vombati sono programmati 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 incrociano una foglia, la mangiano.
  7. 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 lo clicchi, si ferma tutto.
    Il cursore a fianco dai pulsanti Azione e Esegui imposta la velocità di esecuzione.
    Per capire cosa significa, clicca sul pulsante Esegui e poi muovi il cursore.ù
  8. Piuttosto che eseguire l’intero scenario puoi anche chiamare i singoli metodi.
    Un metodo è una singola azione che un oggetto può fare.
    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 vedrai 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, void giraSinistra(). Selezionando questo metodo dici al vombato di girare alla sua sinistra.
    Prova void passo().

  9. Alcuni metodi ti danno una rispostaint quanteFoglieMangiate(), ad esempio, ti dirà quante foglie ha mangiato finora il vombato.
    Prova.
    Noterai anche un metodo void 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 metodoact() dell’oggetto.
  10. 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.
  11. 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 mondoVombati.
    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 è void popola().
    Provalo.
    Questo metodo crea delle foglie e dei vombati e li posiziona nel mondo.
    Dopo lancia lo scenario.
    Un altro metodo del mondo è void foglieCasuali(int quante).
    Questo metodo posiziona a caso delle foglie nel mondo.
    Nota che questo metodo ha, dopo il proprio nome, alcune parole tra parentesi: int quante.
    Questo è il parametro.
    Significa che devi specificare alcune informazioni aggiuntive quando chiami questo metodo.
    Il termine int ti dice che si aspetta un numero intero, e quante 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 sono quindi una sull’altra.

Lo scenario vombati2 (vombati2)

  1. 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!
    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 Vombato nel pannello delle classi.
    Si apre un editor e vedrai il codice sorgente Java della classe Vombato.
    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 metodo direzioneCasuale().
    Aggiungi alla classe Vombato il metodo seguente:

    public void direzioneCasuale()
    {
        int giri=Greenfoot.getRandomNumber(4);
        for(int i=0; i < giri; i++)
        {
            giraSinistra();
        }
    }
  2. Ora modifichiamo act() in modo che utilizzi direzioneCasuale().
    Il metodo act() è attualmente:

    public void act()
    {
        if(trovataFoglia()) mangiaFoglia();
        else if(haStrada()) nuovaPosizione();
        else                giraSinistra();
    }

    Sostituisci la chiamata giraSinistra() in fondo con una chiamata di direzioneCasuale().
    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.

  3. Per impostare l'immagine di una classe, seleziona Definisci Immagine... dal menu contestuale della classe.
    Prova con la classe Foglia: cambia l'immagine, ad esempio, con quella di una banana, il vombato raccoglierà banane.
    Greenfoot include una libreria di immagini che puoi usare a questo scopo, oppure puoi spostare le tue immagini nella cartella images all'interno della cartella dello scenario (vombati1 e vombati2) e poi utilizzarle.
    Un'altra 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():
    una prevede un parametro di tipo GreenfootImage,
    l'altra riceve il nome di un file (e poi legge l'immagine dal file e l'assegna a un oggetto GreenfootImage).
    L'obiettivo che vogliamo raggiungere è che i vombati non appaiano capovolti quando vanno a sinistra.
    Il progetto vombati2 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.
    Dobbiamo caricare da file gli oggetti di tipo immagine una sola volta (nel costruttore) e memorizzarli in campi di tipoGreenfootImage.
    E poi usare i due oggetti immagine per cambiare l'immagine ripetutamente.
    Aggiungi al Vombato le dichiarazioni per le immagini

    private GreenfootImage vombatoDestra;
    private GreenfootImage vombatoSinistra;

    Inserisci le due righe di codice seguenti come prime istruzioni del metodo costruttore Vombato():

    vombatoDestra  =getImage();
    vombatoSinistra=new GreenfootImage("wombat-left.gif");

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

    setImage(vombatoSinistra);

    Useremo questo metodo quando il vombato cambia direzione.
    Per questo dobbiamo modificare il metodo giraSinistra() 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 vombatoSinistra quando procediamo verso ovest o verso nord, e l'immagine originalevombatoDestra quando procediamo verso est o verso sud.
    Ecco qui la nuova versione di nuovaDirezione():

    public void nuovaDirezione(int direzione)
    {
       this.direzione=direzione;
       switch(direzione) 
       {
          case SUD   : setImage(vombatoDestra);   break;
          case EST   : setImage(vombatoDestra);   break;
          case NORD  : setImage(vombatoSinistra); break;
          case OVEST : setImage(vombatoSinistra); break;
       }
    }

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

  4. 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 Vombato (come quanteFoglie()) e alcuni che invece non sono definiti nella classe Vombato.
    I campi aggiuntivi (come xy 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 (selezionandolo e cliccando Ispeziona).
  5. È giunto il momento di rendere la vita dei nostri vombati un po' più interessante aggiugendo degli ostacoli: i massi.
    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 Masso.
    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 masso.gif.
    Seleziona l'immagine, clicca su Ok, ed ecco che è stata creata una nuova classe Masso.
    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.
    Ecco, adesso ci sono i massi!
    Ora popola un po' lo scenario e metti alla prova i vombati.
    Potresti usare i metodi del mondo popola() e foglieCasuali(), 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.
  6. L'ultima cosa che faremo è apportare un'ulteriore modifica perché i vombati non passino sopra i massi.
    Apri l'editor con la classe Vombato e cerca il metodo haStrada().
    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 massi=mioMondo.getObjectsAt(x, y, Masso.class);
    
    if(massi.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 vombati2 comprende tutte le modifiche discusse finora.