incrocio

/*
 * Ci sono N_AUTO automobili che si approcciano a un incrocio regolato da semaforo, da 4 direzioni.
 * Le auto si comportano secondo il seguente schema:
 *
 ********
 *  finche' sulla strada:
 *
 *      Se all'incrocio:
 *          incr.semaforo(direzione); // direzione=true o false a seconda se orizzontale o verticale
 *
 *      incr.muovi(c,x,y,dx,dy); // la macchina si muove se la strada e' libera
 *      x+=dx; y+=dy;
 *
 *      incr.libera(x,y); // esce dall'incrocio
 *********
 *
 * Progettare un monitor Incrocio che implementi i seguenti metodi:
 *
 * void muovi(char c, int x, int y, int dx, int dy)
 *   se la posizione x+dx,y+dy e' occupata attende. Altrimenti scrive c in tale posizione e libera
 *   la posizione attuale x,y invocando libera(x,y) (vedere sotto)
 *
 * void libera(int x, int y)
 *   libera la posizione x,y scrivendo uno spazio (viene invocata quando le auto escono dall'incrocio)
 *
 * void semaforo(Boolean d)
 *   e' il semaforo nell'incrocio. viene invocato con un booleano che indica la direzione
 *   (orizzontale o verticale). Il semaforo puo' essere verde in una direzione o rosso per entrambe
 *   se il semaforo e' rosso per la direzione d la macchina attende
 *
 * void cambiaSemaforo()
 *   viene invocata periodicamente e cambia lo stato del semaforo. Il semaforo deve 'ciclare' tra
 *   quattro stati: rosso per tutti, verde in una direzione, rosso per tutti, verde nell'altra direzione
 */
public class Incrocio {
    int DIM;
    char[][] strada;
    int stato=3;

    /*
     * Costruttore: genera la strada e la inizializza con spazi
     * *** Non modificare ***
     */
    public Incrocio(int DIM) {
        int i,j;
        this.DIM = DIM;
        this.strada = new char[DIM][DIM];
        for (i=0;i<DIM;i++)
            for (j=0;j<DIM;j++)
                strada[i][j] = ' ';
    }

    /*
     * Restituisce il carattere alle coordinate x,y
     * *** Non modificare ***
     */
    public char strada(int x, int y) {
        return strada[x][y];
    }

    /*
     * Aggingere codice per gestire la sincronizzazione
     */
    public synchronized void muovi(char c, int x, int y, int dx, int dy) {


         while(strada[x+dx][y+dy] != ' ')
            try{ this.wait(); }catch(InterruptedException e) {
                    System.out.println(" Ah mi hanno interrotto!!");
                }//catch end


      /*
         * Controlla che non ci sia un incidente, scrive c sulla strada e libera la
         * posizione attuale. Non modificare
         */
        if (strada[x+dx][y+dy] != ' ')
            strada[x+dx][y+dy] = '*'; // questo non dovrebbe accadere quando si sinconizzano!
        else
            strada[x+dx][y+dy] = c;
        libera(x,y);
        /****************************************************************************/
    }

    /*
     * Aggiungere codice per gestire la sincronizzazione
     */
    public synchronized void libera(int x, int y) {
        strada[x][y] = ' ';
        notifyAll();
    }

    public synchronized void semaforo(Boolean d) {

        boolean possopassare=false;

        while(!possopassare){
            try{ this.wait(); }catch(InterruptedException e) {
                        System.out.println(" Ah mi hanno interrotto!!");
                    }//catch end
           //possopassare=false;
            if((stato==0)&&d)possopassare=true;
            else if((stato==2)&&!d)possopassare=true;
            notifyAll();
        }

    }

    public synchronized void cambiaSemaforo() {

        stato=(stato+1)%4;
        notifyAll();
    }
}