Ciao a tutti devo realizzare un programmino che realizzi un gioco composto da una serie di blocchi a due
dimensioni e di una lavagna su cui posizionarli. Oltre alla collocazione iniziale dei blocchi, sono
previste alcune traformazioni che ne cambiano l’aspetto e la posizione; azioni quest’ultime che
derivano dell’esecuzione di comandi corrispondenti.
1.1 La classe astratta Blocco
Un generico blocco o pezzo del gioco `e una figura geometrica rappresentata da una serie di caratteri
in una matrice di dimensione opportuna ed `e rappresentato dalla classe astratta Blocco.java
I metodi astratti della classe Blocco modellano i seguenti comportamenti:
• abstract int numeroPezziBase()
Restituisce il numero dei pezzi base che costituiscono l’istanza corrente del pezzo.
• abstract void capovolgi()
Capovolge il pezzo corrente, la semantica dipende dall’istanza del pezzo.
• abstract void vuoto()
Modifica il pezzo corrente in modo che ne sia rappresentato solo il contorno.
• abstract void pieno()
Modifica il pezzo corrente in modo che sia rappresentato come pieno, ovvero tutti i punti che
compaiono all’interno del suo perimetro siano rappresentati.
• abstract char[][] maschera()
Restituisce una matrice di caratteri che rappresenta l’istanza corrente del pezzo.
1.2 I pezzi da implementare
1.2.1 Rettangolo
La classe Rettangolo modella un pezzo rettangolare. La classe dovr`a fornire i seguenti costrut-
tori:
• public Rettangolo(int altezza, int base)
Costruisce un Rettangolo con altezza e base specificati.
• public Rettangolo(char pezzo, int altezza, int base)
Costruisce un Rettangolo con altezza e base specificati in cui il pezzo base `e pezzo.
La semantica dei metodi astratti specificati dalla classe Blocco `e la seguente:
• capovolgi()
Ruota il rettangolo di 90 gradi.
un ulteriore applicazione del metodo trasforma il rettangolo in
• pieno()
Rende il rettangolo pieno.
• vuoto()
Rende il rettangolo vuoto, mantenendone visibile solo il contorno.
• numeroPezziBase()
Restituisce il numero dei pezzi base che costituiscono l’istanza corrente del pezzo.
• maschera()
Restituisce una matrice di caratteri che rappresenta il Rettangolo corrente. Si assume che
la matrice sia la pi`u piccola necessaria per rappresentare il rettangolo. E che il rettangolo
sia rappresentato tramite il pezzoBase, mentre le caselle libere contengano uno spazio. Ad
esempio, nel caso di
Rettangolo r1 = new Rettangolo(3,6);
l’invocazione del metodo
r1.maschera();
deve restituire una matrice con 3 righe e 6 colonne. Il rettangolo `e rappresentato dalla
presenza del carattere * nelle caselle che costituiscono il bordo del rettangolo.
• public String toString()
Restituisce una stringa che rappresenti il Rettangolo corrente. Ad esempio, con le istruzioni:
Rettangolo r1=new Rettangolo(3,6);
r1.toString();
si potrebbe ottenere la stringa:
"Rettangolo: base=3, altezza=6, carattere base=*"
1.2.2 Quadrato
La classe Quadrato modella un pezzo quadrato. La classe dovr`a fornire i seguenti costruttori:
• public Quadrato(int lato)
Costruisce un Quadrato con il lato specificato.
• public Quadrato(char pezzo, int lato)
La semantica dei metodi astratti specificati dalla classe Blocco nel caso di Quadrato pu`o essere
facilmente desunta da quella dei metodi di Rettangolo dove si assuma base=altezza.
Inoltre deve essere implementato il metodo
• public String toString()
che restituisce una stringa che rappresenti il Quadrato corrente. Ad esempio, le seguenti
istruzioni:
Quadrato q1=new Quadrato(’Q’,10);
q1.toString();
potrebbero restituire la stringa:
"Quadrato: lato=10, carattere base=Q"
1.2.3 Triangolo
La classe Triangolo modella un pezzo triangolo isoscele. La classe dovr`a fornire i seguenti
costruttori:
• public Triangolo(int altezza)
Costruisce un Triangolo isoscele con l’altezza specificata. Ad esempio
Triangolo t1 = new Triangolo(6);
costruisce il triangolo isoscele
• public Triangolo(char pezzo, int altezza)
Costruisce un Triangolo isoscele con l’altezza specificata in cui il pezzo base `e pezzo.
La semantica dei metodi astratti specificati dalla classe Blocco `e la seguente:
• capovolgi()
capovolge il triangolo.
• pieno()
Rende il triangolo pieno.
• vuoto()
Rende il triangolo vuoto, mantenendone visibile solo il contorno.
• numeroPezziBase()
Restituisce il numero dei pezzi base che costituiscono l’istanza corrente del pezzo.
• maschera()
Restituisce una matrice di caratteri che rappresenta il Triangolo corrente. Si assume che
la matrice sia la pi`u piccola necessaria per rappresentare il triangolo e che il triangolo sia
rappresentato tramite il pezzoBase, mentre le caselle libere contengano uno spazio. Ad
esempio, nel caso di
Triangolo t1 = new Triangolo(6);
l’invocazione del metodo
r1.maschera();
deve restituire una matrice con 6 righe e 11 colonne. Il triangolo `e rappresentato dal carattere
* nelle caselle che costituiscono il bordo del rettangolo.
Dopo l’esecuzione dei metodi
t1.capovolgi();
t1.pieno();
t1.maschera();
deve restiuire invece la matrice di 6 righe e 11 colonne
1.3 La classe Lavagna
La classe Lavagna implementa una lavagna quadrettata su cui `e possibile disporre delle istanze
delle classi precedenti delle quali la classe Blocco `e superclasse. La si pu`o immaginare come una
matrice quadrata di caratteri. Per semplicit`a assumiamo che una Lavagna possa contenere al pi`u
100 oggetti di tipo Blocco.
La classe Lavagna dovr`a mettere a disposizione il seguente costruttore:
• public Lavagna(int lato)
Costruisce una Lavagna con il lato specificato.
Inoltre dovr`a mettere a disposizione i seguenti metodi:
• public void aggiungi(Blocco l, int x, int y)
Aggiunge alla lavagna l’istanza di Blocco specificata, posizionandola alle coordinate (x,y).
Si assuma che la coordinata (0,0) rappresenti l’angolo in alto a sinistra della lavagna, men-
tre la coordinata (lato-1,lato-1) (dove lato `e la dimensione della lavagna) rappresenti
l’angolo in basso a destra della lavagna.
Si assuma inoltre che la x vari sulle colonne della lavagna e la y sulle righe.
Posizionare un pezzo sulla lavagna significa ricopiare su di essa i caratteri (diversi dal carattere
spazio) della matrice che rappresenta tale pezzo, a partire dalle coordinate specificate. Pi`u
specificamente, se la coordinata `e (x,y), il primo carattere in alto a sinistra del pezzo deve
essere ricopiato in quel punto della lavagna ed i successivi nelle corrispondenti posizioni,
muovendosi a destra e verso il basso.
La coordinata di riferimento per il pezzo `e quella dell’angolo in alto a sinistra della matrice
che lo contiene.
Ad esempio se:
Lavagna l=new Lavagna(18);
Blocco r=new Rettangolo(’R’,6,3);
l.aggiungi(r,1,2);
Blocco q=new Quadrato(’Q’,6);
l.aggiungi(q,5,7);
Blocco t=new Triangolo(’T’,8);
l.aggiungi(t,2,9);
si ottiene la lavagna di Fig.1 (dove agli spazi `e stato sostiutito il carattere ’-’, per facilitarne
la visione complessiva della lavagna).
Si assuma inoltre che il metodo venga sempre invocato in modo corretto, cio`e con x e y interi
positivi minori di lato.
I pezzi possono essere sovrapposti.
I pezzi possono debordare dalla lavagna. Ad esempio, l’aggiunta di
Blocco t2=new Triangolo(10);
l.aggiungi(t2,10,0);
fornisce la situazione di Fig. 2.
------------------
------------------
-RRR--------------
-R-R--------------
-R-R--------------
-R-R--------------
-R-R--------------
-RRR-QQQQQQ-------
-----Q----Q-------
-----Q---TQ-------
-----Q--T-T-------
-----Q-T--QT------
-----QTQQQQ-T-----
-----T-------T----
----T---------T---
---T-----------T--
--TTTTTTTTTTTTTTT-
------------------
Fig. 1
------------------
------------------
-RRR-------------*
-R-R------------*-
-R-R-----------*--
-R-R----------*---
-R-R---------*----
-RRR-QQQQQQ-*-----
-----Q----Q*------
-----Q---T********
-----Q--T-T-------
-----Q-T--QT------
-----QTQQQQ-T-----
-----T-------T----
----T---------T---
---T-----------T--
--TTTTTTTTTTTTTTT-
------------------
Fig. 2
------------------
------------------
-RRR-------------*
-RRR------------*-
-RRR-----------*--
-RRR----------*---
-RRR---------*----
-RRR-QQQQQQ-*-----
-----Q----Q*------
-----Q---T********
-----Q--T-T-------
-----Q-T--QT------
-----QTQQQQ-T-----
-----T-------T----
----T---------T---
---T-----------T--
--TTTTTTTTTTTTTTT-
------------------
Fig. 3
• public void pieno(int x, int y)
Trasforma tutti i pezzi posizionati nelle coordinate (x,y) in pezzi pieni. Ad esempio
l.pieno(1,2);
fornisce la situazione di Fig. 3
• public void pieno()
Trasforma tutti i pezzi che compaiono sulla lavagna in pezzi pieni. Ad esempio:
l.pieno();
fornisce la situazione di Fig.4.
• public void vuoto(int x, int y)
Trasforma tutti i pezzi posizionati nelle coordinate (x,y) in pezzi vuoti. Ad esempio:
l.vuoto(1,2);
------------------
------------------
-RRR-------------*
-RRR------------**
-RRR-----------***
-RRR----------****
-RRR---------*****
-RRR-QQQQQQ-******
-----QQQQQQ*******
-----QQQQT********
-----QQQTTT-------
-----QQTTTTT------
-----QTTTTTTT-----
-----TTTTTTTTT----
----TTTTTTTTTTT---
---TTTTTTTTTTTTT--
--TTTTTTTTTTTTTTT-
------------------
Fig. 4
------------------
------------------
-RRR-------------*
-R-R------------**
-R-R-----------***
-R-R----------****
-R-R---------*****
-RRR-QQQQQQ-******
-----QQQQQQ*******
-----QQQQT********
-----QQQTTT-------
-----QQTTTTT------
-----QTTTTTTT-----
-----TTTTTTTTT----
----TTTTTTTTTTT---
---TTTTTTTTTTTTT--
--TTTTTTTTTTTTTTT-
------------------
Fig. 5
------------------
------------------
-RRR-------------*
-R-R------------*-
-R-R-----------*--
-R-R----------*---
-R-R---------*----
-RRR-QQQQQQ-*-----
-----Q----Q*------
-----Q---T********
-----Q--T-T-------
-----Q-T--QT------
-----QTQQQQ-T-----
-----T-------T----
----T---------T---
---T-----------T--
--TTTTTTTTTTTTTTT-
------------------
Fig. 6
fornisce la situazione di Fig. 5.
• public void vuoto()
Trasforma tutti i pezzi che compaiono sulla lavagna in pezzi vuoti. Ad esempio:
l.vuoto();
fornisce la situazione di Fig. 6
------------------
------------------
-RRRRRR----------*
-R----R---------*-
-RRRRRR--------*--
--------------*---
-------------*----
-----QQQQQQ-*-----
-----Q----Q*------
-----Q---T********
-----Q--T-T-------
-----Q-T--QT------
-----QTQQQQ-T-----
-----T-------T----
----T---------T---
---T-----------T--
--TTTTTTTTTTTTTTT-
------------------
Fig. 7
----------********
-----------*------
-RRRRRR-----*-----
-R----R------*----
-RRRRRR-------*---
---------------*--
----------------*-
-----QQQQQQ------*
-----Q----Q-------
--TTTTTTTTTTTTTTT-
---T-Q----Q----T--
----TQ----Q---T---
-----TQQQQQ--T----
------T-----T-----
-------T---T------
--------T-T-------
---------T--------
------------------
Fig. 8
• public void capovolgi(int x, int y)
Capovolge tutti i pezzi posizionati nelle coordinate (x,y). Ad esempio:
l.capovolgi(1,2);
fornisce la situazione di Fig. 7.
• public void capovolgi()
Capovolge tutti i pezzi che compaiono sulla lavagna. Ad esempio:
l.capovolgi();
fornisce la situazione di Fig. 8.
• public char[][] maschera()
Restituisce la matrice di caratteri che rappresenta la lavagna corrente. Le matrici sono
esattamente quelle mostrate negli esempi precedenti dove al posto del carattere ’-’ vi sia
uno spazio.
• int numeroPezziBase()
Restituisce il numero dei pezzi base che compaiono nella lavagna corrente. Ad esempio la
lavagna nell’ultimo esempio contiene 74 pezzi.
Osservazioni
• Non importa se un pezzo posizionato sulla lavagna fuoriesce dai bordi della stessa. Il meto-
do maschera() nella costruzione della matrice che rappresenta la lavagna deve prendere in
considerazione solo la parte del pezzo che cade all’interno della lavagna.
• Analogamente il metodo numeroPezziBase() dovr`a contare solo i pezzi che e ettivamente
cadono all’interno della lavagna.
• Non `e importante l’ordine con cui visualizzare i pezzi sulla lavagna. Se due pezzi si so-
vrappongono e hanno come pezzoBase caratteri diversi `e irrilevante il carattere che viene
visualizzato nella parte della lavagna in cui i pezzi si sovrappongono.
• Per quel che riguarda i metodi che utilizzano le coordinate, si assuma che verranno sempre
utilizzati in modo corretto, cio`e che non verranno utilizzati con valori di x e y non leciti per
la Lavagna utilizzata.
Quindi dovrei implementare i metodi della classe astratta,poi farli funzionare su rettangolo,quadrato,triangolo e lavagna,
implementre i metodi specifici delle classi e provare a realizzare le figure ho capito bene?? datemi i vostri consigli.
Rispondi quotando
VVoVe: 
