IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff.

Crosato/Bedani

Esercizi per la pausa natalizia 2021/2022

I progetti devono essere essere realizzati interamente ad oggetti, separando il più possibile la logica di
funzionamento dalla gestione dell’interfaccia con l’utente.

Per alcuni progetti sono presentate alcune linee guida/suggerimenti per la realizzazione; è possibile
implementare comunque ulteriori varianti. Documentarsi (usando la guida in linea di Visual Studio o sul sito
Microsoft MSDN) sui componenti visuali necessari per lo sviluppo dell’interfaccia grafica.
Altri siti che potrebbero eventualmente tornare utili per tips&tricks sono:

• https://www.codeproject.com/
• https://www.c-sharpcorner.com/
• https://stackoverflow.com/

I sorgenti devono essere intestati con i propri riferimenti e commentati. Consegnare uno zip (con nome
del tipo CognomeN.zip) contenente le cartelle di tutti i progetti completi.

1
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “Gestione rubrica”

Un’app per smartphone per la gestione (semplificata) di una rubrica di contatti utilizza le classi Contatto e
Rubrica che rappresenta un singolo contatto memorizzato in rubrica.
Ogni oggetto di classe Contatto rappresenta un singolo contatto, con le seguenti specifiche minime:
• campi stringa per memorizzare cognome; nome; numeri di telefono per cellulare, lavoro e casa;
email
• campo intero id che identifica univocamente il contatto: a questo campo viene assegnato il valore
di un contatore incrementato ad ogni creazione di contatto in modo da avere sempre un numero
diverso da assegnare al contatto creato
• costruttore che permetta di creare il contatto specificando tutti i valori per i campi (v. N.B.)
• costruttore che permetta di creare il contatto specificando solo cognome, nome e numero di
cellulare
• costruttore che riceve una stringa contenente tutti i dati in formato CSV (v. metodo ToString),
estrapola i valori e crea il contatto
• metodo ToString: restituisce tutti i dati del contatto in formato CSV (separati da punti e virgole
restituisce i valori dei campi cognome, nome, telefono cellulare, telefono lavoro, telefono casa,
email)
• proprietà in sola lettura per id, cognome, nome ed email
• indicizzatore che permetta di ottenere uno dei tre numeri di telefono passando come indice
rispettivamente le stringhe “cellulare”, “lavoro” e “casa”. Se un numero non è stato impostato
l’indicizzatore restituisce una stringa vuota e se l’indice non è valido solleva un’eccezione. I numeri
devono essere anche modificabili (v. N.B.).
• N.B.: l’impostazione dei numeri di telefono deve aggiungere, se non presente, il prefisso
internazionale sfruttando un metodo interno. Il prefisso internazionale viene memorizzato in una
costante inizializzata a “+39” (potrebbe avere un valore diverso).
Un oggetto di classe Rubrica rappresenta la rubrica, come insieme di contatti, con le seguenti
caratteristiche:
• campi che identificano il proprietario della rubrica (cognome e nome)
• lista dei contatti inseriti in rubrica
• opportuno costruttore
• metodo per aggiungere un contatto: di questo metodo devono esistere due overload, per
aggiungere un contatto pre-esistente passato per riferimento e per aggiungere un contatto
passando tutti i dati necessari per crearlo
• metodo per salvare l’intera rubrica su file testo in formato CSV (si sfrutti il metodo ToString() di ogni
contatto)
• metodo per caricare l’intera rubrica da file testo in formato CSV (si sfrutti l’opportuno costruttore
del contatto)
Sviluppare un’interfaccia grafica coerente e completa per gestire una rubrica di contatti in modo
persistente (cioè mantenendo i dati archiviati tra successive esecuzioni).

Nota sull’uso dei file testo: per leggere da file testo si usa un oggetto di tipo StreamReader, per scrivere su
un file testo un oggetto di tipo StreamWriter (namespace System.IO).
StreamReader sr = new StreamReader(nomeFile); // nomeFile è una stringa con il nome del file
// legge fino alla fine del file riga per riga
while (!sr.EndOfStream)
string linea = sr.ReadLine(); // legge una riga che salva nella variabile linea
sr.Close();

StreamWriter sw = new StreamWriter(nomeFile, true); // il secondo parametro indica che si

deve aprire in append
sw.WriteLine(linea); // scrive una riga
sw.Close();

2
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “Simulazione gestione utenti Unix”

Nei sistemi operativi Unix/Linux, vengono definiti utenti del sistema con privilegi diversi. Ogni utente è
caratterizzato da diverse informazioni come il nome (username), che lo identifica nel sistema, la sua parola
d’ordine (password), un commento, la sua home directory e la shell di default.
Quando viene creato un nuovo utente, il sistema assegna un identificativo numerico user ID (un numero
intero) che lo individua univocamente nel sistema. Ogni utente appartiene ad uno o più gruppi di utenti:
ogni gruppo, in modo simile agli utenti, è caratterizzato da un nome, da una password (richiesta all’utente
quando cerca di cambiare gruppo) e da un identificativo numerico group ID. Quando viene creato un nuovo
utente, viene anche creato un nuovo gruppo con lo stesso nome dell’utente e questo diventa il gruppo
primario assegnato all’utente.
Il sistema mantiene un elenco degli utenti definiti (memorizzato nel file /etc/passwd) ed un elenco dei
gruppi (memorizzato nel file /etc/group):
• il file passwd contiene le informazioni sugli utenti, uno per riga, con questo formato:
username : password cifrata : user ID : group ID : commento : home directory : shell
• il file group contiene uno per riga, le informazioni sui gruppi e l’elenco degli utenti che
appartengono ai singoli gruppi, nel formato:
nome gruppo : password cifrata : group ID : lista di utenti (separati da virgola)

1. Rappresenta usando un diagramma UML la precedente situazione introducendo le classi User, Group,
UserList, GroupList.
2. Implementa una classe User con le seguenti caratteristiche (tralascia per il momento la presenza dei
gruppi di utenti):
• costruttori che permettano di definire le informazioni sull’utente in diversi modi: creazione
dell’utente solo impostando il nome (password vuota, identificativo progressivo a partire dal valore
1, commento vuoto, home directory impostata a /home/nome_utente, shell impostata a /bin/bash)
• metodo per modificare la password fornendo la vecchia password: se la vecchia password non è
esatta oppure se la nuova password non è lunga almeno 6 caratteri, il metodo non fa nulla è
restituisce false, altrimenti restituisce true
• osservatori (implementati con proprietà) per ricavare le informazioni dell’utente (tranne la
password)
3. Implementa una classe UserList per gestire la lista degli utenti definiti sul sistema, che utilizzi un
oggetto di tipo lista di User per mantenere l’elenco.
4. Sviluppa un’interfaccia grafica che verifichi il funzionamento di tutte le classi.

3
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “Fatture e ordini”

Sviluppare un’applicazione ad interfaccia grafica, orientata agli oggetti, per la gestione di fatture e ordini.
L’applicazione dovrà definire due classi che rappresentano la
fattura e l’ordine, nella seguente relazione tra di esse:
Le caratteristiche delle classi dovranno essere:
Classe Fattura:
• attributi:
- nomeCliente: string // cognome + nome
- partitaIva: string
- elencoOrdini: List<Ordine> // lista di oggetti di tipo ordine
• metodi:
+ Fattura() // costruttore che crea elencoOrdini
+ Fattura(cliente, piva) // costruttore che in più imposta il nome del cliente e la partita IVA
+ NomeCliente: string // proprietà che legge/imposta nomeCliente
+ PartitaIva: string // proprietà che legge/imposta partitaIva
+ double ImportoTotale // proprietà che restituisce il totale fattura
+ int NumOrdini // proprietà che restituisce il numero di ordini
+ void AggiungiOrdine(Ordine ord) // metodo che aggiunge un ordine alla lista
+ void RimuoviOrdine(int indOrdine) // rimuove l’ordine di posto indOrdine
+ void RimuoviOrdine(string codiceArt) // rimuove l’ordine conoscendo codiceArt
+ Ordine GetOrdine(int indOrdine) // restituisce l’ordine di posto indOrdine
+ Ordine GetOrdine(string codiceArt) // restituisce l’ordine conoscendo codiceArt
- int RicercaOrdine(string codiceArt) // ritorna la posizione dell’ordine con codiceArt e -1 se l’ordine
non esiste
Classe Ordine:
• attributi:
- codiceArt: string // codice articolo
- descArt: string // descrizione articolo
- quantita: double // quantità ordinata
- costoUnitario: double
• metodi:
+ Ordine() // costruttore di default; non svolge alcuna operazione
+ Ordine(codice, descr, qta, costo) // 2^ costruttore
+ Importo: double // proprietà che restituisce costoUnitario*quantita
+ CodiceArt: string // proprietà che legge/imposta codiceArt
+ DescArt: string // proprietà che legge/imposta descArt
+ Quantita: double // proprietà che legge/imposta quantita
+ CostoUnitario: double // proprietà che legge/imposta costoUnitario
+ ToString(): string // metodo che visualizza una stringa con i dati dell’ordine

L’applicazione è composta inoltre da una form che permette di testare le due classi cioè di creare una
fattura specificando nome cliente e partita iva mediante delle caselle di testo (se lasciate vuote, crea la
fattura usando il costruttore senza parametri). Gli ordini contenuti nella fattura vengono mostrati in un
controllo di tipo ListBox. L’applicazione consente l’aggiunta di ordini (verificando che non esistano già in
base al codice dell’articolo; n.b.: in una stessa fattura non ci sono più ordini dello stesso articolo), la
rimozione di un ordine specificato attraverso l’indice nell’elenco oppure attraverso il suo codice articolo.
L’applicazione mostra (ad esempio su una barra di stato) il numero di ordini presenti nella fattura, sempre
aggiornato.
4
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “Gioco della vita” (“Life”)

Il gioco della vita1 (Game of Life in inglese) è un automa cellulare sviluppato dal matematico inglese John
Conway sul finire degli anni ‘60. Il gioco della vita è l’esempio più famoso di automa cellulare: il suo scopo è
quello di mostrare come comportamenti simili alla vita possano emergere da regole semplici e interazioni a
molti corpi.
Si tratta di un gioco senza giocatori, intendendo che la sua evoluzione è determinata dal suo stato iniziale,
senza necessità di alcun input da parte di giocatori umani. Si svolge su una griglia di caselle quadrate (celle)
che si estende all'infinito in tutte le direzioni; questa griglia è detta mondo.
Ogni cella ha 8 vicini, che sono le celle ad essa adiacenti, includendo quelle in senso diagonale. Ogni cella
può trovarsi in due stati: viva o morta (o accesa e spenta, on e off). Lo stato della griglia evolve in intervalli
di tempo discreti. Gli stati di tutte le celle in un dato istante sono usati per calcolare lo stato delle celle
all'istante successivo. Tutte le celle del mondo vengono quindi aggiornate simultaneamente nel passaggio
da un istante a quello successivo: passa così una generazione.
Le transizioni di stato dipendono unicamente dal numero di vicini vivi, secondo le seguenti regole:
• una cella morta con esattamente 3 vicini vivi nasce, diventando viva
• una cella viva con 2 o 3 vicini vivi sopravvive; altrimenti muore (per isolamento o sovraffollamento)
Ad esempio, partendo dalla configurazione di sinistra, dopo una generazione, si arriva alla configurazione di
destra (le caselle scure sono celle vive):

0 1 2 3 4 5 6 0 1 2 3 4 5 6

0 0

1 1

2 2

3 3

4 4

5 5

6 6

La logica di gioco può essere realizzata implementando due classi:

Classe Cella che rappresenta una singola cella viva con le seguenti caratteristiche:
• due attributi riga e colonna che rappresentano numero di riga e colonna (riga >= 0 e colonna >= 0)
• due proprietà in sola lettura che restituiscono le coordinate della cella
• un costruttore che riceve le coordinate della cella e se queste non sono valide, solleva un’eccezione
“coordinate non valide”
• un metodo polimorfico ToString che restituisce una descrizione testuale della cella
Classe GiocoLife che rappresenta il mondo attraverso una matrice di booleani (true equivale ad una cella
viva, false ad una cella morta) e con le seguenti caratteristiche:
• metodo Azzera che imposta a false (morte) tutti gli elementi della matrice
• costruttore che riceve le dimensioni del mondo come valori interi (positivi), dimensiona la matrice e
l’azzera; se le dimensioni passate non sono valide solleva un’eccezione “dimensioni non valide”
• proprietà Vivi che restituisce il numero di celle vive
• indicizzatore che restituisce lo stato della cella (true o false) di cui sono passate le coordinate e se
queste non sono valide restituisce false
• osservatore Vicini che restituisce il numero di celle vive vicine alla cella di cui sono passate le
coordinate e se queste non sono valide restituisce zero
• metodo AggiungiCella che riceve due parametri interi che indicano le coordinate di una nuova cella
viva e, se è possibile, aggiorna la matrice
1
Tratto da https://it.wikipedia.org/wiki/Gioco_della_vita
5
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

• metodo AggiungiCella, come il precedente, ma che riceve un oggetto di tipo Cella utilizzato per
aggiornare la matrice
• metodo Imposta che riceve una lista di oggetti di tipo Cella: il metodo azzera la matrice, quindi
utilizza la lista per impostare le celle vive
• metodo Prossimo, senza parametri, che determina il prossimo stato del gioco, dopo una singola
generazione: questo metodo usa una lista generica di oggetti di tipo Cella dove memorizza le celle
vive in seguito alle applicazioni delle regole del gioco descritte all’inizio. Quindi il metodo richiama il
metodo Imposta per aggiornare la matrice al nuovo stato.

L’applicazione ad interfaccia grafica dovrà permettere la definizione di una griglia di determinate

dimensioni e le seguenti funzionalità:
• azzeramento della griglia
• cliccando sulla griglie permettere il cambio di stato della cella (viva/morta)
• visualizzazione del prossimo stato (generazione)
• visualizzazione in sequenza delle generazioni successive (con conteggio delle generazioni)
• scelta, attraverso un combo box, di schemi precostituiti (informarsi su Internet, es. Wikipedia)
• generazione di disposizioni per massimizzare le celle vive
• …

6
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “Memory”

Memory, noto anche come coppie, è un popolare gioco di carte che richiede concentrazione e memoria.
Nel gioco, le carte sono inizialmente mescolate e disposte coperte sul tavolo. I giocatori, a turno, scoprono
due carte; se queste formano una “coppia”, vengono incassate dal giocatore di turno, che può scoprirne
altre due; altrimenti, vengono nuovamente coperte e rimesse nella loro posizione originale sul tavolo, e il
turno passa al prossimo giocatore. Vince il giocatore che riesce a scoprire più coppie.
Se si gioca con un mazzo di carte tradizionale, per "coppia" si intendono di solito due carte dello stesso
valore e dello stesso seme; esistono tuttavia anche mazzi di carte dedicati, composti di un certo numero di
coppie identiche.
Il gioco può essere anche giocato come solitario, per esempio tenendo conto del numero di carte non
corrispondenti scoperte e cercando di incassare tutte le carte nel minor numero possibile di tentativi.
Per la realizzazione di questo progetto si richiede la realizzazione di quest’ultima versione con l’eventuale
possibilità di scegliere tra più mazzi di carte.

7
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “TuxMath”

TuxMath è un gioco educativo che permette di

esercitarsi su semplici operazioni aritmetiche, come
addizioni, sottrazioni, moltiplicazioni e divisioni.
Il gioco è una sorta di SpaceInvaders, nel quale gli
alieni sono stati sostituiti da meteoriti che
accompagnano un calcolo matematico che deve
essere risolto prima di poter colpire il suolo.
Tux, la mascotte del sistema operativo Linux, è il
personaggio principale e controlla un raggio laser
che è in grado di distruggere enormi palle di fuoco,
ma per farlo sarà necessario rispondere
correttamente l’operazione.

Progetto “Mastermind”
Mastermind2 è un gioco da tavolo astratto in cui un giocatore, il
“decodificatore” (utente), deve indovinare il codice segreto composto dal
“codificatore” (computer), il suo avversario. Nella versione originale di
mastermind, il codice segreto è di quattro cifre e il codificatore ha a
disposizione, per comporlo, le dieci cifre del sistema decimale standard
(0,1,2,3,4,5,6,7,8,9). Esistono numerose versioni successive, la più famosa
è quella in cui al posto dei numeri si usano dei piolini colorati.
Regolamento
Dopo che il codificatore ha composto il codice, il decodificatore fa il suo
primo tentativo, cercando di indovinare il codice. Il codificatore, appena il
suo avversario ha completato il tentativo fornisce degli aiuti
comunicando:
• Il numero di cifre giuste al posto giusto; cioè le cifre del tentativo
che sono effettivamente presenti nel codice al posto tentato; con
pioli neri
• Il numero di cifre giuste al posto sbagliato; cioè le cifre del
tentativo che sono effettivamente presenti nel codice, ma non al
posto tentato; con pioli bianchi.

2
Tratto da https://it.wikipedia.org/wiki/Mastermind
8
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Non bisogna comunicare quali cifre sono giuste o sbagliate, ma solo quante. Se il decodificatore riesce ad
indovinare il codice entro il numero di tentativi predeterminati (solitamente i tentativi sono 9) allora
quest'ultimo vince la partita, altrimenti vince il codificatore.
L’applicazione, ad interfaccia grafica, deve presentare per default il gioco nella forma base e permetterne la
modifica di alcuni parametri (ad esempio numero di colori e numero di tentativi).

Progetto “Tetris”

Tetris3 è un videogioco di logica e ragionamento inventato da

Aleksej Pažitnov il 6 giugno 1984, mentre lavorava per
l’Accademia Russa delle Scienze di Mosca, Russia. Non essendo
stato brevettato, il gioco è diventato disponibile praticamente
per qualunque dispositivo. Il gioco e molte sue varianti sono
disponibili per qualunque console e sistema operativo. Il gioco
ha iniziato ad avere popolarità alla fine degli anni ottanta.
Inoltre è stato dichiarato uno dei dieci videogiochi più
importanti di sempre da Henry Lowood della Stanford
University, nel marzo 2007.

Caratteristiche
I vari pezzi del gioco di Tetris si chiamano tetramini, ciascuno
composto da quattro blocchi, infatti il termine Tetris deriva da
“tetra” (τετρα) che significa “quattro”. I tetramini cadono giù uno alla volta e il compito del giocatore è
ruotarli e/o muoverli in modo che creino una riga orizzontale di blocchi senza interruzioni.

Quando la riga è stata creata, i mattoni spariscono e i pezzi sovrastanti (se ce ne sono) cadono a formare
nuove linee.

I pezzi di Tetris possibili sono raffigurati di seguito:

Le sette possibili combinazioni in Tetris sono chiamate come le corrispondenti lettere dell'alfabeto che più
si avvicinano alla forma del pezzo: I, T, O, L, J, S, e Z.
Le forme dei tetramini sono il risultato di tutte le possibili combinazioni che si possono ottenere
disponendo 4 quadrati, ciascuno dei quali ha almeno un lato in comune con almeno uno degli altri tre
quadrati.
Tutti i pezzi possono completare righe singole o doppie; I, L, e J possono completare anche righe triple e
solo la I può completare quattro righe simultaneamente. Quest'ultima situazione è chiamata un “tetris”.

3
Tratto da https://it.wikipedia.org/wiki/Tetris
9
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “Space Invaders”

Space Invaders4 è un videogioco arcade del 1978 sviluppato da

Toshihiro Nishikado. È stato prodotto in origine dalla Taito, e dato
in licenza per la produzione in USA alla divisione Midway Games
della Belly. Sebbene sia molto semplice per gli standard odierni, è
stato uno dei videogiochi più influenti della sua generazione: il
gioco generò in pochi anni un fatturato di 500 milioni di dollari.

Modalità di gioco
Il gioco si basa su una struttura piuttosto semplice. Il giocatore
controlla un cannone mobile che si muove orizzontalmente sul
fondo dello schermo, e deve abbattere uno ad uno gli alieni che
piano piano si avvicinano alla terra. Le tappe di avvicinamento
degli alieni alla terra seguono uno schema univoco (una specie di
ampio e ordinato zig-zag )che li porta lentamente ma
inesorabilmente, se non ostacolati, a raggiungere il fondo dello schermo decretando l'avvenuta invasione e
la conseguente fine della partita.
Il giocatore “difende la terra” affrontando con il suo cannone orde di alieni che si susseguono
incessantemente (sterminata un'ondata, subito un'altra scende, sempre più veloce e agguerrita). Ogni
tanto, nella zona in alto dello schermo scorrono velocemente alcune navicelle bonus che permettono al
giocatore di incrementare il suo punteggio molto più velocemente.
Il gioco si conclude quando le gli alieni raggiungono il fondo dello schermo o quando il cannone viene
distrutto. Il cannone può essere distrutto dal fuoco nemico, da bombe o da raggi mortali che
periodicamente vengono lanciate verso il cannone. Il giocatore dispone di tre cannoni mobili (tre vite o più
a seconda di settaggi del coin-up), dopo la distruzione degli stessi il gioco termina. Il giocatore dispone di un
numero illimitato di proiettili ma può sparare solo un colpo per volta. Man mano che le navicelle aliene
vengono distrutte le rimanenti si muovono più velocemente sullo schermo. La traccia sonora, minimalista
(una serie di impulsi), segue il ritmo sempre in crescendo della partita.
Versioni successive del gioco furono implementate con schemi e scenari differenti, ma rimasero intatte le
regole principali del gioco.

4
Tratto da https://it.wikipedia.org/wiki/Space_Invaders
10
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “JetPack Joyride”

Jetpack Joyride5 è un videogioco a scorrimento orizzontale sviluppato dalla Halfbrick Studios. È stato
pubblicato il 1º settembre 2011 per iOS, il 19 agosto 2012 per Android e il 23 ottobre 2012 per Windows 8.
Insieme a "Age of Zombies" e "Monster Dash" fa parte della serie Barry Steakfries. Nel novembre 2012 è
stato rilasciato per PSP, mentre nel dicembre 2012 è stato reso gratuito, dalla Big Ant Studios, per
PlayStation 3 e PS Vita.

Metodo di gioco
La base del meccanismo di gioco è basata sul tocco
dello schermo da parte del giocatore per dare potenza
al jetpack e quindi far sollevare Barry.
Il giocatore deve andare il più lontano possibile da dove
ha rubato il jetpack, raccogliendo le monete e evitando
missili, raggi laser ed elettrodi che generano scariche,
che tentano di ucciderlo.
Durante la corsa, il giocatore può accumulare anche i
Gettoni Slot, che appaiono a mezz'aria di tanto in tanto
e servono per poter giocare e tentare di vincere premi alla slot machine che appare dopo la morte del
personaggio (solo se giocando ha preso almeno un gettone). Di tanto in tanto appaiono anche delle scatole
color arcobaleno. Queste contengono dei veicoli, che possono aiutare Barry durante la sua fuga. …

Progetto “Puzzle Bobble”

Puzzle Bobble6 (conosciuto negli Stati Uniti, in Canada e qualche volta in Europa come Bust-a-Move) è una
serie di videogiochi creata dalla Taito.

Modalità di gioco
In cima all'area di gioco rettangolare, si trovano alcune biglie di
vari colori preimpostate in un modo particolare all'inizio del
livello. In basso si trova un cannone fermo, la cui rotazione è
controllata dal giocatore, che spara palline colorate in modo
semicasuale in linea retta. La palla, quando viene sparata,
viaggia in linea retta, possibilmente facendola rimbalzare
contro i muri, prima che una o più palle tocchino la linea
immaginaria all'altezza del cannone.
Se una pallina viene a contatto con un'altra dello stesso colore,
formando un gruppo di tre o più sfere, questo gruppo verrà
fatto "scoppiare" e sarà rimosso dal campo di gioco, facendo
"cadere" anche le palline sottostanti che si ancoravano ad esso.
Questo aspetto è molto importante per realizzare degli alti punteggi, dato che la prima pallina fatta cadere
(e non scoppiare) dà 20 punti, la seconda 40, la terza 80 e così via fino ad un massimo di 1,310,720 punti
bonus.
Per rendere il gioco più difficile, con il procedere del gioco, il muro in cima al livello e le palle sottostanti
scenderanno con il passare del tempo. Questo impone un tempo limite, in modo che il giocatore rimuova
tutte le palle prima che arrivino a toccare la linea in basso. …

5
Tratto da https://it.wikipedia.org/wiki/Jetpack_Joyride
6
Tratto da https://it.wikipedia.org/wiki/Puzzle_Bobble
11
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “2048”

20487 è un videogioco a giocatore singolo pubblicato on-line il 9 marzo 2014 da Gabriele Cirulli, uno
sviluppatore web italiano di 19 anni, il cui obiettivo è quello di far scorrere le piastrelle su una griglia, unirle
e creare una tessera con il numero 2048.
Considerato come un rompicapo, è molto simile a Threes!, applicazione pubblicata un mese prima.
Versioni simili includono anche elementi provenienti da Doge, Doctor Who, Flappy Bird e Tetris; è stata
anche pubblicata una versione 3D e versioni con griglie più grandi o più piccole. L'autore, Gabriele Cirulli,
definisce questi cloni come "La bellezza dei software open source" e non si oppone a loro in quanto, dice,
aggiungono nuove modifiche creative per il gioco.

A 2048 si gioca su una semplice griglia grigia di formato 4×4 in cui scorrono
caselle di colori diversi, con numeri diversi (tutti i numeri sono potenze di
2), senza intralci quando un giocatore le muove. Il gioco usa i tasti freccia
della tastiera per spostare tutte le caselle a sinistra o a destra oppure in
alto o in basso.
Se due caselle contenenti lo stesso numero si scontrano mentre si
muovono, si fondono in un'unica casella che avrà come numero la somma
delle due tessere che si sono scontrate e dunque il colore corrispondente.
Ad ogni turno, un nuova tessera con il valore di 2 o 4 apparirà in modo
casuale in un punto vuoto sul tabellone.
Inoltre, un tabellone in alto a destra tiene traccia del punteggio dell'utente. Il punteggio dell'utente inizia da
zero e viene incrementato ogni volta che due tessere si combinano, con il valore della nuova casella.
Come in molti altri giochi, il miglior punteggio dell'utente viene visualizzato accanto al punteggio attuale.
La partita è vinta quando, a furia di far combinare le tessere, si riesce a crearne una con il numero 2048: da
qui il nome del gioco. Dopo aver raggiunto il punteggio stabilito, i giocatori possono continuare oltre 2048.
Se il giocatore non può muovere le caselle (non ci sono spazi vuoti e senza tessere adiacenti con lo stesso
valore), finisce la partita.

7
Tratto da https://it.wikipedia.org/wiki/2048_%28videogioco%29
12
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “Gioco del 15”

Il “gioco del 15” è un solitario costituito di 15 tessere numerate da 1 a 15
(disposte su una matrice 4x4) e che presenta una casella vuota che il giocatore
può riempire spostando una tessera adiacente con movimenti orizzontali o
verticali:

Scopo del gioco è quello di muovere successivamente le tessere in modo da

portare la matrice nella situazione:

Linee guida per la progettazione: le operazioni (modificatori e osservatori) che la

classe dovrà come minimo implementare sono:
1. Inizializza(fattore_di_scombinazione)
è un modificatore che ha l’effetto di portare il gioco in uno stato più o meno lontano da quello finale a
seconda del fattore_di_scombinazione specificato. Se questo è pari a 0 si conviene che lo stato sia
quello finale. Si osservi che non è corretto pensare di inizializzare il gioco riempiendo casualmente la
matrice con i numeri da 1 a 15. Potremmo infatti incorrere in uno stato dal quale sarebbe poi
impossibile raggiungere lo stato finale. Un modo corretto è invece quello di partire dallo stato finale e
poi di scombinare la matrice attraverso delle mosse casuali.
2. Muovi(direzione)
è un modificatore che ha l’effetto di spostare una delle 4 tessere adiacenti alla casella vuota nella
direzione sepcificata e codificata mediante un numero da 1 a 4. Ad esempio Muovi(1), assumendo che
1 sia la codifica di “alto”, avrebbe l’effetto, con riferimento alla situazione della prima figura, di spostare
la tessera 14 verso l’altro e, quindi, di “spostare” la casella vuota verso il basso. Si osservi che se la
casella vuota è su un bordo della matrice non sarà possibile effettuare movimenti in tutte le direzioni.
3. Mosso
è un osservatore booleano che ci dice se l’ultima Muovi è stata eseguita, cioè se è stato richiesto un
movimento possibile. Conveniamo che sia falso prima della prima mossa.
4. NumeroTessera(riga, colonna)
è un osservatore che restituisce il numero della tessera posta all’incrocio specificato. Conveniamo di
restituire 0 nel caso in cui si tratti delle coordinate della casella vuota.
5. RaggiuntoObiettivo
è osservatore booleano che restituisce true se e solo se il gioco si trova nello stato finale. Si tratta di una
query molto utile, ma ridondante. Tale informazione potrebbe infatti essere ottenuta unicamente
mediante l’osservatore precedente.

Si osservi che la prima operazione sarà ottima candidata per il comando di creazione.
Suggerimenti per l’implementazione: per rappresentare lo stato del gioco la scelta di una matrice, anche se
facilita la stesura dei metodi Muovi e NumeroTessera rende sia meno immediati che meno efficienti i
metodi Inizializza e RaggiuntoObiettivo. Quest’ultimo diventa relativamente semplice da scrivere ed
efficiente se optiamo invece per una rappresentazione a vettore di 16 elementi (vettore tessere) in cui la
stessa matrice risulta memorizzata per righe. Pe rendere individuabile in modo efficiente la posizione della
casella vuota, decidiamo, inoltre, di aggiungere tra gli attributi variabili anche l’indice della posizione della
tessera vuota (posizioneVuota) e le sue coordinate rispetto all’ipotetica 4x4 (vuotaX e vuotaY). Nella parte
nascosta della classe viene anche definita una funzione ausiliaria (Posizione) che calcola l’ndice di una
tessera nel vettore tessere date le sue coordinate nella matrice.

13
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “Sette e mezzo”

Il sette e mezzo è un popolare gioco di carte italiano.

Per giocare si usa un mazzo di quaranta carte da gioco (l’usuale mazzo utilizzato per la briscola). Nel mazzo
ci sono, quindi, quattro carte di semi diversi per ciascun valore fra asso e 7, più dodici figure.
Il gioco si svolge tra due giocatori, uno è l’utente, l’altro il computer.
Uno dei giocatori è deputato alla funzione di mazziere e di banco (il computer).
Lo scopo del gioco è quello di realizzare il punteggio più alto possibile senza mai sballare, vale a dire senza
superare il 7 e mezzo. Il mazziere deve cercare di eguagliare o superare il punteggio del giocatore.
Il punteggio di ciascun giocatore si calcola sommando i punti di tutte le carte che possiede:
• le carte dall'asso al 7 valgono tanti punti quanto è il loro valore numerico. L'asso vale 1 punto, il 2
vale 2 punti, ecc.
• le figure valgono mezzo punto.

Svolgimento del gioco

Il mazziere è sempre il computer.
All'inizio della mano il mazziere distribuisce una carta coperta al giocatore ed una scoperta a se stesso. Il
gioco inizia dal giocatore che effettua le seguenti operazioni:
• Guarda la propria carta.
• Se lo vuole, può richiedere altre carte per migliorare il proprio punteggio. Tutte le carte successive
alla prima vengono date scoperte una per volta, fino a quando il giocatore continua a richiederne.
• Se un giocatore sballa o realizza 7 e mezzo il deve comunicarlo immediatamente scoprendo anche
la prima carta ricevuta (questa operazione è ovviamente gestita automaticamente dal computer).
Nel caso il giocatore sballi, il gioco è concluso con la vittoria del banco.
• Il mazziere decide se prendere altre carte con l’obiettivo di superare il punteggio del giocatore. Se
il mazziere sballa la vittoria è assegnata automaticamente al giocatore.
• Alla fine vengono confrontati i risultati e la vittoria è assegnata al giocatore che ha raggiunto il
punteggio maggiore. In caso di parità vince sempre il banco.

Progetto “Snake”

Snake è un videogioco presente in molti telefonini. Le sue origini

risalgono agli anni settanta, con i videogiochi arcade Barricade e
Blockade; da allora è stato prodotto in numerose piattaforme e varianti,
fino a ritrovare nuova fama negli anni novanta grazie ai cellulari.
Snake è un serpente che mangiando quello che appare sul display si
allunga, e il giocatore guadagna dei punti. Si muove costantemente e
deve evitare di andare a sbattere contro gli ostacoli, ma soprattutto
contro sé stesso, cosa sempre più difficile man mano che il suo corpo si
allunga.

14
IIS “Marzotto-Luzzatti” - Classi 4^D1 e 4^D2 2021/2022 Corso di Informatica - Proff. Crosato/Bedani

Progetto “Gioco del filetto” (“Tris”)

Il tris8 (noto anche come filetto, fila tre, crocetta e pallino, zero per, cerchi e croci, tria o, nel mondo
anglosassone, tic-tac-toe) è un popolarissimo e semplicissimo gioco di carta e matita.
Si gioca su una griglia quadrata di 3×3 caselle (ma ci sono varianti che usano griglie più grandi). A turno, i
giocatori scelgono una cella vuota e vi disegnano il proprio simbolo (di solito un giocatore ha come simbolo
una “X” e l’altro un cerchio “O”).
Vince il giocatore che riesce a disporre tre dei propri simboli in linea retta orizzontale, verticale o diagonale.
Se la griglia viene riempita senza che nessuno dei giocatori sia riuscito a completare una linea retta di tre
simboli, il gioco finisce in parità.

Il progetto da realizzare deve permettere a due giocatori “umani” di giocare l’uno contro l’altro, segnando a
turno sulla griglia; quest’ultima va dimensionata ad una dimensione N x N (quindi non solo 3x3).
Il progetto può essere realizzato implementando due classi:
Classe Tris che implementa la logica di gioco indipendentemente dalla gestione dell’interfaccia utente e con
le seguenti caratteristiche:
• questa classe potrebbe rappresentare la griglia attraverso una matrice quadrata di interi (0
identifica la cella vuota, -1 identifica il giocatore “X” mentre 1 identifica il giocatore “O”; si noti che
questa scelta semplifica il cambio da un giocatore all’altro e la verifica dello stato del gioco)
• costruttore che inizializza il gioco impostando il giocatore di partenza
• osservatore che restituisce lo stato di una casella date le sue coordinate
• osservatore che restituisce il prossimo giocatore che dovrà muovere
• osservatore che determina se e qual’è il vincitore nello stato attuale del gioco
• modificatore che marca una cella con il giocatore corrente (e aggiorna il giocatore)
• osservatore che determina se il gioco è finito

Classe TrisGrid che è ereditata dalla precedente e, rispetto a quella, gestisce l’interfaccia grafica: ad
esempio potrebbe allocare una DataGridView inserendola in un controllo contenitore (Panel o altro) il cui
riferimento viene passato al costruttore.
Per disegnare su una DataGridView si può sfruttare l’evento CellPainting (si veda ad esempio:
https://docs.microsoft.com/en-us/dotnet/api/system.windows.forms.datagridview.cellpainting)

8
Tratto da https://it.wikipedia.org/wiki/Tris_%28gioco%29
15