Incrocio

public class Incrocio {

    /*
        L'idea è quella di avere un semaforo con quattro stati, descritto di seguito.
        ogni volta che una macchina vuole attraversare l'incrocio verifica il semaforo,
        se ha il semaforo rosso deve aspettare, altrimenti può proseguire.

        la seconda parte è sincronizzare le macchine in modo da non farli scontrare,
        quindi devo aspettare che si liberi la posizione in cui voglio muovermi se è occupata.

        i metodi synchronized mi fanno eseguirli in mutuaesclusione
        la wait puoi generare l'eccezione InterruptedException
    */

    int DIM;
    char[][] strada;

    int semaforo = 0; //ha quatro stati:
    /*
        formato: (orizzontale verticale)
        0 - rosso rosso
        1 - rosso verde
        2 - rosso rosso
        3 - verde rosso
    */
        //inizialmente il semaforo è rosso per tutti quindi stato 0

    /*
     * 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];
    }

    /*
     * Aggiungere codice per gestire la sincronizzazione
     */
    public synchronized void muovi(char c, int x, int y, int dx, int dy) throws InterruptedException {
        while(strada[x+dx][y+dy] != ' ') //aspetto affinche' non ho lo spazio per muovermi
            wait(); //una volta che ce l'ho mi muovo e libero la posizione occupata in precedente

        if (strada[x+dx][y+dy] != ' ')
            strada[x+dx][y+dy] = '*'; // questo non dovrebbe accadere quando si sincronizzano!
        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(); //una volta che ho liberato lo spazio notifico a tutti che l'ho liberato
        //in modo che se qualcuno mi stava aspettando si possa muovere
    }

    public synchronized void semaforo(Boolean d) throws InterruptedException {
        //assumo che quando d è true la macchina si muove in orizzontale
        while((d && semaforo != 3) || (!d && semaforo != 1)) //se il mio semaforo è rosso aspetto
            wait();

        //quando d è true significa che voglio spostami orizzontalmente quindi posso farlo solo
        //quando il semaforo è 3: (verde rosso), formato (orizzontale verticale)

        //simetricamente per il caso quando voglio spostarmi verticalmente:
        //aspetto fino a quando il semaforo diventi 1 (rosso verde), formato (orizzontale verticale)
    }

    public synchronized void cambiaSemaforo() {
        semaforo = (semaforo+1)%4;
        //il semaforo a 4 stati: da 0 a 3 quindi il modulo mi garantisce di ciclare tra i stati disponibili
        // Notifico tutti che ho cambiato il semaforo, quindi sblocco quelli che aspettavano per il caso semaforo
        notifyAll();
    }
}