Il programma proposto non è pienamente funzionante. Si propone un procedimento di progettazione di un programma per collaudi successivi. Cioè si realizzano piccole parti funzionanti e si aggiungono nuove funzionalità che si integrano per formare una soluzione completa.

Il gioco viene proposto nella modalità per due giocatori.

Nella parte iniziale ci sono le solite direttive al compilatore e la classe che ridefinisce i Gestori degli eventi sulla finestra.

La classe Griglia fornisce un’area per disegnare nella finestra, detta Canvas.

Ridefinisce i gestori degli eventi generati dai tasti del mouse.

Il gestore di evento MouseClicked riceve il messaggio e di tipo MouseEvent dal quale preleva, per memorizzare in campi della classe, le coordinate in cui si è fatto clic e poi genera un messaggio (repaint) per ridisegnare l’area di disegno.

Il metodo paint viene richiamato dal costruttore.

Quando viene richiamato, associa il gestore degli eventi del mouse all’area di disegno.

Disegna una griglia.

Il metodo update viene invocato dal metodo repaint. Questo affida alla funzione Pedina il compito di disegnare la pedina del giocatore di turno all'interno della griglia.

In un primo momento ci si limita a disegnare la pedina nella casella della griglia più vicina alla posizone del mouse, successivamente si calcolerà la casella esatta in cui questa deve essere disegnata (metodo di collaudo per passi successivi).

Prima di proseguire ci si assicura che sia stato fatto clic all'interno dell'area della griglia.

La funzione Pedinacalcola il numero di colonna e il numero di riga in cui si è fatto clic, ovvero trasforma le coordinate del pixel in una coppia di numeri di riga e di colonna, avendo scelto 20 pixel la larghezza di una colonna.

L’oggetto g ricevuto come parametro viene usato per disegnare la pedina. a seconda del turno sceglie il colore per disegnare la pedina

prima di terminare si cambia il turno del giocatore.

Termina la dichiarazione della classe Griglia

Il programma proposto svolge solo alcune operazioni di base:
disegna la griglia di gioco e disegna una pedina all’interno di una casella.
Si vuole introdurre la funzione che, a partire dal basso, colloca le pedine una sopra l’altra, non nel punto in cui si fa clic.

Di seguito verranno fornite le indicazioni per ottenere l'effetto desiderato:

Dopo aver calcolato le coordinate di riga e di colonna (x=xPos/20, y=yPos/20), all’interno della funzione Pedina, e prima di decidere il colore della pedina da disegnare, si deve individuare all’interno della colonna la prima casella vuota, a partire dal basso.

Per fare questa operazione, quindi, occorre gestire una matrice in memoria che riproduce lo stato del gioco.
ad esempio una cella contenente 0 indica che la casella corrispondente è vuota, mentre una cella contenente 1 indica che la cella corrispondente è occupata dalla pedina rossa e una cella contenente 2 indica che la cella è occupata dalla pedina verde.

• Tra le proprietà della classe Griglia bisogna includere la dichiarazione di una matrice delle stesse dimensioni della griglia disegnata sull’area canvas;
• La classe non possiede il costruttore, ma per assegnare il valore 0 a tutte le celle della matrice è necessario dichiarare un costruttore che svolga questa operazione;
• Per scandire le celle di una colonna occorre dichiarare una variabile intera locale alla funzione Pedina;
• Nel punto indicato (dopo il calcolo di y=yPos/20) bisogna inserire le seguenti operazioni:
• Se la colonna è piena si esce dalla funzione,
• a iniziare dalla cella più in basso nella colonna cercare, verso l’alto, una cella contenente un valore≠0,
• La coordinata così trovata deve essere usata per disegnare la pedina,
• Nella corrispondente cella della matrice inserire il valore 1 o il valore 2 a seconda del turno di gioco.
• a questo punto, dopo aver cambiato il turno del giocatore, si può usare una zona laterale alla griglia per indicare il turno del giocatore con pedina rossa o il giocatore con pedina nera.

Dopo aver disegnato la pedina del giocatore (quindi prima dell’istruzione Turno = !Turno all’interno della funzione Pedina, si deve riconoscere se il giocatore ha collocato 4 pedine su una linea.

• Si creano due cicli nidificati per far variare gli indici di riga e di colonna dalla prima all’ultima cella della matrice, Nel ciclo più interno:
• Si legge il valore contenuto nella cella corrente,
• Se è 0 (casella vuota) si avanza alla cella successiva,
(si supponga di scandire la matrice da sinistra a destra, dall’alto in basso) Un giocatore vince in uno dei seguenti casi:
• Si ha un allineamento orizzontale se l’indice di colonna dista almeno 4 caselle dall’ultima colonna di destra e se nelle tre caselle adiacenti c’è lo stesso valore letto nella cella corrente, (le caselle adiacenti hanno l’indice di colonna uguale a quello corrente +1, +2 e +3)
• Si ha un allineamento verticale se l’indice di riga dista almeno quattro celle da quella inferiore e se nelle tre celle sottostanti (quelle con indice di riga uguale all’indice della cella corrente +1, +2 e +3) c’è lo stesso valore letto nella cella corrente,
• Si ha un allineamento diagonale verso destra se entrambi gli indici distano almeno quattro celle dai margini della matrice e se nelle tre celle poste sulla riga+1 e colonna+1, riga+2 e colonna+2 e riga+3 e colonna+3 contengono lo stesso valore letto nella cella corrente,
• Si ha un allineamento in diagonale verso sinistra se entrambi gli indici distano almeno quattro celle dai margini della matrice e se nelle tre celle poste sulla riga+1 e colonna-1, riga+2 e colonna-2 e riga+3 e colonna-3 contengono lo stesso valore letto nella cella corrente,

Gestire l’evento mouse Move per disegnare la pedina al di sopra delle colonne della griglia, in modo da indicare al giocatore dove cadrà la pedina.

Infine si richiede di gestire la fine del gioco e l’inizio di una nuova partita.

Si deve gestire una variabile booleana per riconoscere la fine del gioco (un giocatore vince oppure lo schema è pieno) e cancellare tutte le pedine.

Può essere utile, al riguardo l’uso della funzione clearRect appartenente all’oggetto g di classe Graphics.

Il metodo clearRect richiede 4 parametri: la prima coppia riguarda le coordinate dello spigolo superiore sinistro del rettangolo e la seconda coppia rappresenta le dimensioni dell’area rettangolare da cancellare. Per poter utilizzare il metodo occorre includere la libreria awt.Graphics.* nella compilazione.