sosolitario - sti.uniurb.it · precondizioni il giocatore deve aver terminato il mazzo da gioco...

Progetto Ingegneria del Software

Anno Accademico 2014-2015

Sessione invernale

SoSolitario

Una tipologia di solitario come tante

Giulia Talamonti n°248899

2

Indice

1. Specifica del problema 4

2. Specifica dei requisiti

2.1 Diagramma dei casi d’uso 5

2.2 Relazioni e descrizione dei casi d’uso 6

3. Analisi e progettazione

3.1 Linguaggio di programmazione 12

3.2 Ambiente di sviluppo 12

3.3 GUI 14

3.4 Design pattern 15

3.5 Organizzazione progetto 16

3.6 Classi 17

3.7 Diagramma delle classi

3.7.1 Diagramma delle classi Mazzo-Carta 35

3.7.2 Diagramma delle classi MVC 36

3.7.3 Diagramma di sequenza di una partita 37

4. Implementazione

4.1 Carta.cs 38

4.2 Mazzo.cs 39

4.3 MazzoNormale.cs 41

4.4 MazzoPiacentine.cs 42

4.5 PartitaSolitario.cs 44

4.6 IniziaPartita.cs 47

4.7 Tavolo.cs 47

4.8 Regole.cs 48

4.9 IniziaPartitaController.cs 49

3

4.10 TavoloController.cs 50

4.11 Program.cs

5. Test

5.1 WhiteBox Test 61

5.2 BlackBox Test 71

6. Compilazione ed esecuzione 81

4

1. Specifica del problema

Si vuole realizzare una applicazione desktop per il gioco di carte Solitario. In

particolare si vuole sviluppare una versione che supporta due tipologie di mazzo. Il

classico mazzo con 53 carte e il mazzo di carte piacentine italiano da 40 carte.

Il mazzo classico è inteso come il mazzo di carte francesi che comprende carte

dall'asso al re per ognuno dei quattro colori (quadri, picche, fiori, cuori) e senza

i jolly. Per ogni seme abbiamo quindi 13 carte.

Il mazzo italiano di carte piacentine comprende 4 semi diversi di cui troviamo i

numeri 2, 3, 4, 5, 6, 7, più l'asso e le figure (fante, cavallo e re). I semi sono denari,

coppe, bastoni e spade.

L’utente deciderà di iniziare una partita, quindi un singolo gioco, scegliendo il mazzo

con il quale voler giocare.

La versione del gioco del solitario considerato si basa su queste regole:

il giocatore scopre una carta alla volta e ne visualizza il valore disponendola

sul tavolo

le carte scoperte vengono disposte in fila una dietro all’altra

tra le carte scoperte il giocatore deve individuare quelle coppie di carte che hanno o lo stesso numero o seme e che distano tra di loro di una carta (non è importante il valore di questa carta)

una volta individuata una coppia che rispetta i vincoli prima enunciati, la carta più a sinistra viene eliminata

Durante il gioco si pescheranno nuove carte dal mazzo, si disporranno sul tavolo e il

giocatore deve cercare di avere sempre il minor numero possibile di carte in tavola.

Una volta scoperte tutte le carte del mazzo, il giocatore potrà richiedere dei

suggerimenti. Al termine di tre aiuti, se sul tavolo da gioco non saranno presenti

soltanto due carte, il giocatore avrà perso.

Le due tipologie di mazzo sono un ottimo modo per ottenere due giochi di difficoltà

diversa.

5

2. Specifica dei requisiti

Di seguito vengono riportate i casi d’usi dell’applicativo che ci aiuteranno a

comprendere al meglio le funzionalità del gioco.

Il diagramma dei casi d’uso ha evidenziato la partecipazione di un unico attore: il

giocatore, il quale potrà scegliere inizialmente quale tipo di mazzo di carte voler

utilizzare. Una volta che il giocatore avrà scelto, il sistema mostrerà al giocatore il

tavolo predisposto per la partita.

2.1 Diagramma dei casi d’uso

6

2.2 Relazioni e descrizione dei casi d’uso

Si mostreranno di seguito le descrizioni dei casi d’uso individuati.

Il giocatore avvia l’applicazione GUI e visualizzerà un form che darà a lui la

possibilità di decidere se utilizzare il mazzo classico da poker oppure il mazzo

italiano piacentino. I casi d’uso #1 e #2 sono del tutto speculari.

Caso d’uso Inizia nuova partita con mazzo normale

ID #1

Attore

Giocatore

Precondizioni Il giocatore lancia il programma che mostra un form contenente la possibilità di scegliere tra i due mazzi da gioco.

Corso d’azione base

1) Il giocatore clicca sull’immagine del mazzo normale 2) Il programma mostra il tavolo da gioco

Post condizioni

Il giocatore può visualizzare il tavolo da gioco predisposto con il mazzo normale.

Percorso Alternativo

Il giocatore lancia il programma e sceglie il mazzo piacentino.

Caso d’uso Inizia nuova partita con mazzo piacentino

ID #2

Attore

Giocatore

Precondizioni Il giocatore deve aver lanciato il programma che mostra un form contenente la possibilità di scegliere tra i due mazzi.


1) Il giocatore clicca sull’immagine del mazzo piacentino 2) Il programma mostra il tavolo da gioco

Post condizioni

Il giocatore può visualizzare il tavolo da gioco predisposto con il tipo di mazzo piacentino.


Il giocatore lancia il programma e sceglie il mazzo normale.

7

Visualizza il tavolo da gioco

Una volta che il giocatore ha scelto il mazzo da utilizzare si visualizzerà il

tavolo da gioco consentendo all’utente di interagire con l’interfaccia.

La operazioni che il giocatore può compiere sono:

- Scoprire una carta dal mazzo

- Selezionare una carta scoperta sul tavolo

- Deselezionare una carta scoperta sul tavolo

- Selezionare due carte scoperte e tentare di eliminare quella più a sinistra

- Iniziare una nuova partita

- Chiedere un suggerimento

- Visualizzare le regole del gioco

Caso d’uso Scoprire una carta dal mazzo

ID #3

Attore

Giocatore

Precondizioni Post condizioni #1 o #2


1) Il giocatore clicca sull’immagine del mazzo 2) Il programma dispone sul tavolo la carta estratta dal mazzo

Post condizioni

Il giocatore può visualizzare sul tavolo da gioco la carta che ha pescato dal mazzo.


Il giocatore ha pescato tutte le carte del mazzo, il programma mostra all’utente un messaggio in cui si notifica la nuova condizione, quindi l’immagine del mazzo non è più presente sul tavolo da gioco.

8

Caso d’uso Selezionare una carta scoperta sul tavolo

ID #4

Attore

Giocatore

Precondizioni Post condizione #3


1) Il giocatore clicca su una delle carte scoperte 2) Il programma mette in evidenza la carta selezionata

Post condizioni

Il giocatore può visualizzare la carta che è stata da lui cliccata


/

Caso d’uso Deselezionare una carta scoperta sul tavolo

ID #5

Attore

Giocatore

Precondizioni Post condizione #4


1) Il giocatore clicca sulla carta scoperta selezionata precedentemente

2) Il programma mette in evidenza che la carta è stata deselezionata

Post condizioni

Il giocatore può visualizzare che la carta non è più messa in evidenza


/

9

Caso d’uso Selezionare due carte scoperte e eliminare una di queste

ID #6

Attore

Giocatore

Precondizioni Il giocatore ha scoperto più di tre carte sul tavolo da gioco


1) Il giocatore clicca e seleziona una delle carte scoperte 2) Il giocatore clicca e seleziona su un’altra carta scoperta sul

tavolo 3) Se le due carte selezionate hanno lo stesso numero o lo

stesso seme e le carte si trovano a distanza uno, la carta sinistra viene eliminata

Post condizioni

Il giocatore vedrà tra le carte scoperte una carta in meno, cioè quella selezionata (più a sinistra tra le due). Le carte scoperte quindi shiftano sulla sinistra.


1)

- Il giocatore ha selezionato due carte che non distano tra di loro di una carta.

- Il programma visualizza un messaggio che informa il giocatore che non è possibile eliminare nessuna carta perché non sono alla giusta distanza

2) - Il giocatore ha selezionato due carte che distano tra di loro

di una carta - Il programma visualizza un messaggio che informa il

giocatore che non è possibile eliminare nessuna carta perché le carte non sono ne di numero uguale ne di seme uguale

10

Caso d’uso Visualizzare le regole del gioco

ID #7

Attore

Giocatore

Precondizioni Post condizione #1 e #2


1) Il giocatore desidera visualizzare informazioni aggiuntive sul gioco clicca sul bottone “Regole del gioco”

2) Il programma visualizza un form contenente le regole base del solitario considerato

Post condizioni

Il giocatore vedrà una nuova finestra con le regole del solitario


/

Caso d’uso Iniziare una nuova partita

ID #9

Attore

Giocatore

Precondizioni Post condizione #1 o #2


1) Il giocatore desidera iniziare una nuova partita, clicca sul bottone “Nuova partita”

2) Il tavolo da gioco viene “ripulito”

Post condizioni

Il giocatore vedrà il tavolo da gioco senza carte scoperte


/

11

Caso d’uso Chiedere un suggerimento

ID #8

Attore

Giocatore

Precondizioni Il giocatore deve aver terminato il mazzo da gioco


1) Il giocatore clicca sul tasto “Aiuto” 2) Il programma visualizza sul tavolo da gioco due carte da

gioco che possono essere selezionate e eliminate per continuare il gioco

Post condizioni

Il giocatore avrà visualizzato le carte che è possibile selezionare per l’eliminazione di una delle due


1) I suggerimenti non sono terminati ma non ci sono più combinazioni di carte per poter proseguire il gioco

1.1 Il giocatore clicca sul tasto “Aiuto” 1.2 Il programma non individua nessuna combinazione possibile, mostra al giocatore un messaggio dove viene informato che ha perso la partita perché non ci sono più carte da eliminare

2) I suggerimenti sono terminati ma ci sono combinazioni

2.1 Il giocatore clicca sul tasto “Aiuto” 2.2 Il giocatore ha terminato i suggerimenti a disposizione

(si hanno a disposizione 3 aiuti) il programma visualizza un messaggio dove informa l’utente che ha terminato i suggerimenti e che la partita è persa

3) Ci sono solo due carte scoperte 3.1 il giocatore clicca sul tasto “Aiuto” 3.2 Il programma notifica all’utente che ha vinto la partita

12

3. Analisi e progettazione

Descriveremo in questa sezione le principali scelte di progettazione e di

implementazione fatte per realizzare il gioco.

Scelte di progetto

Linguaggio di programmazione

Ambiente di sviluppo

GUI

Design pattern

Organizzazione progetto

Classi

Diagramma delle classi

Diagramma di interazioni

3.1 Linguaggio di programmazione : C#

Il linguaggio di programmazione C# è un linguaggio multi paradigma: orientato ad

oggetti, imperativo, ad eventi e funzionale. Il linguaggio è stato concepito dalla

Microsoft per contrapporsi ai nascenti linguaggi ad oggetto. La gran parte della forza

di questo linguaggio deriva dall’utilizzo delle API del framework .NET che mette a

disposizione numerose classi base per lo sviluppo di applicazioni di vario genere.

C# risulta essere molto versatile e permette allo sviluppatore di realizzare progetti

software sfruttando a pieno le caratteristiche e i vantaggi della programmazione ad

oggetti.

In particolare dando la possibilità di effettuare l’incapsulamento dei vari componenti

per riuscire a gestire i malfunzionamenti, decidendo il grado di accessibilità dei vari

elementi, sfruttando la definizione di classe astratte, interfacce che ci consentono di

creare dei format per gli oggetti ben definiti che possono essere ereditati tra le varie

classi e sfruttando in ultimo il concetto di polimorfismo che ci consente di avere

codice riusabile e più facilmente mantenibile per successive migliorie.

Offre un ottimo ambiente per lo sviluppo visuale delle applicazioni di tipo desktop

ed è reperibile sul web un’ampia documentazione delle classi a disposizione.

13

3.2 Ambiente di sviluppo

Si è utilizzato per lo sviluppo del progetto l’ambiente Visual Studio C# 2010 che

utilizza il framework .NET 4.0 . La versione utilizzata è quella che Microsoft mette

gratuitamente a disposizione cioè la Express. Le funzionalità di questo ambiente

sono stata sufficienti per lo sviluppo del software.

3.3 GUI

Per ottenere un livello di gioco che si avvicinasse al solitario giocato realmente, si è

deciso di realizzare un’applicazione di tipo grafica. Infatti lo stessa tipologia di gioco,

via console, non avrebbe coinvolto in egual modo il giocatore.

L’intero progetto è stato quindi concepito per l’applicazione grafica, attraverso

l’utilizzo di Windows form e dei suoi elementi sfruttando classi già presenti nel

framework .NET.

Tra le classi grafiche utilizzate abbiamo:

PictureBox che rappresenta un controllo casella dell'immagine.

Button che rappresenta un pulsante che risponde all'evento Click.

MessageBox visualizza una finestra di messaggio che può contenere testo,

pulsanti e simboli.

Abbiamo introdotto principalmente tre form:

Form lancio del programma

Form tavolo da gioco

Form regole di gioco

Il primo form da la possibilità all’utente di scegliere il mazzo da gioco desiderato, si

sono utilizzate due PictureBox per rappresentare i due mazzi e si è attivato un

evento MouseClick per reagire alla scelta dell’utente. Una volta compiuta la scelta, si

aprirà un secondo form, al di sopra del primo, che rappresenterà il tavolo da gioco,

già predisposto per la partita. Si troveranno in questa schermata 3 bottoni in basso a

destra.

Questi ci serviranno per mostrare le “Regole del gioco”, iniziare una “Nuova partita”

e per sfruttare i “Aiuti”. Inizialmente il bottone “Aiuti” è disabilitato perché il

http://msdn.microsoft.com/it-it/library/system.windows.controls.primitives.buttonbase.click(v=vs.110).aspx

14

giocatore potrà usufruire dei suggerimenti solo nel momento in cui tutte le carte del

mazzo sono state scoperte. Abbiamo inoltre introdotto un particolare oggetto che

rappresenta le carte sul tavolo da gioco, CartaTavolo che associa alla carta logica

l’immagine relativa attraverso una PictureBox.

Sul tavolo in alto a destra verrà posizionato invece l’immagine del mazzo. Il

giocatore cliccherà come prima cosa sul mazzo, e verrà posizionata in alto a sinistra

la prima carta scoperta. Ad ogni click sull’immagine del mazzo, verrà pescata una

nuova carta, che sarà affiancata a quella precedentemente scoperta. Le carte

vengono disposte in file da dieci da sinistra a destra e le file e la dimensione del

tavolo sono calcolate in base al numero di carte del mazzo scelto. Infatti andremo a

calcolare la dimensione del form tavolo tenendo conto di quanto spazio

occuperebbero tutte le carte se fossero scoperte.

Le dimensioni dei form non possono essere modificate dall’utente durante il gioco.

Infine possiamo mostrare una schematizzazione del form tavolo da gioco attraverso

questa immagine:

15

Infine abbiamo introdotto all’interno del progetto delle risorse immagini, nelle

Properties dell’applicativo, che rappresentano le immagini relative ai due mazzi da

gioco che poi verranno visualizzate. Le dimensioni dei due mazzi sono descritte in

pixel.

- Le carte del mazzo piacentino hanno dimensione 70x121 px

- Le carte del mazzo da poker hanno dimensione 70x96 px

3.4 Design Pattern

La volontà di sviluppare una applicazione che sfrutti un’interfaccia grafica ha

sicuramente determinato la scelta di utilizzare, per l’intero progetto, il pattern di

sviluppo MVC (Model View Control).

Questo design pattern fondamentale ci da la possibilità di suddividere l’intero

sistema in 3 importanti moduli.

Possiamo infatti ottenere un disaccoppiamento efficace della logica

dell’applicazione e dei dati dalla vista offerta all’utente, consentendo una riusabilità

del codice per più applicazioni o per successive integrazioni e facilitando la fase di

testing, che può essere mirata ai vari componenti secondo le problematiche che

emergono.

I 3 moduli sono:

Modello: gestisce il comportamento e i dati dell’applicazione, risponde alle

richieste del cambiamento da parte dell’utilizzatore.

Vista: mostra le informazioni all’utente.

Controller: interpreta gli input dell’utente e informa la vista e il modello del

cambiamento appropriato.

16

Come si può notare, il controller e la vista dipendono dal modello, ma il modello non

dipende da nessuno dei due moduli.

3.5 Organizzazione progetto

L’applicazione sviluppata rispetta il design pattern MVC infatti, si sono sviluppate

delle librerie specifiche per modellare concettualmente gli oggetti del gioco, quali la

carta, il mazzo, e la logica del gioco stesso.

Per sviluppare il modello si è ricorso ai principali concetti offerti dalla

programmazione ad oggetti. Infatti si è individuato un prototipo di Mazzo, che ha

caratteristiche comuni a tutti i mazzi e allo stesso modo si è realizzato un prototipo

di carta da gioco, il più generale possibile. Dopo di che, abbiamo i mazzi specifici che

ci serviranno nel gioco, che hanno ereditato le caratteristiche dalla loro classe base.

La vista iniziale che appare all’utente nel momento del lancio del gioco permette a

questo di scegliere con quale mazzo iniziare a giocare. Il tavolo invece fungerà da

concetto logico per la vista offerta all’utente per giocare.

Infine si utilizzeranno due controller, uno che gestirà la scelta iniziale del giocatore

del mazzo, il secondo invece interpreterà le azioni del giocatore sul tavolo durante la

partita, aggiornando di conseguenza la vista, cioè il tavolo da gioco.

Nel lancio iniziale dell’applicazione si richiamerà il controller per la scelta iniziale che

poi porterà al controller tavolo. Abbiamo quindi questi elementi fondamentali:

Modello Carta Mazzo MazzoPiacentino MazzoNormale PartitaSolitario SemePiacentine CartaPiacentine SemeFrancese CartaFrancese

View CartaTavolo IniziaPartita Tavolo Regole

17

Controller IniziaPartitaController TavoloController

3.6 Classi

Si descrivono di seguito le classi istanziate e utilizzate per lo sviluppo del progetto

attraverso l’utilizzo di diagrammi UML.

Modello

La prima parte della descrizione riguarda le due classi fondamentali, cioè Carta e

Mazzo. Poi si passerà alla descrizione dei mazzi specifici, e infine si descriverà la

classe che gestirà la logica del gioco.

3.6.1 Carta

La classe Carta modellizza l’idea logica che si ha di una singola carta presente in un

mazzo generico. Gli attributi della classe sono quelli che caratterizzano una carta

fisica, cioè il numero che è un integer ed è un attributo privato che verrà poi settato

tramite le proprietà NumeroCarta.

Il secondo importante attributo è invece il seme che viene rappresentato con un

integer. Nella realtà il seme della carta rappresenta, più che un numero, una stringa

(es. Picche, Fiori…), essendo comunque il numero di semi all’interno di un mazzo

numerabili, si è preferito rappresentare l’attributo numericamente per renderlo il

più generico possibile.

Anche quest’ultimo verrà settato tramite le proprietà SemeCarta.

18

Per entrambe le proprietà, al momento del setting del valore, controlleremo che il

valore non sia un valore negativo, in caso contrario alzeremo un eccezione.

Si sono poi introdotti due costruttori per la classe, uno senza parametri e uno con

parametri(numero carta e seme carta). Il costruttore con i parametri verrà utilizzato

nella creazione effettiva del mazzo di carte durante l’inizializzazione.

3.6.2 Mazzo

La classe Mazzo concettualizza un mazzo di carte da gioco generico. Questa è una

classe astratta, che quindi non ha un costruttore, ma potrà essere ereditata da classi

specifiche. Infatti è stata pensata appositamente per creare un prototipo di mazzo,

da cui i mazzi “reali” devono ereditare. Tra gli attributi simbolo del mazzo abbiamo

le dimensioni del mazzo, che potranno essere settate dalle rispettive proprietà di

Larghezza e Altezza. C’è inoltre un ulteriore attributo carte che è rappresentato da

una List <Carta>, uno degli oggetti che il linguaggio C# mette a disposizione nelle

librerie di sistema Collection. Sarà semplicemente la lista di carte del mazzo. Questo

è stato definito come attributo pubblico.

Si definiscono inoltre 3 proprietà astratte della classe mazzo:

NumeroCartePerSeme

NumeroCarteTotali

NumeroSemi

19

Le tre proprietà sono di sola lettura, infatti nelle classi che ereditano, questi attributi

non potranno essere modificati. Sono infatti proprietà che rendono caratteristico il

mazzo.

I metodi definiti riguardano le principali azioni che si possono compiere su di un

mazzo.

mazzoVuoto() è il metodo che restituisce true se il mazzo non è stato creato,

cioè la lista delle carte è vuota.

prendiCarta() è il metodo che estrae dal mazzo la prima carta e la rimuove

dalla lista. Il metodo restituisce la carta pescata. Nel caso in cui il mazzo sia

vuoto, il metodo alzerà una eccezione per segnalare all’utente che sono

estratte tutte le carte.

nuovoMazzo() è il metodo che si occupa di creare la lista di carte specifiche

per il mazzo. Istanzia quindi un oggetto List <Carta> e lo riempie tenendo

conto delle proprietà NumeroCartePerSeme e NumeroSemi. Sono proprietà

astratte che verranno specificate dalle classi che erediteranno la classe mazzo.

mescolaMazzo() è il metodo che consente di mischiare le carte del mazzo, si

andrà prima di tutto a controllare se il mazzo non è vuoto, in caso

affermativo, viene applicato l’algoritmo di mescolamento. L’algoritmo

utilizzato è quello definito da Knuth-Fisher-Yates. E’ un algoritmo utilizzato

per generare permutazioni random di un set finito di carte. Questo algoritmo

ha una complessità pari a O(n) dove n è il numero di carte del mazzo.

L’algoritmo è inoltre imparziale ciò vuol dire che statisticamente ogni

mescolamento ha la stessa probabilità rispetto agli altri mescolamenti.

In effetti il mescolamento di carte può essere descritto attraverso l’uso

dell’operatore fattoriale. Le possibili combinazioni di mescolamento per n

carte è uguale a n! cioè n*(n-1)*(n-2)*…*1.

ottieniValoreCarta(int numeroCarta) è il metodo virtuale che potrà essere

sovrascritto nelle classi derivate per ottenere la stringa specifica del valore

della carta. In questa classe, il metodo restituisce il valore stringa del numero

della carta.

ottieniSemeCarta(int semeCarta) è il metodo virtuale analogo al precedente

ma avrà il compito di restituire il valore in stringa del seme della carta.

Dopo aver definito le classi più generali, andiamo a descrivere le classi implementate

per rappresentare le due tipologie di mazzo.

20

Andremo prima di tutto a specificare le enumerazioni che rappresentano i semi

delle carte. Abbiamo in particolar modo due tipi di seme:

Seme delle carte francesi

Seme delle carte piacentine

3.6.3 SemeFrancese

Abbiamo definito un enumerazione che rappresenterà il seme della carta del tipo di

mazzo Normale e per normale intendiamo appunto il mazzo con semi francesi. Il

valore va da 1 a 4 per i 4 semi.

3.6.4 CartaFrancese

L’enumerazione rappresenta le tredici tipiche carte del mazzo normale da Poker in

stringa.

21

3.6.5 SemePiacentine

Come precedentemente con il seme francese, si è definito un enumerazione per i

semi del mazzo italiano Piacentino.

I suoi valori vanno da 1 a 4.

3.6.6 CartePiacentine

Si è definito l’enumerazione che rappresenta il mazzo di carte piacentine. Composto

da 10 carte per ogni seme.

22

3.6.7 Mazzo Normale

La classe MazzoNormale eredita dalla classe astratta Mazzo e rappresenta il mazzo

di carte tipico da 52 carte, con 4 semi e con 13 carte per ogni seme. Con i semi di

tipo francese. I semi saranno rappresentati dall’enumerazione specifica.

Si sono definite due costanti private NUMCARTESEME e NUMSEMI che

rappresentano per l’appunto il numero di semi, e il numero di carte per seme.

Questi valori potranno essere letti dall’utente attraverso le proprietà di sola lettura

get messe a disposizione nella classe astratta e ridefinite in questa classe specifica.

E’ in più possibile ottenere il numero totale di carte sempre con la proprietà di sola

lettura NumeroCarteTotali.

Il costruttore della classe si occupa semplicemente di richiamare il metodo della

classe astratta nuovoMazzo(), dove appunto si andrà a riempiere la lista di carte con

i valori delle carte.

Sono definiti inoltre due metodi che ridefiniscono quelli della classe base Mazzo

ottieniValoreCarta() e ottieniSemeCarta() che ci consentiranno di ottenere il valore

stringa del seme della carta e del numero della carta, in accordo con la tipologia di

mazzo, sfruttando le enumerazioni messe a disposizione.

23

3.6.8 MazzoPiacentine

Il mazzo piacentino è del tutto analogo a quello normale, si utilizzano gli stessi

attributi, soltanto che questi sono adattati alle caratteristiche del mazzo piacentino.

Quindi avremo sempre una costante che ci indica il numero di semi, che anche in

questo caso sono 4, e il numero di carte per seme che invece sono 10.

24

Possiamo quindi ottenere un diagramma UML parziale tra le classi Mazzo

MazzoPiacentine e MazzoNormale :

25

3.6.9 PartitaSolitario

La classe PartitaSolitario è stata implementata in modo tale di mettere a

disposizione gli strumenti e i metodi per poter gestire la logica del gioco.

Come attributi di classe abbiamo:

selezionate List<int> che è una lista di interi, dove andremmo a salvare gli

indici delle carte selezionate dal giocatore.

suggerimenti è la variabile intera che ci indica il numero di aiuti ancora

disponibili per la partita. Il suo valore di default è 3. E’ una variabile privata e è

possibile decrementare il suo valore attraverso il metodo specifico

usaSuggerimento().

carteFila è la variabile che ci indica quante carte saranno disposte per ogni fila

del tavolo da gioco. Questa variabile può essere modificata attraverso

l’utilizzo delle proprietà ad essa correlata.

Il costruttore della classe PartitaSolitario , prende come parametro un oggetto della

classe Mazzo. Questo si occuperà di richiamare il metodo del mazzo mescolaCarte()

e di inizializzare la lista di carte da poter selezionare.

26

I metodi implementati:

cartaSelezionata prende come parametro l’indice della carta che è stata

selezionata dall’utente e restituisce un valore intero che determina come

agire durante la successiva fase di gioco. Entrando nel dettaglio, il metodo

restituisce :

o -1, se la carta che è stata selezionata dall’utente, è già presente nella lista

o 0 , se la carta, è il primo elemento che viene introdotto nella lista di

controllo

o 1 se all’interno della lista ci sono due carte e la distanza rispetta i vincoli

del gioco; per cui abbiamo due carte che distano tra di loro di una

posizione

o 2 se all’interno della lista ci sono due carte ma la loro distanza non rispetta

i vincoli di gioco

cartaDaEliminare prende come parametri due oggetti Carta e due interi.

Questi corrispondono alle due carte selezionate dall’utente e i rispettivi indici.

Si verifica se il valore numerico o il valore di seme è lo stesso e in tal caso

viene restituito l’indice di valore minore, che corrisponde alla carta più a

sinistra e quindi la carta che si vuole eliminare. Nel caso in cui le due carte non

rispettino il vincolo precedentemente menzionato, allora il metodo restituirà

un valore negativo -1.

dimensioneTavolo è il metodo che prende come parametri il numero delle

carte del mazzo, le dimensioni del mazzo (larghezza e altezza) e il valore di

offset tra le carte sul tavolo. Si calcolerà, a seconda del mazzo, la dimensione

che rappresenterà il tavolo da gioco. Restituisce quindi due valore interi che

rappresenteranno l’altezza e la larghezza del tavolo da gioco.

fileMassime è il metodo che ci restituisce il numero di file massime che si

potranno visualizzare sul tavolo da gioco, questo parametro è direttamente

correlato con il numero di carte per fila, valore che viene settato in questa

stessa classe.

usaSuggerimento è il metodo che ci serve per decrementare la variabile

suggerimenti, e quindi verrà richiamato nel momento in cui l’utente

richiederà un aiuto.

distanzaCarteCorretta è il metodo privato che si è utilizzato all’interno del

metodo cartaSelezionata, e ci indicherà se la distanza tra i due valori

specificati rispetta i vincoli del gioco.

27

trovaElementoSelezionato determina, se un certo valore, è presente

all’interno della lista passata per parametro.

coppiaCorretta determina se la coppia di carte inserite come parametro,

hanno numero o seme uguale.

Infine abbiamo la definizione delle due proprietà sugli attributi suggerimenti e

cartePerFile.

View

Si vanno ora a descrivere le classi che caratterizzano la vista del gioco.

3.6.10 CartaTavolo

Questa classe è stata introdotta come ponte tra la carta logica e la carta

visualizzata dall’utente per la GUI. Infatti associamo direttamente a un oggetto

Carta, un oggetto di tipo PictureBox, che corrisponderà all’immagine della carta.

Attraverso le proprietà get e set possiamo ottenere e settare gli attributi carta e

picture box della classe.

3.6.11 IniziaPartita

28

IniziaPartita è la vista che viene richiamata dal controller all’avvio del gioco.

Mostrerà due PictureBox contenenti le immagini delle tipologie di mazzo.

3.6.12 Tavolo

La classe Tavolo rappresenta la parte grafica dove l’utente interagirà con il gioco

di carte. La progettazione dell’interfaccia grafica precedentemente affrontata,

rispecchia fedelmente la sua implementazione. Troviamo quindi un’area adibita

alla visualizzazione delle carte scoperte dall’utente (la lista di CarteTavolo),

un’area riservata al mazzo (la picture box del mazzo), e una serie di tasti che

consentono di gestire le principali opzioni di gioco. Le carte verranno mostrate

grazie all’utilizzo dell’attributo carteScoperte che è una lista di oggetti

CartaTavolo.

Importanti all’interno di questa classe, sono i metodi cambiaSize e

cambiaPosizioneMazzo. Rispettivamente ci serviranno per cambiare la

dimensione del form durante l’inizializzazione del tavolo, e il posizionamento del

mazzo sul tavolo.

29

3.6.13 Regole

La classe Regole rappresenta la vista che viene mostrata quando l’utente vuole

leggere le istruzioni del gioco.

Control

Vengono descritte le classi adibite al controllo e quindi alla comunicazione tra

vista e modello. Rendono possibile la risposta adeguata agli input dell’utente.

3.6.14 IniziaPartitaController

La classe IniziaPartitaController è stata implementata per fungere da controller

nella fase iniziale dell’avvio del software. Questa inizializzerà il gestore degli

eventi, sarà quindi possibile controllare la scelta dell’utente attraverso l’evento

MouseClick su una delle due PictureBox presenti nella vista IniziaPartita.

In entrambi i casi si andrà ad inizializzare il controller del Tavolo per la gestione

dell’interfaccia grafica con il giocatore.

30

3.6.15 TavoloController

TavoloController è il controller principale, il cuore di tutta l’applicazione. Questo

classe è adibita al controllo degli eventi generati dall’azione del giocatore sulla

vista principale Tavolo.

La classe contiene infatti tutti gli elementi fondamentali del gioco.

Gli attributi sono:

- dimensioneTavolo : una lista di due valori che rappresenteranno la

larghezza e l’altezza del tavolo

- mazzo : istanza della classe mazzo

- carteScoperte : il numero di carte scoperte sul tavolo

- file : il numero di file di carte sul tavolo

- offset : viene dinamicamente calcolato in base alla dimensione del mazzo,

quindi è 1/5 della larghezza del mazzo scelto

- partita : istanza della classe PartitaSolitario

- regole : il form dove il giocatore può visualizzare la regole del gioco

- tavolo : il form tavolo, quindi la form di gioco

31

- tipologiaMazzo : valore booleano che sarà true o false a seconda del

mazzo scelto dall’utente al momento della scelta

I metodi dichiarati nella classe si dividono in metodi che gestiscono i veri e propri

eventi di click delle picture box che rappresentano le carte e i bottoni

dell’interfaccia e quelli che servono per gestire la logica del gioco e adibiti al

cambiamento, in accordo, dell’interfaccia grafica, richiamando le azioni della

classe partitaSolitario e mazzo.

Il costruttore della classe prenderà come parametro il risultato dell’azione

dell’utente nella scelta del mazzo. Così verranno inizializzati gli elementi del

controller dinamicamente. E’ nel costruttore che calcoliamo le dimensione del

tavolo in base alle immagini che abbiamo del mazzo piacentino e normale.

I metodi implementati in questa classe sono:

- vediCarta_MouseClick: è il gestore dell’evento click sul mazzo in alto a

destra. Questo preleverà una carta dal mazzo con l’apposito metodo

messo a disposizione dalla classe Mazzo e dalla corrispondente carta verrà

calcolata la posizione sul tavolo e verrà creata una apposita CartaTavolo

nella quale verrà caricata l’immagine della corrispondente carta. Inoltre

abiliteremo per ogni nuova carta pescata l’evento sulla pictureBox

corrispondente, selezionaCarta_MouseClick.

La posizione è calcolata in base alla fila di carte e al numero di carte

scoperte dal mazzo.

Inoltre si deve gestire la terminazione delle carte del mazzo. Quando si

cerca di pescare una carta con il metodo del mazzo.prendiCarta(), se non

sono più presenti carte, il metodo alzerà una eccezione. Per cui andremo a

gestire la terminazione del mazzo con una try-catch. Quando il mazzo è

terminato verrà inoltre resa invisibile l’immagine del mazzo.

- selezionaCarta_MouseClick: è il gestore dell’evento click sulle singole

picture box che rappresentano le carte pescate. In questo metodo si

gestirà la logica del gioco. Per ogni carta selezionata verrà utilizzato il

metodo della classe partita.cartaSelezionata() , che inserirà la carta

cliccata all’interno della lista di carte da controllare. Il valore di ritorno ci

determina l’azione da dover eseguire sul tavolo.

Tutte le carte sul tavolo che vengono cliccate verranno evidenziate tramite

l’utilizzo del metodo selezionaCarta().

32

Dopo di che a seconda del valore ritornato dal metodo cartaSelezionata()

con uno switch si agirà:

o se 0 vuol dire che è la prima carta selezionata e non si farà nulla

o se il valore di ritorno è 1, l’utente avrà selezionato due carte e

queste si trovano alla distanza corretta, si deve quindi verificare se è

possibile eliminare una delle due carte, si chiamerà quindi, il metodo

dell’istanza partita.cartaDaEliminare() . A seconda del valore di

ritorno agiremo eliminando la carta più a sinistra oppure mostrando

un messaggio di errore al giocatore.

Nel caso in cui la carta sia eliminata andiamo infine a riorganizzare il

tavolo con il metodo apposito riorganizzaCarte().

o Se il valore di ritorno è 2, vuol dire che le carte selezionate

dall’utente non si trovano nella distanza corretta quindi andremo a

notificarlo all’utente.

o Se il valore di ritorno è -1, vuol dire che la carta deve essere

deselezionata.

- preparaMazzo : ci consente di caricare l’immagine del mazzo in base alla

scelta del giocatore. Alla fine della creazione del mazzo richiesto,

inizializzeremo una istanza di partita per poter iniziare il gioco. Abbiamo

qui sfruttato il polimorfismo. Infatti il costruttore della classe partita

prende come parametro l’oggetto di classe base Mazzo.

- deselezionaCarta e selezionaCarta sono i metodi che evidenziano le

picture box cliccate dall’utente modificandone il bordo

- riorganizzaCarte: è il metodo che viene utilizzato in selezionaCarta_Click,

nel momento in cui viene eliminata una carta da quelle scoperte sul tavolo.

Il metodo si occupa di rimpiazzare, partendo dalla carta che è stata

eliminata, la CartaTavolo con quella successiva, fino a che, al termine della

sostituzione, avremo nelle ultime due posizione delle carte scoperte un

duplicato, si procederà infine estraendo l’ultimo elemento della lista di

carte scoperte e rimuovendo quest’ultimo.

- mostraSuggerimento_Click : questo metodo si occupa di gestire l’evento

click del bottone dei suggerimenti. Il bottone sarà abilitato solo nel

momento in cui il mazzo di carte è terminato. Questo metodo è molto

importante perché decreta anche la vittoria o la sconfitta da parte del

giocatore.

33

Per mostrare il suggerimento al giocatore, il metodo scorre la lista di carte

scoperte in cerca di una coppia di carte che rispetta le regole del gioco. In

tal caso, il numero di suggerimenti viene decrementato dall’apposita

funzione messa a disposizione dall’oggetto partita, e verrà mostrato

all’utente la coppia di carte da poter selezionare per continuare a giocare.

Nel caso in cui non siano più presenti coppie che rispettano i vincoli e il

numero di carte sul tavolo sia maggiore di due, il giocatore avrà perso la

partita.

- ottieniNomeCartaImg : questo metodo è stato utilizzato per restituire il

nome della risorsa immagine relativa alla carta che il giocatore ha pescato.

Questo viene richiamato nel metodo vediCarta_Click ogni volta che il

giocatore pesca una nuova carta dal mazzo.

Qui si sfrutta il polimorfismo, infatti il metodo che viene richiamato,

mazzo.ottieniSemeCarta viene definito all’interno della classe Mazzo e

ridefinito nelle implementazioni dei rispettivi MazzoPiacentino e

MazzoNormale, ma non si va a richiamare il metodo specifico. Si sono

organizzati i nomi delle risorse in maniera organica, in modo che la

corrispondenza tra Carta logica e immagine fosse possibile. Si utilizzano

due switch differenti per le due tipologie di mazzo.

- regoleGioco_Click: è il gestore dell’evento click sul bottone Regole di

gioco, mostrerà all’utente il form regole che viene riempito con una

immagine dove vengono spiegate le regole del gioco con immagini

annesse.

- nuovaPartita_Click: è i gestore dell’evento click sul bottone Nuova Partita,

e deve gestire la riorganizzazione da zero del tavolo, in quanto il giocatore

richiede di azzerare la partita corrente.

Se la lista carteScoperte non è vuota, viene effettuata la Dispose di tutte le

carte scoperte e viene effettuata la pulizia delle varie liste che gestiscono

la logica del gioco, e infine si procede a ripreparare il mazzo, richiamando il

metodo preparaMazzo.

- inizializzaTavolo : il metodo inizializza i gestori di eventi del tavolo da

gioco.

34

3.6.16 Program

Program è il punto di accesso e di avvio dell’applicazione. All’interno del suo

metodo principale, andiamo ad istanziare un oggetto del controller

IniziaPartitaController. Che è il punto di ingresso dell’applicazione dal punto di

vista del giocatore.

35

3.7 Diagramma delle classi

Si mostreranno ora le relazioni presenti tra le varie classi sempre attraverso l’utilizzo

di diagrammi delle classi UML. Si sono tralasciati gli attributi e i metodi della classe

per rendere più snelli i diagrammi.

3.7.1 Diagramma delle classi Mazzo – Carta

Questo schema UML rappresenta come si è deciso di modellare l’entità Mazzo e

Carta e le sue sottoclassi. Si è ragionato pensando l’entità Mazzo da gioco come

composizione di n carte. Da questo punto di partenza sono state realizzate le

specializzazioni dei mazzi da gioco reali cioè quello da poker e quello piacentino. In

particolare si è deciso di evitare di realizzare una specializzazione delle carte (come

per il mazzo) in quanto, le carte assumono un certo tipo di valore perché sono

all’interno dello specifico mazzo. Per cui nel momento in cui si vorrà conoscere il

valore della carta, si dovrà passare per il metodo messo a disposizione dal mazzo

specifico.

Il mazzo è una composizione di carte: questo vuol dire che una volta che l’oggetto

mazzo e le carte sono stati creati, hanno lo stesso ciclo di vita.

36

3.7.2 Diagramma delle classi MVC

Questo diagramma invece vuole mettere in evidenza le relazioni che ci sono tra il

modello, i controller e la vista. Come possiamo vedere, i controller comunicano con

la vista e il modello. La vista comunica con il modello attraverso la classe

CartaTavolo e il modello risulta indipendente rispetto l’implementazione delle altre

classi. Come nel precedente schema abbiamo preferito omettere gli attributi e i

metodi delle classi per rendere lo schema più snello.

3.7.3 Diagramma di sequenza delle classi durante una partita

Nella pagina successiva invece è mostrato il diagramma di sequenza di una partita a

SoSolitario. Ho tralasciato la fase iniziale di settaggio del tavolo e mi sono

concentrata nel mostrare l’interazione del TavoloController con il Modello e la vista.

38

4. Implementazione

Si riporta di seguito il codice dell’applicativo sviluppato.

4.1 Carta.cs

using System; using System.Collections.Generic; using System.Text; namespace SoSolitario { // Classe che ci rappresenta l'oggetto carta public class Carta { // Attributi della carta private int numero; private int seme; // Costruttore della classe carta con numero e seme selezionati public Carta(int num, int s) { // Setto i valori della carta this.NumeroCarta = num; this.SemeCarta = s; } // Costruttore vuoto public Carta() {} // Proprietà numero di carta public int NumeroCarta { get { return this.numero; } set { if(value > 0) numero = value; else throw new Exception("Il numero della carta deve essere maggiore di zero!"); } } // Proprietà seme della carta public int SemeCarta { get { return this.seme; } set { if (value > 0) seme = value; else throw new Exception("Il seme della carta non può essere un valore negativo!"); } } } }

39

4.2 Mazzo.cs

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SoSolitario.Model { // Classe atratta che ci rappresenta il prototipo di mazzo, all'interno implementiamo // i metodi che sono comuni a tutti i mazzi public abstract class Mazzo { // Lista delle carte del mazzo public List<Carta> carte; // Dimensione delle carte del mazzo private int larghezzaCarta; private int altezzaCarta; // Metodo che crea un nuovo mazzo public void nuovoMazzo() { // Instanziamo una lista per il mazzo this.carte = new List<Carta>(); // Creiamo un mazzo for (int i = 1; i <= NumeroCartePerSeme; i++) { for (int j = 1; j <= NumeroSemi; j++) { //Creo una nuova carta Carta c = new Carta(i, j); this.carte.Add(c); } } } //Metodo per prendere una carta public Carta prendiCarta() { if (!mazzoVuoto()) { //Selezioniamo dalla lista il primo elemento Carta scelta = new Carta(); scelta = carte.FirstOrDefault(); carte.Remove(scelta); return scelta; } else throw new Exception("Mazzo vuoto, impossibile selezionare una carta! "); } //Metodo per mescolare le carte public void mescolaMazzo() { //Controlliamo se il mazzo è vuoto, se lo è alziamo un eccezione if (!mazzoVuoto()) { //Algoritmo Knuth-Fisher-Yates Random rand = new Random(); for (int i = this.carte.Count - 1; i > 0; i--)

40

{ int n = rand.Next(i + 1); //Effettuiamo lo swap, selezioniamo le due carte //swapping Carta x = new Carta(); x = this.carte[i]; this.carte[i] = this.carte[n]; this.carte[n] = x; } } } //Metodo per controllare che il mazzo non sia vuoto public bool mazzoVuoto() { return this.carte.Count <= 0 ? true : false; } //Proprietà di larghezza public int Larghezza { get { return this.larghezzaCarta; } set { if (value > 0) this.larghezzaCarta = value; else throw new Exception("La larghezza del mazzo non può essere un valore negativo"); } } //Proprietà di lunghezza public int Altezza { get { return this.altezzaCarta; } set { if (value > 0) this.altezzaCarta = value; else throw new Exception("L'altezza del mazzo non può essere un valore negativo"); } } // Metodo per ottenere il valore della carta public virtual string ottieniValoreCarta(int numeroCarta) { string s = numeroCarta.ToString(); return s; } // Metodo per ottenere il seme della carta public virtual string ottieniSemeCarta(int semeCarta) { string s = semeCarta.ToString(); return s; } // Proprietà da settare nel mazzo specifico // Il numero di carte totali

41

public abstract int NumeroCarteTotale { get; } // Il numero di carte per ogni seme public abstract int NumeroCartePerSeme { get; } // Il numero di semi del mazzo public abstract int NumeroSemi { get; } } }

4.3 MazzoNormale.cs

using System; using System.Collections.Generic; using System.Text; namespace SoSolitario.Model { // Enumerazione che restituisce il valore di stringa delle carte public enum CartaFrancese { Asso, Due, Tre, Quattro, Cinque, Sei, Sette, Otto, Nove, Dieci, Jack, Donna, Re }; // Enumerazione che restituisce il nome del seme public enum SemeFrancese { fiori = 1, cuori = 2, picche = 3, quadri = 4 }; // Classe mazzo piacentine figlio della classe astratta mazzo class MazzoNormale : Mazzo { // Numero semi nel mazzo normale private const int NUMSEMI = 4; // Numero di carte per seme private const int NUMCARTESEME = 13; // Costruttore della classe MazzoNormale public MazzoNormale() { // Inizializza un nuovo mazzo e lo mescola nuovoMazzo(); } // Metodo che ritorna la stringa della carta public override string ottieniValoreCarta(int numeroCarta) { if (numeroCarta <= NUMCARTESEME) { CartaFrancese val; val = (CartaFrancese)numeroCarta; return val.ToString(); } else throw new Exception("Numero della carta non riconosciuto"); }

42

// Metodo che ritorna la stringa della carta public override string ottieniSemeCarta(int semeCarta) { if (semeCarta <= NUMSEMI) { SemeFrancese s; s = (SemeFrancese)semeCarta; return s.ToString(); } else throw new Exception("Seme della carta non riconosciuto"); } // Metodo che restituisce il numero di carte totali public override int NumeroCarteTotale { get { return NUMCARTESEME * NUMSEMI; } } // Metodo che restituisce il numero di carte totali public override int NumeroCartePerSeme { get { return NUMCARTESEME; } } // Metodo che restituisce il numero di carte totali public override int NumeroSemi { get { return NUMSEMI; } } } }

4.4 MazzoPiacentine.cs

using System; using System.Collections.Generic; using System.Text; namespace SoSolitario.Model { // Enumerazione che restituisce il valore di stringa delle carte public enum CartaPiacentine { Asso, Due, Tre, Quattro, Cinque, Sei, Sette, Fante, Cavallo, Re}; // Enumerazione che restituisce il nome del seme public enum SemePiacentine { denari = 1, bastoni = 2, spade = 3, coppe = 4 }; // Classe mazzo piacentine deriva della classe astratta mazzo class MazzoPiacentine : Mazzo { // Numero semi nel mazzo normale sono 4 private const int NUMSEMI = 4; // Numero di carte per seme private const int NUMCARTESEME = 10; // Costruttore della classe MazzoNormale public MazzoPiacentine() {

43

nuovoMazzo(); } // Metodo che ritorna la stringa della carta public override string ottieniValoreCarta(int numeroCarta) { if (numeroCarta <= NUMCARTESEME) { CartaPiacentine val; val = (CartaPiacentine)numeroCarta; return val.ToString(); } else throw new Exception("Numero della carta non riconosciuto"); } // Metodo che ritorna la stringa della carta public override string ottieniSemeCarta(int semeCarta) { if (semeCarta <= NUMSEMI) { SemePiacentine s; s = (SemePiacentine)semeCarta; return s.ToString(); } else throw new Exception("Seme della carta non riconosciuto"); } // Metodo che restituisce il numero di carte totali public override int NumeroCarteTotale { get { return NUMCARTESEME * NUMSEMI; } } // Metodo che restituisce il numero di carte totali public override int NumeroCartePerSeme { get { return NUMCARTESEME; } } // Metodo che restituisce il numero di carte totali public override int NumeroSemi { get { return NUMSEMI; } } } }

44

4.5 PartitaSolitario.cs

using System; using System.Collections.Generic; using System.Text; namespace SoSolitario.Model { // La classe fornisce i metodi per la gestione delle fasi di gioco // e la preparazione del tavolo da gioco del solitario class PartitaSolitario { // Lista carte selezionate dall'utente public List<int> selezionate; // Numero di carte per fila sul tavolo da gioco private int carteFila = 10; // Variabile che tiene traccia dei suggerimenti di cui ha fatto uso l'utente private int suggerimenti = 3; // Proprietà numero carte per fila public int CartePerFila { get { return carteFila; } set { if (value > 0) this.carteFila = value; else throw new Exception("Valore negativo!"); } } // Proprietà che restituisce il numero di suggerimenti public int Suggerimenti { get { return this.suggerimenti; } } // Costruttore della classe PartitaSolitario public PartitaSolitario(Mazzo mazzo) { // Mescoliamo il mazzo di carte mazzo.mescolaMazzo(); // Inizializziamo la lista delle carte da analizzare this.selezionate = new List<int>(); } // Metodo che controlla se le carte selezionate dall'utente rispettano i vincoli di distanza // e restituisce: // -> -1 carta già stata selezionata dall'utente // -> 0 unico elemento nella lista // -> 1 distanza tra la prima e la seconda carta è corretta // -> 2 distanza tra la prima e la seconda carta non è corretta public int cartaSelezionata(int indiceCarta) { // Il valore che ritorniamo int azione;

45

// Controllo che nella lista non sia già stata inserita la carta corrispondente all'indice if (!trovaElementoSelezionato(indiceCarta)) { // Aggiungo l'indice della carta alla lista this.selezionate.Add(indiceCarta); // Se il numero della lista è uguale a due allora controlliamo se la distanza tra le due carte selezionata è corretta if (this.selezionate.Count == 2) { azione = this.distanzaCarteCorretta(this.selezionate[0], this.selezionate[1]) ? 1 : 2; return azione; } return azione = 0; } else return azione = -1; } // Metodo che controlla se le due carte selezionate hanno indice che corrisponde a i e i+2 private bool distanzaCarteCorretta(int ind1, int ind2) { // Se la differenza tra ind1 e ind2 è uguale a più o meno due ritorna true return (Math.Abs(ind1 - ind2) == 2)? true : false; } // Metodo che controlla se le due carte hanno lo stesso numero o seme public bool coppiaCorretta(Carta c1, Carta c2) { return (c1.NumeroCarta == c2.NumeroCarta || c1.SemeCarta == c2.SemeCarta) ? true : false; } // Metodo che restituisce l'indice della carta da eliminare public int cartaDaEliminare(Carta c1, Carta c2, int i1, int i2) { // Se le due carte hanno lo stesso colore o lo stesso seme allora ritorniamo l'indice di i1 o i2 if (coppiaCorretta(c1,c2)) { // Ritorniamo i2 oppure i1 a seconda della grandezza dell'indice return (i1 > i2) ? i2 : i1; } else // Nessuna delle carte può essere eliminata return -1; } // Metodo per settare la dimensione del tavolo in base al mazzo scelto dall'utente // X rappresenta la dimensione di larghezza della carta // Y rappresenta la dimensione di altezza della carta // numeroCarte il numero di carte presenti nel mazzo // offset ci indica di quanto le carte saranno distanziate le une dalle altre public List<int> dimensioneTavolo(int numeroCarte, int X, int Y, int offset) { // Memorizziamo in dimensioni la larghezza e l'altezza del tavolo List<int> dimensioni = new List<int>();

46

// Numero di file che possono essere presenti sul tavolo da gioco double numeroFile = fileMassime(numeroCarte); // Dimensione del tavolo in larghezza int spaziofilaTavolo = ((carteFila)*(X + offset)); int spazioMazzoTavolo = X + 3*offset; int larghezzaTavolo = spaziofilaTavolo + spazioMazzoTavolo ; dimensioni.Add(larghezzaTavolo); // Dimensione del tavolo in altezza int altezzaTavolo = (int)(numeroFile * (Y + 3*offset)); dimensioni.Add(altezzaTavolo); return dimensioni; } // Metodo per restituire il numero di file di carte massime da mostrare public double fileMassime(int numeroCarte) { double numeroFile; double numFileArrontondato; //Calcoliamo il numero di file massime if (numeroCarte > 0) { // Se l'operazione di modulo del num di carte del mazzo con il numero di carte per file // da zero, il numero è divisibile per il numero di file e quindi non necessitiamo di arrotondare if (numeroCarte % carteFila == 0) numeroFile = numeroCarte / carteFila; else numeroFile = (double) numeroCarte / carteFila; // Con la funzione Math.Ceiling andiamo ad ottenere il valore arrotondato in eccesso numFileArrontondato = Math.Ceiling(numeroFile); return numFileArrontondato; } else return numFileArrontondato = -1; } // Metodo che decrementa la variabile suggerimenti public void usaSuggerimento() { // Decremento il numero di suggerimenti this.suggerimenti--; } // Metodo che controlla se all'interno di una lista è presente una carta tramite indice public bool trovaElementoSelezionato(int valore) { // Cerco nella lista se c'è presente la carta tra quelle selezionate foreach (var sel in this.selezionate.FindAll(x => x == valore)) return true; return false; } } }

47

4.6 IniziaPartita.cs

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace SoSolitario.View { public partial class IniziaPartita : Form { public IniziaPartita() { InitializeComponent(); } //Definiamo le proprietà per richiamare gli elementi grafici nel controller public PictureBox Piacentine { get { return this.piacentinePic;} } public PictureBox Normale { get { return this.normaliPic; } } } }

4.7 Tavolo.cs

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using SoSolitario.View; namespace SoSolitario { // Vista del tavolo da gioco public partial class Tavolo : Form { //Creiamo un array di carte del tavolo public List<CartaTavolo> carteScoperte; //Inizializza i componenti del tavolo public Tavolo() { // Inizializzazione lista che mostra le carte scoperte dall'utente this.carteScoperte = new List<CartaTavolo>(); InitializeComponent(); }

48

// Proprietà del tavolo public PictureBox MazzoImg { get { return this.mazzoPic; } } public Button suggerimentoBtn { get { return this.suggerimentiBtn; } } public Button istruzionibtn { get { return this.istruzioniBtn; } } public Button iniziaNuova { get { return this.iniziaNuovaBtn; } } // Metodo che modificano la dimensione del tavolo public void cambiaSize(int larghezza, int altezza) { this.SetClientSizeCore(larghezza, altezza); this.MaximumSize = new Size(larghezza, altezza); } // Metodo che modifica la posizione del mazzo public void cambiaPosizioneMazzo(int x, int y) { this.MazzoImg.Location = new Point(x, y); } } }

4.8 Regole.cs

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms;

namespace SoSolitario.View { public partial class Regole : Form { public Regole() { InitializeComponent(); }

public PictureBox istruzioni { get { return this.istruzioniPic; } } } }

49

4.9 CartaTavolo.cs

using System; using System.Windows.Forms; using System.Drawing; namespace SoSolitario.View { // Questa classe rappresenta la carta che si visualizzerà sull'interfaccia grafica public class CartaTavolo { //Attributi private PictureBox picBox; private Carta c; public CartaTavolo(PictureBox p, Carta carta) { this.picBox = p; this.c = carta; } public PictureBox imgCarta { get { return this.picBox; } set { this.picBox = value; } } public Carta carta { get { return this.c; } set { this.c = value; } } } }

4.10 IniziaPartitaController.cs

using System; using System.Windows.Forms; using System.Drawing; // Libreria esterna using SoSolitario.View; namespace SoSolitario.Control { // Classe controller per l'inizio della partita class InizioPartitaController { // Attributi della classe private IniziaPartita viewIniziale; // Costruttore public InizioPartitaController() { this.viewIniziale = new IniziaPartita(); //Inizializziamo il gestore degli eventi inizializzaEventi(); }

50

// Inizializza eventi del form public void inizializzaEventi() { //Creo gestore evento click this.viewIniziale.Piacentine.MouseClick += new MouseEventHandler(this.piacentine_Click); this.viewIniziale.Normale.MouseClick += new MouseEventHandler(this.normale_Click); } // Metodo che visualizza il primo form di scelta del mazzo public void mostraIniziaPartita() { this.viewIniziale.Piacentine.Image = (Image)Properties.Resources.inizioPiacentine; this.viewIniziale.Normale.Image = (Image)Properties.Resources.inizioNormali; this.viewIniziale.ShowDialog(); } //Metodo dell'evento click sul bottone Piacentine private void piacentine_Click(object sender, EventArgs e) { //Inizializziamo il form che visualizzerà il tavolo TavoloController controller = new TavoloController(true); controller.mostraTavolo(); } //Metodo dell'evento click sul bottone Normale private void normale_Click(object sender, EventArgs e) { //Inizializziamo il form che visualizzerà il tavolo TavoloController controller = new TavoloController(false); controller.mostraTavolo(); } } }

4.11 TavoloController.cs

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Drawing; using System.Windows.Forms; // Librerie esterne using SoSolitario.Model; using SoSolitario.View; namespace SoSolitario.Control { // Controller tra view Tavolo e model Carta-Mazzo-Partita class TavoloController { // Attributi del tavolo

51

private Tavolo tavolo; private Mazzo mazzo; private Regole regole; // Indica che tipo di mazzo è stato scelto dall'utente private bool tipologiaMazzo; // Istanza della partita private PartitaSolitario partita; // Offset distanza tra le carte sul tavolo private int offset; // Numero di file sul tavolo da gioco private int file = 0; // Contatore carte scoperte private int carteScoperte; // Lista che salva la dimensione del tavolo private List<int> dimensioneTavolo; // Costruttore della classe public TavoloController(bool tipologiaMazzo) { // Istanza tavolo this.tavolo = new Tavolo(); // Attributo che ci determinata la tipologia di mazzo scelta dall'utente this.tipologiaMazzo = tipologiaMazzo; // Lista che conterrà le dimensioni del tavolo calcolate dinamicamente in base al mazzo this.dimensioneTavolo = new List<int>(); try { // Settiamo lo sfondo del tavolo da gioco this.tavolo.BackgroundImage = Properties.Resources.sfondo10; // Organizziamo il tavolo preparaMazzo(this.tipologiaMazzo); // Calcolo dell'offset in base alla dimensione della carta decimal offset = this.mazzo.Larghezza / 5; // Setto offset this.offset = (int)Math.Ceiling(offset); // Settiamo la dimensione desiderate del tavolo da gioco dimensioneTavolo = partita.dimensioneTavolo(this.mazzo.carte.Count, this.mazzo.Larghezza, this.mazzo.Altezza, this.offset); // Modifico dimensioni del tavolo this.tavolo.cambiaSize(dimensioneTavolo[0], dimensioneTavolo[1]); // Posizionamento mazzo this.tavolo.cambiaPosizioneMazzo(dimensioneTavolo[0] - mazzo.Larghezza - (2 * this.offset), this.offset); // Metodo che inizializza gli eventi inizializzaTavolo(); }

52

catch (Exception e) { // Liberiamo la memoria dall'immagine di background if (this.tavolo.MazzoImg.Image != null) this.tavolo.MazzoImg.Image.Dispose(); MessageBox.Show("Errore nel caricamento del tavolo! " + e); } } // Metodo per visualizzare il form tavolo public void mostraTavolo() { this.tavolo.ShowDialog(); } // Metodo inizializza eventi del tavolo public void inizializzaTavolo() { // Evento click sul mazzo this.tavolo.MazzoImg.MouseClick += new MouseEventHandler(this.vediCarta_MouseClick); // Evento del bottone suggerimenti this.tavolo.suggerimentoBtn.Click += new EventHandler(this.mostraSuggerimento_Click); // Evento bottone inizia nuova partita this.tavolo.iniziaNuova.Click += new EventHandler(this.nuovaPartita_Click); // Evento bottone regole del gioco this.tavolo.istruzionibtn.Click += new EventHandler(this.regoleGioco_Click); } // Metodo evento nuova partita private void nuovaPartita_Click(object sender, EventArgs e) { // Se il numero di carte scoperte è diverso da zero, effettuiamo una dispose sulle pictureBox if (this.tavolo.carteScoperte.Count != 0) { // Azzeriamo la lista di carte scoperte for (int i = 0; i < carteScoperte; i++) this.tavolo.carteScoperte[i].imgCarta.Dispose(); // Puliamo l'array delle carte scoperte this.tavolo.carteScoperte.Clear(); // Azzeriamo il numero di carte scoperte this.carteScoperte = this.tavolo.carteScoperte.Count; // Organizziamo il tavolo preparaMazzo(this.tipologiaMazzo); // Metodo che rende visibile il mazzo } this.tavolo.MazzoImg.Visible = true; this.tavolo.suggerimentoBtn.Enabled = false; } // Metodo che mostra le regole del gioco private void regoleGioco_Click(object sender, EventArgs e) { // Creo il form regole this.regole = new Regole(); // Riempio la pictureBox con l'immagine delle istruzioni

53

this.regole.istruzioni.Image = (Image)Properties.Resources.Istruzioni; // Regoliamo la dimensione del form alla dimensione dell'immagine this.regole.istruzioni.Size = new Size(Properties.Resources.Istruzioni.Width, Properties.Resources.Istruzioni.Height); this.regole.Size = new Size(Properties.Resources.Istruzioni.Width,Properties.Resources.Istruzioni.Height + this.offset); // Settiamo la dimensione massima del form a quella dell'immagine delle regole di gioco this.regole.MaximumSize = this.regole.Size; this.regole.istruzioni.Visible = true; // Mostriamo il form this.regole.ShowDialog(); } // Gestore evento click sulla pictureBox del mazzo quando il giocatore estrae una carta private void vediCarta_MouseClick(object sender, EventArgs e) { // Creiamo una nuova picture box PictureBox nuovaPic = new PictureBox(); // Inizializzo evento click sulla nuova carta estratta nuovaPic.MouseClick += new MouseEventHandler(this.selezionaCarta_MouseClick); try { // Prendiamo una carta dal mazzo Carta nuova = this.mazzo.prendiCarta(); // Creiamo un elemento cartaTavolo con la pictureBox correlata CartaTavolo c = new CartaTavolo(nuovaPic, nuova); // Aggiungiamo la carta alla lista di carte scoperte sul tavolo this.tavolo.carteScoperte.Add(c); // Calcolo la posizione della picture box int posizioneOrizzontale = this.carteScoperte % this.partita.CartePerFila; // Memorizziamo le coordinate sull'ascissa del punto (per posizionamento pictureBox) int x = (this.mazzo.Larghezza + offset) * posizioneOrizzontale; // n rappresenterà il numero di fila in cui si deve trovare la carta Double n = this.carteScoperte / this.partita.CartePerFila; file = (int)Math.Ceiling(n); // Memorizziamo le coordinate dell'ordinata del punto (per posizionamento pictureBox) int y = (this.mazzo.Altezza + offset) * file; // Ricaviamo il nome del file immagine della carta che ci interessa string nomeFile; // Otteniamo il nome del file immagine a seconda del mazzo che utilizziamo nomeFile = ottieniNomeCartaImg(nuova); // Associamo alla carta l'immagine della carta estratta

54

c.imgCarta.Image = (Image)Properties.Resources.ResourceManager.GetObject(nomeFile); // Settiamo la dimensione della picturebox della carta c.imgCarta.Height = this.mazzo.Altezza; c.imgCarta.Width = this.mazzo.Larghezza; // Settiamo la posizione della carta pescata if (this.carteScoperte == 0) c.imgCarta.Location = new Point(this.offset, this.offset); else c.imgCarta.Location = new Point(x + this.offset, y + this.offset); // Aggiungiamo la carta al tavolo this.tavolo.Controls.Add(c.imgCarta); // Rendo visibile la pictureBox c.imgCarta.Visible = true; // Incremento il numero di carte scoperte this.carteScoperte++; } catch (Exception) { // Funzione che decreta la vincita o meno dell'utente this.tavolo.MazzoImg.Visible = false; // Abilitiamo il tasto dei suggerimenti e settiamone le dimensioni this.tavolo.suggerimentoBtn.Size = new Size(this.mazzo.Larghezza, this.tavolo.suggerimentoBtn.Height); this.tavolo.suggerimentoBtn.Enabled = true; MessageBox.Show("Mazzo terminato!"); } } // Metodo che gestisce l'evento di click sulla carta private void selezionaCarta_MouseClick(object sender, EventArgs e) { // Recuperiamo la pictureBox cliccata dall'utente e il suo indice PictureBox selezionata = (PictureBox)sender; // Recuperiamo a quale elemento corrisponde la pictureBox CartaTavolo cartaSel = this.tavolo.carteScoperte.Find( x => x.imgCarta == selezionata ); // Recuperiamo l'indice della carta selezionata int indice = this.tavolo.carteScoperte.IndexOf(cartaSel); //Questa funzione restituisce: // 0 -> primo elemento selezionato dell'utente // 1 -> secondo elemento selezionato e distanza corretta // 2 -> secondo elemento selezionato ma distanza tra i due non è corretta // -1 -> elemento già selezionato int azione = this.partita.cartaSelezionata(indice); // Rendiamo il bordo della carta 3d selezionaCarta(indice); switch (azione) { case 0: break;

55

case 1: // Recupero indice delle carte selezionate durante il gioco dall'utente int i1 = this.partita.selezionate[0]; int i2 = this.partita.selezionate[1]; // Recupero le carte selezionate Carta c1 = this.tavolo.carteScoperte[i1].carta; Carta c2 = this.tavolo.carteScoperte[i2].carta; //Recuperiamo l'indice della carta da eliminare int cartaDaElim = this.partita.cartaDaEliminare(c1, c2, i1, i2); // Se la variabile cartaDaElim non è un valore negativo, questa conterrà il valore della carta da eliminare if (cartaDaElim >= 0) { // Bordo pictureBox normale deselezionaCarta(this.partita.selezionate[0]); deselezionaCarta(this.partita.selezionate[1]); // Troviamo la carta da eliminare CartaTavolo daEliminare = this.tavolo.carteScoperte[cartaDaElim]; // Sistema le carte sul tavolo da gioco riorganizzaCarte(daEliminare); } else { // Deselezioniamo le carte deselezionaCarta(this.partita.selezionate[0]); deselezionaCarta(this.partita.selezionate[1]); // Messaggio al giocatore MessageBox.Show("Naaaaaaa! Non si può eliminare nessuna carta! ", "Ops!", MessageBoxButtons.OK, MessageBoxIcon.Error); } // Vuota elementi nell'array delle carte da scambiare this.partita.selezionate.Clear(); break; case 2: // Non è possibile eliminare le carte deselezionaCarta(this.partita.selezionate[0]); deselezionaCarta(this.partita.selezionate[1]); // Vuoto elementi lista carte selezionate this.partita.selezionate.Clear(); MessageBox.Show("Ops scelte le carte a distanza non corretta ", "Distanza non corretta", MessageBoxButtons.OK, MessageBoxIcon.Error); break; case -1: // Deseleziono la stessa carta selezionata.BorderStyle = BorderStyle.None;

56

// Puliamo la lista che traccia gli indici delle carte da scambiare this.partita.selezionate.Clear(); break; default: MessageBox.Show("Errore ", "Ops qualcosa non quadra :(", MessageBoxButtons.OK, MessageBoxIcon.Error); break; } } // Metodo per deselezionare la carta tramite indice public void deselezionaCarta(int i) { CartaTavolo c = this.tavolo.carteScoperte[i]; c.imgCarta.BorderStyle = BorderStyle.None; } // Metodo per selezionare la carta tramite indice public void selezionaCarta(int i) { CartaTavolo c = this.tavolo.carteScoperte[i]; c.imgCarta.BorderStyle = BorderStyle.Fixed3D; } // Metodo per rimpiazzare la vecchia immagine con la nuova e riorganizzare le carte sul tavolo public void riorganizzaCarte(CartaTavolo eliminata) { // Salviamo l'indice della carta che vogliamo eliminare int indiceCartaEliminata = this.tavolo.carteScoperte.IndexOf(eliminata); // Per ogni carta a partire dall'indice della carta che vogliamo // eliminare sostituiamo l'immagine e la carta con il contenuto della picture box successiva for (int i = indiceCartaEliminata; i < this.carteScoperte - 1; i++) { // Prendo la carta successiva CartaTavolo carta = this.tavolo.carteScoperte[i + 1]; // Inserisco le informazioni della carta i + 1 in i cancellando le informazioni di i this.tavolo.carteScoperte[i].carta = carta.carta; // Setto il nome dell'immagine da caricare nella picture box a seconda del mazzo string nomeFile = ottieniNomeCartaImg(carta.carta); try { this.tavolo.carteScoperte[i].imgCarta.Image = (Image)Properties.Resources.ResourceManager.GetObject(nomeFile); } catch (Exception) { MessageBox.Show("Problema caricamento immagine"); } }

57

// Dispose dell'ultimo elemento che sarà la copia dell'ultima carta CartaTavolo c = this.tavolo.carteScoperte.LastOrDefault(); c.imgCarta.Dispose(); this.tavolo.carteScoperte.Remove(c); //Decremento il numero di carte scoperte this.carteScoperte--; } // Metodo che ci consente di ottenere il nome del file immagine che rappresenta la carta private string ottieniNomeCartaImg(Carta c) { string nomeRisorsa = ""; string nRis = ""; //Recuperiamo il nome del seme della carta del mazzo string nomeSeme = this.mazzo.ottieniSemeCarta(c.SemeCarta); if (!tipologiaMazzo) { //Associazione in base al nome dei file switch (nomeSeme) { case "fiori": nRis = "c"; break; case "quadri": nRis = "d"; break; case "picche": nRis = "s"; break; case "cuori": nRis = "h"; break; } return nomeRisorsa = nRis + c.NumeroCarta; } else { switch (nomeSeme) { case "denari": nRis = "dp"; break; case "coppe": nRis = "cp"; break; case "bastoni": nRis = "bp"; break; case "spade": nRis = "sp"; break; } return nomeRisorsa = nRis + c.NumeroCarta; } }

58

// Metodo che analizza la lista di carte scoperte in cerca di combinazioni presenti // Se ne trova una viene mostrata all'utente, se non ce ne sono il giocatore ha perso private void mostraSuggerimento_Click(object sender, EventArgs e) { // Imposto a falso la flag suggerimento bool suggerimento = false; // Se l'utente ha a disposizione dei suggerimenti if (this.partita.Suggerimenti != 0) { // Dichiaro le variabili dove salveremo gli indici delle carte interessate int i1; int i2; // Controlliamo in un ciclo for per ogni carta delle carte scoperte se al i+2 c'è almeno un carta // che è possibile eliminare, appena ne viene trovata una, interrompo ciclo for (int i = 0; i < this.carteScoperte - 3 && !suggerimento; i++) { // Se la coppia selezionata rispetta i requisiti del gioco if (this.partita.coppiaCorretta(this.tavolo.carteScoperte[i].carta, this.tavolo.carteScoperte[i + 2].carta)) { // Imposto suggerimento a true per indicare che è stata trovata una coppia suggerimento = true; // Memorizzo gli indici con il quale possibile effettuare lo scambio i1 = i; i2 = i + 2; // Visualizzo momentaneamente all'utente le carte che si possono selezionare selezionaCarta(i1); selezionaCarta(i2); deselezionaCarta(i1); deselezionaCarta(i2); } } // Se la variabile suggerimento è rimasta falsa, vuol dire che non ci sono più combinazioni // disponibili! L'utente ha perso if (!suggerimento && this.carteScoperte != 2) { MessageBox.Show("Non ci sono più combinazioni disponibili, hai perso :( ", "Partita persa", MessageBoxButtons.OK, MessageBoxIcon.Information); // Disabilito button aiuti this.tavolo.suggerimentoBtn.Enabled = false; // Disabilito la selezione delle carte sul tavolo disabilitaEventiCarteScoperte(); } // Se il numero di carte scoperte è uguale a due il giocatore ha vinto else if (!suggerimento && this.carteScoperte == 2)

59

MessageBox.Show("Hai vinto! :)", "Partita vinta", MessageBoxButtons.OK, MessageBoxIcon.Information); else // Decrementiamo il numero di suggerimenti this.partita.usaSuggerimento(); } else { // Controllo se ci sono due solo carte scoperte e se non ci sono suggerimenti l'utente ha vinto if (this.carteScoperte != 2) MessageBox.Show("Hai terminato gli aiuti! Hai perso :(", "Suggerimenti finiti", MessageBoxButtons.OK, MessageBoxIcon.Information); else MessageBox.Show("Hai vinto! :)", "Partita vinta", MessageBoxButtons.OK, MessageBoxIcon.Information); // Disabilito nuovamente il tasto suggerimenti this.tavolo.suggerimentoBtn.Enabled = false; // Disabilito la selezione delle carte sul tavolo disabilitaEventiCarteScoperte(); } } // Metodo che setta il tavolo per iniziare il gioco public void preparaMazzo(bool tipologiaMazzo) { // Se la tipologia è del primo tipo settiamo il mazzo normale if (!tipologiaMazzo) { // Creo istanza mazzo normale this.mazzo = new MazzoNormale(); // Recuperiamo dimensioni delle carte del mazzo this.mazzo.Altezza = (int)Properties.Resources.dietroCarta.Height; this.mazzo.Larghezza = (int)Properties.Resources.dietroCarta.Width; // Settiamo le dimensioni delle carte this.tavolo.MazzoImg.Height = mazzo.Altezza; this.tavolo.MazzoImg.Width = mazzo.Larghezza; // Assegniamo l'immagine alla picturebox del mazzo this.tavolo.MazzoImg.Image = Properties.Resources.dietroCarta; } else { // Creo una istanza del mazzo Piacentine this.mazzo = new MazzoPiacentine(); // Recuperiamo dimensioni delle carte del mazzo this.mazzo.Altezza = (int)Properties.Resources.dietroPiacentine.Height; this.mazzo.Larghezza = (int)Properties.Resources.dietroPiacentine.Width; // Settiamo le dimensioni delle carte

60

this.tavolo.MazzoImg.Height = mazzo.Altezza; this.tavolo.MazzoImg.Width = mazzo.Larghezza; // Assegniamo l'immagine alla picturebox del mazzo this.tavolo.MazzoImg.Image = Properties.Resources.dietroPiacentine; } // Creo un'istanza della partita partita = new PartitaSolitario(this.mazzo); // TEST_2 // Si verificherà le condizioni del software in caso di vittoria // Per questo motivo abbiamo bisogno di un mazzo nuovo, e non mescolato // this.mazzo.nuovoMazzo(); } // Metodo per rimuovere gli event handler nelle carte quando l'utente avrà perso private void disabilitaEventiCarteScoperte() { foreach(var c in this.tavolo.carteScoperte ) { c.imgCarta.MouseClick -= new MouseEventHandler(this.selezionaCarta_MouseClick); } } } }

4.12 Program

using System; using System.Windows.Forms; using SoSolitario.Control; namespace SoSolitario { static class Program { /// <summary> /// Punto di ingresso principale dell'applicazione. /// </summary> [STAThread] static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); //form iniziale InizioPartitaController inipartita = new InizioPartitaController(); //Visualizza il form che consente la scelta tra le due tipologie di mazzo inipartita.mostraIniziaPartita(); } } }

61

5. Test

La fase di testing è essenziale nello sviluppo di un software. E’ piuttosto chiaro

che coprire tutti i casi di test e assicurarsi al cento per cento che un applicativo

sia esatto e privo di errori è impossibile. Possiamo però cercare di individuare

una serie di test che riescano a coprire gran parte dei casi, riuscendo quindi ad

assicurare una certa stabilità del prodotto.

Il gioco sviluppato è stato corretto durante la sua scrittura, e apparentemente

non si sono evidenziati problemi nel suo utilizzo, cerchiamo però di andare a

stanare le possibili problematiche.

5.1 White Box Test

Questa tipologia di test, si basa sulla conoscenza del codice e richiede la

conoscenza del diagramma di flusso che rappresenta le porzioni di codice che si

vogliono testare. Generalmente i test vengono effettuati su tutte le istruzioni del

codice, ma si è preferito concentrarsi su sezioni specifiche del codice visto la fase

di testing e debug che si è effettuata durante la stesura del codice.

In questo caso, si sviluppano dei casi di test specifici per le due principali criticità

del gioco:

- L’eliminazione della carta dal tavolo

- La richiesta da parte dell’utente dei suggerimenti

Infatti, come si può constatare dal diagramma dei casi d’uso, è proprio in queste

due fasi che andiamo incontro a una serie di comportamenti del programma

difficili da testare. Prima tra tutti la vittoria del giocatore e i vari casi in cui il

giocatore selezionerà carte scoperte dal tavolo.

1) White Box test eliminazione della carta dal tavolo:

I due metodi principali, presenti in PartitaSolitario, che consentono l’eliminazione

di una carta sono:

- cartaSelezionata(int indiceCarta)

- cartaDaEliminare(Carta c1, Carta c2, int i1, int i2)

Al suo interno utilizziamo poi:

- distanzaCarteCorretta(int ind1, int ind2)

62

- coppiaCorretta(Carta c1, Carta c2)

Il diagramma di flusso che descrive il funzionamento del metodo

cartaSelezionata(int indice) è molto semplice:

Si noti inoltre che il blocco più interno, è descritto dal metodo

distanzaCoppiaCorretta(), che restituisce true o false a seconda che l’espressione

indice1 – indice2 sia uguale al valore assoluto di 2.

Questo invece è l’altrettanto semplice diagramma di flusso che si occupa di indicare

l’indice della carta da eliminare:

63

Stabiliti i diagrammi di flussi critici, ci interessa poter coprire tutti i rami di questi

diagrammi di flusso per poterci assicurare che il comportamento sia quello

desiderato. Questa tipologia di white box test è chiamata Branch Coverage testing.

Il set di test individuati sono molto semplici e riguardano, per il primo metodo

cartaSelezionata():

1) selezione primo elemento

2) selezione dello stesso elemento

3) selezione di due carte a distanza non corretta

4) selezione di due carte a distanza corretta

Nel secondo diagramma di flusso, possiamo notare che per poter coprire tutti i rami,

dobbiamo anche considerare l’ordine con cui vengono inseriti gli indici nella

funzione. Per cui ci saranno due test sostanzialmente identici ma che percorreranno

i due rami.

Per quanto riguarda il metodo cartaDaEliminare():

5) Seleziono due carte che possono essere eliminate con i1<i2

6) Seleziono due carte che possono essere eliminate con i2<i1

7) Seleziono due carte che non possono essere eliminate

Per questa tipologia di test, abbiamo creato un applicativo Console, che è incluso nei

file di progetto, al quale viene aggiungo il riferimento del modello dell’applicativo

SoSolitario e vengono testate le principali funzioni della classe PartitaSolitario.cs.

Dai risultati dei test ottenuti, visibili nell’immagine alla pagina successiva, si può

notare che non ci sono comportamenti anomali e che sono stati coperti i principali

rami dei diagrammi di flusso.

64

Il risultato dei test è:

65

Implementazione

using System; using System.Collections.Generic; using System.Text; // Inclusione classe esterna using SoSolitario.Model; using SoSolitario; namespace Test1 { class Program { static void Main(string[] args) { Test_1 t = new Test_1(); // Test il caso in cui viene selezionato il primo elemento t.testaPartita(1); // Test il caso in cui viene selezionato lo stesso elemento t.testaPartita(2); // Test il caso in cui vengono selezionate due carte t.testaPartita(3); // Test il caso in cui vengono selezionate due carte a distanza non corretta t.testaPartita(4); // Test l'eliminazione di una carta se il seme è corretto t.testaPartita(5); // Test distanza delle carte corretta stesso seme di carte t.testaPartita(6); // Test distanza delle carte corretta ma nome del seme diverso t.testaPartita(7); while (true) ; } class Test_1 { // Del metodo messo a disposizione dal controlle per l'eliminazione della carta // vogliamo coprire tutte le possibili condizioni delllo switch che indica // l'azione che si dovrà compiere nell'interfaccia grafica Mazzo m; PartitaSolitario p; // Classe test public Test_1() { // Inizializzo m = new MazzoNormale(); p = new PartitaSolitario(m); } // Metodo utilizzato per implementare i vari test public void testaPartita(int caso) { int risultato;

66

int azione; Carta c1 ; Carta c2; switch (caso) { case 1: Console.WriteLine("********* Test 1 *******************************************"); Console.WriteLine("Seleziono la prima carta e la inserisco nell'oggetto partita"); Console.WriteLine("************************************************************\r\n"); // Copriamo il primo caso in cui si ha la selezione di una nuova carta, azione dovrebbe contenere valore zero azione = p.cartaSelezionata(0); Console.WriteLine("Il metodo partita.cartaSelezionata ritorna : " + azione ); p.selezionate.Clear(); break; case 2: Console.WriteLine("\r\n********* Test 2 *************************************"); Console.WriteLine("Seleziono due volte la stessa carta (Seleziona-Deseleziona)"); Console.WriteLine("**********************************************************\r\n"); // Copriamo il secondo caso in cui la carta è già stata selezionata, azione dovrebbe contenere valore -1 azione = inserisciDueIndici(1, 1); Console.WriteLine("Il metodo partita.cartaSelezionata ritorna : " + azione); // Puliamo lista p.selezionate.Clear(); break; case 3: Console.WriteLine("\r\n********* Test 3 ***************"); Console.WriteLine("Seleziono due carte con indici 1 e 4"); Console.WriteLine("************************************\r\n"); // Indici carte selezionate sono diverse ma distanza scorretta 2 azione = inserisciDueIndici(1, 4); Console.WriteLine("Il metodo partita.cartaSelezionata ritorna : " + azione); p.selezionate.Clear(); break; case 4: Console.WriteLine("\r\n********* Test 4 ***************"); Console.WriteLine("Seleziono due carte con indici 1 e 3"); Console.WriteLine("************************************\r\n"); // Indici carte selezionate a distanza corretta azione = inserisciDueIndici(1, 3); Console.WriteLine("Il metodo partita.cartaSelezionata ritorna : " + azione); p.selezionate.Clear(); break; case 5: Console.WriteLine("\r\n********* Test 5 *****************"); Console.WriteLine("Seleziono due carte con indici i1 < i2"); Console.WriteLine("**************************************\r\n"); // Distanza delle carte corretta stesso seme di carte selezione dell'indice minore c1 = new Carta(1,2); c2 = new Carta(1,4);

67

Console.WriteLine("i1 => "+1+" i2 => "+3+" \r\n"); risultato = p.cartaDaEliminare(c1, c2, 1, 3); Console.WriteLine("Il metodo partita.cartaDaEliminare ritorna l'indice " + risultato); break; case 6: Console.WriteLine("\r\n********* Test 6 **********************************"); Console.WriteLine("Seleziono due carte con stesso numero di carta i2 < i1"); Console.WriteLine("*******************************************************\r\n"); // Distanza delle carte corretta stesso seme di carte selezione dell'indice minore c1 = new Carta(1,2); c2 = new Carta(1,4); Console.WriteLine("i1 =>" + 10 + " i2 => " + 5+ " \r\n"); risultato = p.cartaDaEliminare(c1, c2, 10, 5); Console.WriteLine("Il metodo partita.cartaDaEliminare ritorna l'indice " + risultato); break; case 7: Console.WriteLine("\r\n********* Test 7 ********************************"); Console.WriteLine(" Seleziono due carte che non possono essere eliminate"); Console.WriteLine("*****************************************************\r\n"); // Distanza delle carte corretta, carte diverse c1 = new Carta(1, 3); c2 = new Carta(3, 4); Console.WriteLine("Indice 1° carta selezionata : " + 3 + " indice 2° carta selezionata : " + 1); // Valore della carta c1 Console.WriteLine(" 1° carta selezionata: " + m.ottieniValoreCarta(c1.NumeroCarta) + " " + m.ottieniSemeCarta(c1.SemeCarta)); // Valore della carta c2 Console.WriteLine(" 2° carta selezionata: " + m.ottieniValoreCarta(c2.NumeroCarta) + " " + m.ottieniSemeCarta(c2.SemeCarta)); risultato = p.cartaDaEliminare(c1, c2, 1, 3); Console.WriteLine("Carte da eliminare ha indice :" + risultato); break; } } // Inserimento di due indici all'interno dell'oggetto partita public int inserisciDueIndici(int i, int j) { int azione = p.cartaSelezionata(i); azione = p.cartaSelezionata(j); return azione; } } } }

68

2) White Box test Suggerimenti e vittoria

Il secondo tipo di test riguarda la porzione di codice che gestisce la richiesta di

suggerimenti da parte del giocatore. Per poter testare tutti i percorsi possibili nel

caso d’uso #8, abbiamo bisogno di conoscere il codice; infatti, per poter testare

anche il funzionamento del programma nel caso di vittoria, dobbiamo creare un

mazzo ad hoc, che ci consente di vincere la partita e infine testare il comportamento

del programma.

La vittoria della partita si raggiunge nel momento in cui si hanno solo due carte in

tavolo, a quel punto il giocatore può richiedere un aiuto, e gli verrà notificata la

vittoria della partita.

Andiamo a creare una combinazione di carte speciale che ci dia la possibilità di

ottenere la vittoria e andare a testare questa condizione.

Come nel test dell’eliminazione della carta, si vogliono coprire tutti i rami della

porzione di codice Branch covering test.

Il mazzo “speciale” che ci consente sicuramente la vittoria è quel mazzo che non

viene mischiato. Infatti andando a richiamare il metodo nuovoMazzo(), si avranno i

primi 4 Assi, 4 due ecc è possibile quindi eliminare le carte e far rimanere in tavola

solo due carte.

Per ottenere ciò abbiamo aggiunto al codice, nel metodo preparaMazzo():

69

Dopo di che per testare il comportamento, si è avviato il gioco e si è vinto la partita:

Però il comportamento dell’applicativo rileva un’anomalia. Infatti viene mostrato a

video il messaggio di partita persa e poi di partita vinta.

Il test non ha rispettato l’esito aspettato. Dal codice si può constatare, che veniva

controllato il valore booleano del suggerimento e poi il numero di carte presenti sul

tavolo.

70

Il bug rilevato è il seguente:

E’ stato corretto nel seguente modo:

Dopo la correzione l’esito dell’applicativo è stato quello desiderato.

71

5.2 Black box Test

Questa seconda tipologia di test si basa sull’utilizzo dell’applicativo, e va quindi ad

analizzare le specifiche funzionali dell’applicativo stesso. Questo tipo di testing è

maggiormente sfruttato nella fase finale dello sviluppo software, per poter

evidenziare questi problemi:

Errori nella GUI

Errori nella performance

Errori di terminazione o crash

Valutazione Casi d’uso

Errori nella GUI

Un errore evidenziato nella fase finale di test della GUI dava una posizione della

carta del mazzo, nel caso del mazzo normale, stranamente scorretta rispetto a

quella del mazzo di carte piacentine che era corretta.

Il bug è stato individuato, infatti nel codice si andava a posizionare il mazzo prima di

aggiustare le dimensioni del tavolo. Ridimensionando il tavolo prima di posizionare il

mazzo il problema è stato risolto.

Bug individuato:

// Posizionamento mazzo this.tavolo.cambiaPosizioneMazzo(dimensioneTavolo[0] - mazzo.Larghezza - (2*this.offset), this.offset); // Modifico dimensioni del tavolo this.tavolo.cambiaSize(dimensioneTavolo[0], dimensioneTavolo[1]);

Ecco le due visualizzazione dopo la correzione e prima:

72

Errori di terminazioni o crash

Non sono stati individuati terminazioni o crash inattesi durante le fasi di gioco.

Valutazione Casi d’uso

Andremo ora a mostrare se i casi d’uso considerati rispecchiano le funzionalità

dell’applicativo.

Pre-condizione #1 e #2 Inizia una nuova partita scelta del mazzo piacentino o

normale, che è anche il punto di partenza per il giocatore:

73

Post condizione caso d’uso #1 Visualizza tavolo da gioco con il mazzo piacentino:

Post condizione caso d’uso #2 Visualizza tavolo da gioco con il mazzo normale:

74

#3 Scoprire una carta dal mazzo

#4 Selezionare una carta scoperta sul tavolo

N.B. Non è ben visibile ma il tre di bastoni è stato marcato dopo il click sulla carta.

75

#5 Deselezionare una carta scoperta sul tavolo

#6 Selezionare due carte scoperte e eliminare una di queste

76

#6.1 Selezione delle carte a distanza non corretta

#6.2 Selezione di due carte a distanza corretta ma carte errate

77

#7 Visualizzare le regole del gioco

Dopo il click sul tavolo da gioco del tasto “Regole del gioco”

78

#8 Inizia una nuova partita

Il click sul tasto “Nuova Partita” comporta la pulizia del tavolo dalle carte da gioco e

l’inizio di una nuova partita.

#9 Chiedere un suggerimento

Con li click dell’utente sul tasto aiuto, si può vedere che il 3 di picche e il 3 di cuore

sono evidenziati, è il primo suggerimento ottenuto:

79

#9.1 Suggerimenti non finiti ma non ci sono più combinazioni

#9.2 Suggerimenti finiti ma ci sono ancora combinazioni

80

#9.3 Rimangono solo due carte la partita è vinta

81

6.Compilazione ed esecuzione

L’ambiente di sviluppo utilizzato è Visual Studio 2010 Express - framework .NET 4.0.

Sarà possibile compilare il gioco seguendo queste istruzioni:

- Estrarre la cartella SoSolitario dal file .rar SoSolitario.rar

- Doppio click sul file con estensione .sln (Microsoft Visual Studio Solution )

ed attendere il caricamento del progetto

- Cliccare sul menù a tendina Compila -> Compila soluzione

Dopo aver terminato la compilazione sarà possibile eseguire l’applicativo

raggiungendo il file eseguibile navigando nel percorso:

- Navigare in SoSolitario/bin/Release

- Doppio click sull’eseguibile SoSolitario.exe

L’applicativo è eseguibile in sistemi Windows con framework .NET 4.0 o superiore.

In particolare il software è stato eseguito e collaudato sulle seguenti macchine con

hardware e software differenti:

Sistema Operativo RAM CORE Architettura

Windows 7 6 Gb 2 core 64 bit

Windows 7 4 Gb 4 core 64 bit

Windows 8.1 2 Gb 2 core 32 bit

Windows 8.1 8 Gb 4 core 64 bit

sosolitario - sti.uniurb.it · precondizioni il giocatore deve aver terminato il mazzo da gioco...

Documents