doc/DP/DP_Core.tex

   1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   2 %%%  DP - Componente Core  %%%
   3 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   4
   5 \subsection{Classe Point}
   6 \subsubsection*{Descrizione generale}
   7 Le istanze di questa classe rappresentano una posizione all'interno della \uline{matrice di gioco}.
   8 \medskip
   9
  10 \subsubsection*{\large{Attributi}}
  11 \smallskip
  12
  13 \subsubsection{\_x}
  14 \texttt{private int \_x}
  15 \begin{itemize}
  16         \item Valore della coordinata x.
  17         \item Costruzione: inizializzato nel costruttore della classe.
  18 \end{itemize}
  19 \smallskip
  20
  21 \subsubsection{\_y}
  22 \texttt{private int \_y}
  23 \begin{itemize}
  24         \item Valore della coordinata y.
  25         \item Costruzione: inizializzato nel costruttore della classe.
  26 \end{itemize}
  27 \smallskip
  28
  29 \subsubsection{\_z}
  30 \texttt{private int \_z}
  31 \begin{itemize}
  32         \item Valore della coordinata z.
  33         \item Costruzione: inizializzato nel costruttore della classe.
  34 \end{itemize}
  35
  36 \medskip
  37
  38 \subsubsection*{Operazioni}
  39 \smallskip
  40
  41 \subsubsection{Point()}
  42 \texttt{public Point() [constructor]}
  43 \begin{itemize}
  44         \item Comportamento: inizializza i campi \texttt{\_x}, \texttt{\_y} e \texttt{\_z} con il valore -1.
  45 \end{itemize}
  46 \smallskip
  47
  48 \subsubsection{Point(int, int, int)}
  49 \texttt{public Point(int x, int y, int z) [constructor]}
  50 \begin{itemize}
  51         \item Comportamento: inizializza il campo \texttt{\_x} con \texttt{x}, \texttt{\_y} con \texttt{y} e \texttt{\_z} con \texttt{z}.
  52 \end{itemize}
  53 \smallskip
  54
  55 \subsubsection{x}
  56 \texttt{public int x() [const]}
  57 \begin{itemize}
  58         \item Comportamento: ritorna il valore contenuto nel campo \texttt{\_x}.
  59 \end{itemize}
  60 \smallskip
  61
  62 \subsubsection{y}
  63 \texttt{public int y() [const]}
  64 \begin{itemize}
  65         \item Comportamento: ritorna il valore contenuto nel campo \texttt{\_y}.
  66 \end{itemize}
  67 \smallskip
  68
  69 \subsubsection{z}
  70 \texttt{public int z() [const]}
  71 \begin{itemize}
  72         \item Comportamento: ritorna il valore contenuto nel campo \texttt{\_z}.
  73 \end{itemize}
  74 \smallskip
  75
  76 \subsubsection{isValid}
  77 \texttt{public bool isValid() [const]}
  78 \begin{itemize}
  79         \item Comportamento: ritorna \texttt{true} se e solo se \texttt{\_x}, \texttt{\_y} e \texttt{\_z} appartengono all'intervallo $[0,$ \verb!GameMatrix::instance()->d1() *! \\\verb!GameMatrix::instance()->d2() - 1]!
  80 \end{itemize}
  81 \smallskip
  82
  83 \subsubsection{isNull}
  84 \texttt{public bool isNull() [const]}
  85 \begin{itemize}
  86         \item Comportamento: ritorna \texttt{true} se e solo se \texttt{\_x}, \texttt{\_y} e \texttt{\_z} hanno tutti valore -1.
  87 \end{itemize}
  88 \smallskip
  89
  90 \subsubsection{operator==}
  91 \texttt{public bool operator==(const Point \&p) [const]}
  92 \begin{itemize}
  93         \item Comportamento: ritorna \texttt{true} se e solo se tutti i campi dati di \texttt{this} e \texttt{p} hanno lo stesso valore.
  94 \end{itemize}
  95 \smallskip
  96
  97 \subsubsection{operator!=}
  98 \texttt{public bool operator!=(const Point \&p) [const]}
  99 \begin{itemize}
 100         \item Comportamento: \texttt{return !(this == p)}.
 101 \end{itemize}
 102 \smallskip
 103
 104 \subsubsection{operator$<$}
 105 \texttt{public bool operator<(const Point \&p) [const]}
 106 \begin{itemize}
 107         \item Comportamento: ritorna \texttt{true} se è vero uno dei seguenti casi:
 108         \begin{itemize}
 109                 \item \verb!_x < p._x!
 110                 \item \verb!_x == p._x && _y < p._y!
 111                 \item \verb!_x == p._x && _y == p._y && _z < p._z!
 112         \end{itemize}
 113 \end{itemize}
 114 \smallskip
 115
 116 \subsubsection{operator bool}
 117 \texttt{public operator bool() [const]}
 118 \begin{itemize}
 119         \item Comportamento: \verb!return isValid()!
 120 \end{itemize}
 121
 122 \medskip
 123
 124 \subsection{Classe Move}
 125
 126 \subsubsection*{Descrizione generale}
 127 Le istanze di questa classe rappresentano una posizione e l'identificatore del giocatore che occupa tale posizione all'interno della \uline{matrice di gioco}.
 128
 129 \medskip
 130
 131 \subsubsection*{\large{Attributi}}
 132 \smallskip
 133
 134 \subsubsection{\_playerId}
 135 \texttt{private int \_playerId}
 136 \begin{itemize}
 137         \item \`E l'identificatore associato a un giocatore.
 138         \item Costruzione: inizializzato nel costruttore della classe.
 139 \end{itemize}
 140 \smallskip
 141
 142 \subsubsection{\_coord}
 143 \texttt{private Point \_coord}
 144 \begin{itemize}
 145         \item \`E una posizione nella \uline{matrice di gioco}.
 146         \item Costruzione: inizializzato nel costruttore della classe.
 147 \end{itemize}
 148
 149 \medskip
 150
 151 \subsubsection*{\large{Operazioni}}
 152 \smallskip
 153
 154 \subsubsection{Move}
 155 \texttt{public Move(int id, Point p) [constructor]}
 156 \begin{itemize}
 157         \item Comportamento: inizializza il campo \texttt{\_playerId} con \texttt{id} e \texttt{\_coord} con \texttt{p}.
 158 \end{itemize}
 159 \smallskip
 160
 161 \subsubsection{isValid}
 162 \texttt{public bool isValid() [const]}
 163 \begin{itemize}
 164         \item Parametri e precondizioni: un'istanza del \textit{``singleton''} \texttt{GameMatrix} è stata allocata.
 165         \item Comportamento: ritorna \texttt{true} se sono valide tutte le seguenti condizioni:
 166         \begin{itemize}
 167                 \item \texttt{\_playerId} appartiene all'intervallo $[0,$ \\\verb!GameMatrix::instance()->numberOfPlayers()!$ - 1]$.
 168                 \item \verb!_coord.isValid()! ritorna \texttt{true}.
 169         \end{itemize}
 170 \end{itemize}
 171 \smallskip
 172
 173 \subsubsection{point}
 174 \texttt{public Point point() [const]}
 175 \begin{itemize}
 176         \item Comportamento: \verb!return _coord!.
 177 \end{itemize}
 178 \smallskip
 179
 180 \subsubsection{playerId}
 181 \texttt{public int playerId() [const]}
 182 \begin{itemize}
 183         \item Comportamento: \verb!return _playerId!.
 184 \end{itemize}
 185
 186 \medskip
 187
 188 \subsection{Classe Player}
 189
 190 \subsubsection*{Descrizione generale}
 191 Classe astratta che rappresenta un giocatore.
 192
 193 \medskip
 194
 195 \subsubsection*{\large{Attributi}}
 196 \smallskip
 197
 198 \subsubsection{\_id}
 199 \texttt{private int \_id}
 200 \begin{itemize}
 201         \item Identifica in modo univoco un giocatore nel corso di una partita.
 202         \item Costruzione: inizializzato nel costruttore della classe.
 203 \end{itemize}
 204
 205 \medskip
 206
 207 \subsubsection*{\large{Operazioni}}
 208 \smallskip
 209
 210 \subsubsection{Player}
 211 \texttt{public Player(int id) [constructor]}
 212 \begin{itemize}
 213         \item Parametri e precondizioni: \texttt{id} compreso nell'intervallo $[0,2]$.
 214         \item Comportamento: assegna al campo \texttt{\_id} il valore di \texttt{id}.
 215 \end{itemize}
 216 \smallskip
 217
 218 \subsubsection{\~{}Player}
 219 \texttt{public \~{}Player() [destructor, virtual]}
 220 \begin{itemize}
 221         \item Comportamento: corpo vuoto.
 222 \end{itemize}
 223 \smallskip
 224
 225 \subsubsection{id}
 226 \texttt{public int id() [const]}
 227 \begin{itemize}
 228         \item Comportamento: ritorna il valore del campo \texttt{\_id}.
 229 \end{itemize}
 230 \smallskip
 231
 232 \subsubsection{move}
 233 \texttt{public Move move()}
 234 \begin{itemize}
 235         \item Comportamento:
 236         \begin{itemize}
 237                 \item invoca il metodo \texttt{lock()} sul \textit{``singleton''} \texttt{SyncSharedCondition}.
 238                 \item invoca il metodo \texttt{doMove()} e assegna il valore di ritorno a una variabile ausiliaria \texttt{point}.
 239                 \item invoca il metodo \texttt{unlock()} sul \textit{``singleton''} \texttt{SyncSharedCondition}.
 240                 \item \verb!return Move(_id, point)!.
 241         \end{itemize}
 242         \item Note: \textit{``template method''}.
 243 \end{itemize}
 244 \smallskip
 245
 246 \subsubsection{doMove}
 247 \texttt{protected Point doMove() [abstract, const]}
 248 \begin{itemize}
 249         \item Note: le classi derivate devono implementare questo metodo che viene invocato dal \textit{``template method''} \texttt{move()}.
 250 \end{itemize}
 251
 252 \medskip
 253
 254 \subsection{Classe HumanPlayer}
 255
 256 \subsubsection*{Descrizione generale}
 257 Deriva e concretizza la classe astratta \texttt{Player} e rappresenta un \uline{giocatore umano}.
 258
 259 \medskip
 260
 261 \subsubsection*{\large{Attributi}}
 262 \smallskip
 263
 264 \subsubsection{\_render}
 265 \texttt{private RenderWidget *\_render}
 266 \begin{itemize}
 267         \item Punta alla \textit{widget} che il \uline{giocatore umano} usa per interagire con l'applicazione quando effettua una mossa.
 268         \item Costruzione: inizializzato nel costruttore della classe.
 269         \item Distruzione: il distruttore della classe non deve deallocare l'oggetto puntato da questo campo.
 270 \end{itemize}
 271
 272 \medskip
 273
 274 \subsubsection*{\large{Operazioni}}
 275 \smallskip
 276
 277 \subsubsection{HumanPlayer}
 278 \texttt{public HumanPlayer(int id, RenderWidget *render) [constructor]}
 279 \begin{itemize}
 280         \item Parametri e precondizioni: \texttt{id} compreso nell'intervallo $[0,2]$, \texttt{render} non deve essere un puntatore nullo.
 281         \item Comportamento: invoca il costruttore della classe base passandogli come parametro \texttt{id} e assegna al campo \texttt{\_render} il valore di \texttt{render}.
 282 \end{itemize}
 283 \smallskip
 284
 285 \subsubsection{\~{}HumanPlayer}
 286 \texttt{public \~{}HumanPlayer() [destructor, virtual]}
 287 \begin{itemize}
 288         \item Comportamento: corpo vuoto.
 289 \end{itemize}
 290 \smallskip
 291
 292 \subsubsection{doMove}
 293 \texttt{protected Point doMove() [const, virtual]}
 294 \begin{itemize}
 295         \item Comportamento: vedere Figura~\ref{fig:HP_doMove}.
 296         \item Valore ritornato e sua semantica: ritorna un \texttt{Point} valido.
 297 \end{itemize}
 298
 299 \medskip
 300
 301 \subsection{Classe RemotePlayer}
 302
 303 \subsubsection*{Descrizione generale}
 304 Deriva e concretizza la classe astratta \texttt{Player} e rappresenta un giocatore remoto.
 305
 306 \medskip
 307
 308 \subsubsection*{\large{Attributi}}
 309 \smallskip
 310
 311 \subsubsection{\_net}
 312 \texttt{private Network *\_net}
 313 \begin{itemize}
 314         \item Serve alla classe per richiedere allo strato di rete la mossa eseguita remotamente da un altro giocatore.
 315         \item Costruzione: viene inizializzato nel costruttore della classe.
 316         \item Distruzione: l'oggetto \texttt{Network} puntato non deve essere deallocato dal distruttore della classe.
 317 \end{itemize}
 318
 319 \medskip
 320
 321 \subsubsection*{\large{Operazioni}}
 322 \smallskip
 323
 324 \subsubsection{RemotePlayer}
 325 \texttt{public RemotePlayer(int id, Network *net) [constructor]}
 326 \begin{itemize}
 327         \item Parametri e precondizioni: \texttt{id} compreso nell'intervallo $[0,2]$, \texttt{net} non deve essere un puntatore nullo.
 328         \item Comportamento: invoca il costruttore della classe base passandogli come parametro \texttt{id} e assegna al campo \texttt{\_net} il valore di \texttt{net}.
 329 \end{itemize}
 330 \smallskip
 331
 332 \subsubsection{\~{}RemotePlayer}
 333 \texttt{public \~{}RemotePlayer() [destructor, virtual]}
 334 \begin{itemize}
 335         \item Comportamento: corpo vuoto.
 336 \end{itemize}
 337 \smallskip
 338
 339 \subsubsection{doMove}
 340 \texttt{protected Point doMove() [const, virtual]}
 341 \begin{itemize}
 342         \item Comportamento: vedere Figura~\ref{fig:RP_doMove}.
 343 \end{itemize}
 344
 345 \medskip
 346
 347 \subsection{Classe AIPlayer}
 348
 349 \subsubsection*{Descrizione generale}
 350 Deriva e concretizza la classe astratta \texttt{Player} e rappresenta un \uline{giocatore artificiale}.
 351
 352 \medskip
 353
 354 \subsubsection*{\large{Attributi}}
 355 \smallskip
 356
 357 \subsubsection{\_DefaultSkill}
 358 \texttt{private int \_DefaultSkill [const, static]}
 359 \begin{itemize}
 360         \item Usato per avere un valore di \textit{default} per \texttt{\_skill}.
 361         \item Costruzione: inizializzato a 2.
 362 \end{itemize}
 363 \smallskip
 364
 365 \subsubsection{\_skill}
 366 \texttt{private int \_skill}
 367 \begin{itemize}
 368         \item Rappresenta il livello di abilità dell'\uline{AI}, a un valore di \texttt{\_skill} maggiore corrisponde una abilità maggiore dell'\uline{AI}.
 369         \item Creazione: inizializzato nel costruttore della classe.
 370 \end{itemize}
 371 \smallskip
 372
 373 \subsubsection{\_ai}
 374 \texttt{private AI *\_ai}
 375 \begin{itemize}
 376         \item Puntatore all'\texttt{AI} utilizzata dal \uline{giocatore artificiale}.
 377         \item Costruzione: inizializzato nel costruttore della classe.
 378         \item Distruzione: il distruttore della classe deve occuparsi di deallocare l'oggetto puntato da questo campo.
 379 \end{itemize}
 380
 381 \medskip
 382
 383 \subsubsection*{\large{Operazioni}}
 384 \smallskip
 385
 386 \subsubsection{AIPlayer}
 387 \texttt{public AIPlayer(int id) [constructor]}
 388 \begin{itemize}
 389         \item \texttt{id} compreso nell'intervallo $[0,2]$.
 390         \item Comportamento:
 391         \begin{itemize}
 392                 \item invoca il costruttore della classe base passando il parametro \texttt{id}.
 393                 \item inizializza il campo \texttt{\_skill} con la costante \texttt{\_DefaultSkill}.
 394                 \item se l'impostazione di \uline{difficoltà II} è uguale a 3 inizializza \texttt{\_ai} con il valore ritornato dalla chiamata \verb!new CCThreatSearchAI(id)! altrimenti con quello di \verb!new ThreatSearchAI(id)!.
 395         \end{itemize}
 396 \end{itemize}
 397 \smallskip
 398
 399 \subsubsection{\~{}AIPlayer}
 400 \texttt{public \~{}AIPlayer() [destructor, virtual]}
 401 \begin{itemize}
 402         \item Comportamento: dealloca l'oggetto puntato da \texttt{\_ai}.
 403 \end{itemize}
 404 \smallskip
 405
 406 \subsubsection{doMove}
 407 \texttt{protected Point doMove() [const, virtual]}
 408 \begin{itemize}
 409         \item Comportamento: vedere Figura~\ref{fig:AP_doMove}.
 410         \item Valore ritornato e sua semantica: ritorna un \texttt{Point} valido.
 411 \end{itemize}
 412 \smallskip
 413
 414 \subsubsection{forceMove}
 415 \texttt{public void forceMove() [virtual]}
 416 \begin{itemize}
 417         \item Comportamento: effettua la chiamata \verb!_ai->forceMove()! e ritorna.
 418 \end{itemize}
 419 \smallskip
 420
 421 \subsubsection{skill}
 422 \texttt{public int skill() [const]}
 423 \begin{itemize}
 424         \item Comportamento: ritorna il valore di \texttt{\_skill}.
 425 \end{itemize}
 426 \smallskip
 427
 428 \subsubsection{setSkill}
 429 \texttt{public void setSkill(int skill)}
 430 \begin{itemize}
 431         \item Comportamento: imposta il valore del campo \texttt{\_skill} al valore \texttt{skill}.
 432 \end{itemize}
 433 \smallskip
 434
 435 \subsubsection{undoMove}
 436 \texttt{public void undoMove() [slot]}
 437 \begin{itemize}
 438         \item Comportamento: \verb!_ai->movesUndone()!.
 439 \end{itemize}
 440
 441 \medskip
 442
 443 \subsection{Classe GameMatrix}
 444
 445 \subsubsection*{Descrizione generale}
 446 Mantiene diverse informazioni sullo stato della \uline{matrice di gioco}.
 447 Classe progettata secondo il pattern \textit{``singleton''}.
 448 \\\verb!friend class ThreatSearchAI!
 449 \\\verb!friend class CCThreatSearchAI!
 450 \\\verb!friend class Threat!
 451 \\\verb!friend class CCThreat!
 452
 453 \medskip
 454
 455 \subsubsection*{\large{Attributi}}
 456 \smallskip
 457
 458 \subsubsection{EmptyPoint}
 459 \texttt{public int EmptyPoint [const static]}
 460 \begin{itemize}
 461         \item \`E il numero usato internamente da \texttt{GameMatrix} per indicare le posizioni vuote della \uline{matrice di gioco}.
 462         \item Costruzione: inizializzato con il valore -1.
 463 \end{itemize}
 464
 465 \subsubsection{\_instance}
 466 \texttt{private GameMatrix *\_instance [static]}
 467 \begin{itemize}
 468         \item Puntatore all'eventuale unica istanza della classe.
 469         \item Costruzione: inizializzato con il valore 0.
 470 \end{itemize}
 471 \smallskip
 472
 473 \subsubsection{\_matrix}
 474 \texttt{private int *\_matrix}
 475 \begin{itemize}
 476         \item Puntatore ad un array che rappresenta la \uline{matrice di gioco}.
 477         \item Costruzione: inizializzato nel costruttore della classe.
 478 \end{itemize}
 479 \smallskip
 480
 481 \subsubsection{\_lastRound}
 482 \texttt{private QList<Point> \_lastRound}
 483 \begin{itemize}
 484         \item Contiene le posizioni interessate dall'ultima mossa di ogni giocatore, gli elementi sono in ordine cronologico, quello in posizione 0 è l'elemento inserito più recentemente. Contiene un numero di elementi pari al numero dei giocatori.
 485         \item Costruzione: inizializzazione nel costruttore della classe.
 486 \end{itemize}
 487 \smallskip
 488
 489 \subsubsection{\_d1}
 490 \texttt{private int \_d1}
 491 \begin{itemize}
 492         \item Indica il valore del parametro \uline{difficoltà I} impostato per la partita corrente.
 493         \item Costruzione: inizializzato nel costruttore della classe.
 494 \end{itemize}
 495 \smallskip
 496
 497 \subsubsection{\_d2}
 498 \texttt{private int \_d2}
 499 \begin{itemize}
 500         \item Indica il valore del parametro \uline{difficoltà II} impostato per la partita corrente.
 501         \item Costruzione: inizializzato nel costruttore della classe.
 502 \end{itemize}
 503 \smallskip
 504
 505 \subsubsection{\_freeCounter}
 506 \texttt{private int \_freeCounter}
 507 \begin{itemize}
 508         \item Indica il numero di posizioni libere rimaste nella \uline{matrice di gioco}.
 509         \item Costruzione: inizializzato nel costruttore della classe.
 510 \end{itemize}
 511
 512 \medskip
 513
 514 \subsubsection*{\large{Operazioni}}
 515 \smallskip
 516
 517 \subsubsection{GameMatrix}
 518 \texttt{private GameMatrix(int d1, int d2, int numPlayers) [constructor]}
 519 \begin{itemize}
 520         \item Parametri e precondizioni:
 521         \begin{itemize}
 522                 \item \texttt{d1} appartiene a $\{5, 7, 9\}$
 523                 \item \texttt{d2} appartiene a $[1, 3]$
 524                 \item \texttt{numPlayers} appartiene a $[0, 2]$
 525         \end{itemize}
 526         \item Comportamento:
 527         \begin{itemize}
 528                 \item assegna \texttt{d1} a \texttt{\_d1} e \texttt{d2} a \texttt{\_d2}.
 529                 \item inizializza \texttt{\_lastRound} con \texttt{numPlayers} elementi tutti di valore \texttt{Point()}.
 530                 \item alloca un array di \texttt{int} di dimensione (\texttt{d1}*\texttt{d2})$^3$, inizializza tutti gli elementi con il valore \texttt{GameMatrix::EmptyPoint} e assegna tale array al campo \texttt{\_matrix}.
 531                 \item assegna a \texttt{\_freeCounter} il valore (\texttt{d1}*\texttt{d2})$^3$.
 532         \end{itemize}
 533 \end{itemize}
 534 \smallskip
 535
 536 \subsubsection{\~{}GameMatrix}
 537 \texttt{public \~{}GameMatrix() [destructor]}
 538 \begin{itemize}
 539         \item Comportamento: dealloca l'array puntato da \texttt{\_matrix} e assegna il valore 0 a \texttt{\_instance}.
 540 \end{itemize}
 541 \smallskip
 542
 543 \subsubsection{create}
 544 \texttt{public GameMatrix *create(int d1, int d2, int numPlayers) [static]}
 545 \begin{itemize}
 546         \item Parametri e precondizioni:
 547         \begin{itemize}
 548                 \item \texttt{d1} appartiene a $\{5, 7, 9\}$
 549                 \item \texttt{d2} appartiene a $[1, 3]$
 550                 \item \texttt{numPlayers} appartiene a $[0, 2]$
 551         \end{itemize}
 552         \item Comportamento: se \texttt{\_instance} è nullo gli assegna il valore della chiamata \verb!new GameMatrix(d1, d2, numPlayers)!, ritorna il valore di \texttt{\_instance}.
 553         \item Side effects: può allocare l'istanza di \texttt{GameMatrix} se questo non è ancora avvenuto.
 554 \end{itemize}
 555 \smallskip
 556
 557 \subsubsection{destroy}
 558 \texttt{public void destroy() [static]}
 559 \begin{itemize}
 560         \item Comportamento: se \texttt{\_instance} non è nullo dealloca l'oggetto puntato e gli assegna il valore 0.
 561         \item Side effects: dealloca l'unica istanza di \texttt{GameMatrix}.
 562 \end{itemize}
 563 \smallskip
 564
 565 \subsubsection{instance}
 566 \texttt{public GameMatrix *instance() [static]}
 567 \begin{itemize}
 568         \item Comportamento: ritorna il valore di \texttt{\_instance}.
 569 \end{itemize}
 570 \smallskip
 571
 572 \subsubsection{check}
 573 \texttt{public bool check(Point point) [static]}
 574 \begin{itemize}
 575         \item Parametri e precondizioni: \texttt{\_instance} non nullo.
 576         \item Comportamento: \verb!return point.isValid() &&! \\\verb!elementAt(point) == GameMatrix::EmptyPoint!
 577 \end{itemize}
 578 \smallskip
 579
 580 \subsubsection{add}
 581 \texttt{public bool add(Move move)}
 582 \begin{itemize}
 583         \item Parametri e precondizioni: \verb!move.isValid() &&! \\\verb!elementAt(move.point()) == GameMatrix::EmptyPoint! vale \texttt{true}.
 584         \item Comportamento: vedere diagramma in Figura~\ref{fig:GM_add}.
 585         \item Side effects: modifica un elemento di \texttt{\_matrix}.
 586         \item Valore ritornato e sua semantica: \texttt{true} se il giocatore che ha effettuato tale \uline{mossa} ha conseguito una situazione di vittoria, \texttt{false} altrimenti.
 587 \end{itemize}
 588 \smallskip
 589
 590 \subsubsection{extractCC}
 591 \texttt{private void extractCC(Point p, int id, QSet<Point> \&set)}
 592 \begin{itemize}
 593         \item Parametri e precondizioni:
 594         \begin{itemize}
 595                 \item \verb!p.isValid()!
 596                 \item \verb!id == elementAt(p)!
 597         \end{itemize}
 598         \item Comportamento:
 599         \begin{itemize}
 600                 \item aggiunge a \texttt{set} il valore \texttt{p}.
 601                 \item crea una lista \texttt{l} delle posizioni adiacenti a \texttt{p} nella \uline{matrice di gioco}.
 602                 \item per ogni elemento \texttt{e} di \texttt{l} per cui è vero \verb!id == elementAt(e)! ed \texttt{e} non è già presente in \texttt{set}, invoca \verb!extractCC(e, id, set)!.
 603         \end{itemize}
 604 \end{itemize}
 605
 606 \subsubsection{clear}
 607 \texttt{public void clear(Point point)}
 608 \begin{itemize}
 609         \item Parametri e precondizioni: \verb!point.isValid()! ritorna \texttt{true}.
 610         \item Comportamento:
 611         \begin{itemize}
 612                 \item se \verb|elementAt(point) != -1| aumenta di una unità \texttt{\_freeCounter}.
 613                 \item assegna all'elemento di \texttt{\_matrix} di indice \texttt{point.x() * (\_d1 * \_d2)$^2$ + point.y() * (\_d1 * \_d2) + point.z()} \\il valore \texttt{GameMatrix::EmptyPoint}.
 614         \end{itemize}
 615         \item Side effects: modifica un elemento di \texttt{\_matrix} e il valore di \texttt{\_freeCounter}.
 616         \item Note: il campo \texttt{\_lastRound} rimane inconsistente e deve essere reso consistente in modo manuale con il metodo \texttt{setLastRound}.
 617 \end{itemize}
 618 \smallskip
 619
 620 \subsubsection{elementAt(int, int, int)}
 621 \label{txt:elementAt}
 622 \texttt{public int elementAt(int x, int y, int z) [const]}
 623 \begin{itemize}
 624         \item Comportamento: esegue il controllo \verb!Point(x,y,z).isValid()!, se ritorna \texttt{true} questo metodo ritorna il valore che si trova in \texttt{\_matrix} all'indice \texttt{x * (\_d1 * \_d2)$^2$ + y * (\_d1 * \_d2) + z}. Se invece ritorna \texttt{false} il metodo ritorna il valore -2.
 625         \item Valore ritornato e sua semantica: se la posizione identificata dalle coordinate nella \uline{matrice di gioco}:
 626         \begin{itemize}
 627                 \item è occupata: da un giocatore ritorna l'\texttt{id} associato a quel giocatore.
 628                 \item è libera: ritorna \texttt{EmptyPoint}.
 629                 \item non è interna alla \uline{matrice di gioco}: ritorna -2
 630         \end{itemize}
 631 \end{itemize}
 632 \smallskip
 633
 634 \subsubsection{elementAt(Point)}
 635 \texttt{public int elementAt(Point point) [const]}
 636 \begin{itemize}
 637         \item Comportamento: \verb!return elementAt(point.x(), point.y(), point.z())!
 638         \item Valore ritornato e sua semantica: vedi~\ref{txt:elementAt}.
 639 \end{itemize}
 640 \smallskip
 641
 642 \subsubsection{isFull}
 643 \texttt{public bool isFull() [const]}
 644 \begin{itemize}
 645         \item Comportamento: ritorna \texttt{true} se e solo se \verb!_freeCounter == 0!.
 646 \end{itemize}
 647 \smallskip
 648
 649 \subsubsection{numberOfPlayers}
 650 \texttt{public int numberOfPlayers() [const]}
 651 \begin{itemize}
 652         \item Comportamento: \verb!return _lastRound.size()!
 653 \end{itemize}
 654 \smallskip
 655
 656 \subsubsection{setLastRound}
 657 \texttt{public void setLastRound(QList<Point> round)}
 658 \begin{itemize}
 659         \item Parametri e precondizioni: \texttt{round} ha un numero di elementi pari al numero dei giocatori della partita corrente.
 660         \item Comportamento: assegna \texttt{round} a \texttt{\_lastRound}.
 661 \end{itemize}
 662
 663 \medskip
 664
 665 \subsection{Classe GameLoop}
 666
 667 \subsubsection*{Descrizione generale}
 668 Deriva da \texttt{QThread} e ne implementa il metodo \texttt{run()}, è la parte dell'applicazione che gestisce il susseguirsi dei turni di gioco in una partita e ne segnala gli avvenimenti al resto dell'applicazione.
 669
 670 \medskip
 671
 672 \subsubsection*{\large{Attributi}}
 673 \smallskip
 674
 675 \subsubsection{\_currentPlayer}
 676 \texttt{private Player *\_currentPlayer}
 677 \begin{itemize}
 678         \item \`E un puntatore al \texttt{Player} che deve effettuare la \uline{mossa} successiva.
 679         \item Costruzione: inizializzato nel costruttore della classe.
 680         \item Distruzione: il distruttore della classe non deve deallocare l'oggetto puntato da questo campo.
 681 \end{itemize}
 682 \smallskip
 683
 684 \subsubsection{\_players}
 685 \texttt{private QList<Player*> \_players}
 686 \begin{itemize}
 687         \item Lista di puntatori ai \texttt{Player} che prendono parte alla partita ordinati in modo crescente secondo il loro \texttt{id()}.
 688         \item Costruzione: inizializzata nel costruttore della classe.
 689         \item Distruzione: il distruttore della classe deve occuparsi di deallocare gli oggetti puntati dagli elementi di questo campo.
 690 \end{itemize}
 691 \smallskip
 692
 693 \subsubsection{\_winStatus}
 694 \texttt{private QList<bool> \_winStatus}
 695 \begin{itemize}
 696         \item Mantiene informazioni riguardo le condizioni di vittoria raggiunte dai giocatori.
 697         \item Costruzione: inizializzata nel costruttore della classe.
 698 \end{itemize}
 699
 700 \medskip
 701
 702 \subsubsection*{\large{Operazioni}}
 703 \smallskip
 704
 705 \subsubsection{GameLoop}
 706 \texttt{public GameLoop(QList<Player*> players) [constructor]}
 707 \begin{itemize}
 708         \item Parametri e precondizioni: \texttt{players} contiene 2 o 3 elementi nessuno dei quali è un puntatore nullo.
 709         \item Comportamento:
 710         \begin{itemize}
 711                 \item assegna al campo \texttt{\_players} il parametro \texttt{players}.
 712                 \item assegna al campo \texttt{\_currentPlayer} il valore contenuto nell'elemento di indice 0 di \texttt{\_players}.
 713                 \item aggiunge al campo \texttt{\_winStatus} un numero di elementi \texttt{false} pari al valore ritornato dalla chiamata \verb!_players->size()!.
 714         \end{itemize}
 715 \end{itemize}
 716 \smallskip
 717
 718 \subsubsection{\~{}GameLoop}
 719 \texttt{public \~{}GameLoop() [destructor, virtual]}
 720 \begin{itemize}
 721         \item Comportamento: dealloca i \texttt{Player} puntati dagli elementi di \texttt{\_players}, invoca il metodo \texttt{GameMatrix::destroy()}.
 722 \end{itemize}
 723 \smallskip
 724
 725 \subsubsection{setTurn}
 726 \texttt{public void setTurn(int id)}
 727 \begin{itemize}
 728         \item Parametri e precondizioni: \texttt{id} è compreso nell'intervallo $[0,$ \_players.size()$- 1]$.
 729         \item Comportamento: assegna a \texttt{\_currentPlayer} il valore contenuto in \verb!_players[id]!.
 730         \item Side effects: cambia il valore di \texttt{\_currentPlayer}.
 731 \end{itemize}
 732 \smallskip
 733
 734 \subsubsection{run}
 735 \texttt{protected void run() [virtual]}
 736 \begin{itemize}
 737         \item Comportamento:
 738         \begin{itemize}
 739                 \item vedere Figura~\ref{fig:GL_run}.
 740                 \item viene assegnato a \verb!_winStatus[_currentPlayer->id()]! il valore ritornato dalla chiamata al metodo \texttt{add} invocato sull'istanza di \texttt{GameMatrix} ogni volta che questa chiamata viene effettuata nel diagramma precedente.
 741                 \item se la chiamata \texttt{isFull()} sull'istanza di \texttt{GameMatrix} ritorna \texttt{true} assegno il valore \texttt{true} a tutti gli elementi di \texttt{\_winStatus}.
 742         \end{itemize}
 743 \end{itemize}
 744 \smallskip
 745
 746 \subsubsection{forceMove}
 747 \texttt{public void forceMove() [slot]}
 748 \begin{itemize}
 749         \item Comportamento: se \texttt{\_currentPlayer} punta a un'istanza di \texttt{AIPlayer} ne invoca il metodo \texttt{forceMove()}.
 750 \end{itemize}
 751 \smallskip
 752
 753 \subsubsection{moved}
 754 \texttt{protected void moved(Move move) [signal]}
 755 \begin{itemize}
 756         \item Note: viene emesso dopo che è stata effettuata una mossa da parte di un \texttt{Player}.
 757 \end{itemize}
 758 \smallskip
 759
 760 \subsubsection{turn}
 761 \texttt{protected void turn(int playerId) [signal]}
 762 \begin{itemize}
 763         \item Note: viene emesso all'inizio del turno di ogni \texttt{Player} passando come parametro \texttt{playerId} il valore della chiamata \verb!id()! sul \texttt{Player} stesso.
 764 \end{itemize}
 765 \smallskip
 766
 767 \subsubsection{win}
 768 \texttt{protected void win(int playerId) [signal]}
 769 \begin{itemize}
 770         \item Note: viene emesso quando tutti i giocatori hanno eseguito un numero uguale di mosse e solamente uno di loro ha conseguito una condizione di vittoria, come parametro \texttt{playerId} viene passato l'identificatore numerico associato a tale \texttt{Player}.
 771 \end{itemize}
 772 \smallskip
 773
 774 \subsubsection{draw}
 775 \texttt{protected void draw(QList<int> playerIds) [signal]}
 776 \begin{itemize}
 777         \item Note: viene emesso quando la \uline{matrice di gioco} è piena o quando tutti i giocatori hanno eseguito un numero uguale di mosse e almeno due di loro hanno conseguito una condizione di vittoria, come parametro \texttt{playerIds} viene passata una \texttt{QList<int>} contenente gli identificatori numerici associati a tali \texttt{Player}.
 778 \end{itemize}
 779 \medskip
 780
 781 \subsection{Classe SyncSharedCondition}
 782
 783 \subsubsection*{Descrizione generale}
 784 Deriva da \texttt{QMutex} da cui eredita in particolare i metodi \texttt{lock()} e \texttt{unlock()}.
 785 Classe progettata secondo il pattern \textit{``singleton''}.
 786
 787 \medskip
 788
 789 \subsubsection*{\large{Attributi}}
 790 \smallskip
 791
 792 \subsubsection{\_instance}
 793 \texttt{private SyncSharedCondition *\_instance [static]}
 794 \begin{itemize}
 795         \item Puntatore all'eventuale unica istanza della classe.
 796         \item Costruzione: inizializzato con il valore \texttt{0}.
 797 \end{itemize}
 798 \smallskip
 799
 800 \subsubsection{\_point}
 801 \texttt{private Point \_point}
 802 \begin{itemize}
 803         \item Fornisce un modo sicuro per il passaggio sincronizzato di un valore di tipo \texttt{Point} tra \textit{thread} diversi.
 804         \item Costruzione: inizializzato in modo automatico con il costruttore di \textit{default} nel costruttore della classe.
 805 \end{itemize}
 806 \smallskip
 807
 808 \subsubsection{\_waitCond}
 809 \texttt{private QWaitCondition \_waitCond}
 810 \begin{itemize}
 811         \item \`E l'oggetto che permette l'effettiva sincronizzazione richiesta alla classe \texttt{SyncSharedCondition}.
 812         \item Costruzione: inizializzato in modo automatico con il costruttore di \textit{default} nel costruttore della classe.
 813 \end{itemize}
 814
 815 \medskip
 816
 817 \subsubsection*{\large{Operazioni}}
 818 \smallskip
 819
 820 \subsubsection{SyncSharedCondition}
 821 \texttt{private SyncSharedCondition() [constructor]}
 822 \begin{itemize}
 823         \item Comportamento: corpo vuoto.
 824 \end{itemize}
 825 \smallskip
 826
 827 \subsubsection{\~{}SyncSharedCondition}
 828 \texttt{public \~{}SyncSharedCondition() [destructor]}
 829 \begin{itemize}
 830         \item Comportamento: assegna al campo \texttt{SyncSharedCondition::\_instance} il valore \texttt{0}.
 831 \end{itemize}
 832 \smallskip
 833
 834 \subsubsection{instance}
 835 \texttt{public SyncSharedCondition *instance() [static]}
 836 \begin{itemize}
 837         \item Comportamento:
 838         \begin{itemize}
 839                 \item se \texttt{SyncSharedCondition::\_instance} è un puntatore nullo gli assegna il valore ritornato dalla chiamata \verb!new SyncSharedCondition()!.
 840                 \item ritorna il valore di \texttt{SyncSharedCondition::\_instance}.
 841         \end{itemize}
 842         \item Valore ritornato e sua semantica: ritorna un puntatore all'unica istanza della classe, non può mai essere nullo.
 843 \end{itemize}
 844 \smallskip
 845
 846 \subsubsection{notifyMove}
 847 \texttt{public void notifyMove(Point p)}
 848 \begin{itemize}
 849         \item Parametri e precondizioni: il \textit{thread} che esegue la chiamata deve aver precedentemente effettuato l'invocazione del metodo \texttt{lock()} sull'unica istanza della classe.
 850         \item Comportamento:
 851         \begin{itemize}
 852                 \item assegna a \texttt{\_point} il valore di \texttt{p};
 853                 \item esegue \verb!_waitCond.wakeOne()!.
 854         \end{itemize}
 855 \end{itemize}
 856 \smallskip
 857
 858 \subsubsection{waitForMove}
 859 \texttt{public Point waitForMove()}
 860 \begin{itemize}
 861         \item Parametri e precondizioni: il \textit{thread} che esegue la chiamata deve effettuare prima la chiamata del metodo \texttt{lock()} sull'unica istanza della classe.
 862         \item Comportamento:
 863         \begin{itemize}
 864                 \item \verb!_waitCond.wait(this)!;
 865                 \item ritorna il valore di \texttt{\_point}.
 866         \end{itemize}
 867 \end{itemize}
 868
 869 \medskip
 870
 871 \subsection{Classe AbstractSettings}
 872
 873 \subsubsection*{Descrizione generale}
 874 Classe astratta che dichiara l'interfaccia necessaria a salvare in modo persistente alcune impostazioni dell'applicazione.
 875 \medskip
 876
 877 \subsubsection*{\large{Operazioni}}
 878 \smallskip
 879
 880 \subsubsection{setLanguage}
 881 \texttt{public void setLanguage(QString lang) [abstract]}
 882 \smallskip
 883
 884 \subsubsection{setGeometry}
 885 \texttt{public void setGeometry(QByteArray geom) [abstract]}
 886 \smallskip
 887
 888 \subsubsection{setDockState}
 889 \texttt{public void setDockState(QByteArray state) [abstract]}
 890 \smallskip
 891
 892 \subsubsection{setDefaultCubeColor}
 893 \texttt{public void setDefaultCubeColor(QColor color) [abstract]}
 894 \smallskip
 895
 896 \subsubsection{setBackgroundColor}
 897 \texttt{public void setBackgroundColor(QColor color) [abstract]}
 898 \smallskip
 899
 900 \subsubsection{language}
 901 \texttt{public QString language() [abstract, const]}
 902 \smallskip
 903
 904 \subsubsection{geometry}
 905 \texttt{public QByteArray geometry() [abstract, const]}
 906 \smallskip
 907
 908 \subsubsection{dockState}
 909 \texttt{public QByteArray dockState() [abstract, const]}
 910 \smallskip
 911
 912 \subsubsection{defaultCubeColor}
 913 \texttt{public QColor defaultCubeColor() [abstract, const]}
 914 \smallskip
 915
 916 \subsubsection{backgroundColor}
 917 \texttt{public QColor backgroundColor() [abstract, const]}
 918
 919 \medskip
 920
 921 \subsection{Classe SettingsManager}
 922
 923 \subsubsection*{Descrizione generale}
 924 Classe astratta che deriva da \texttt{AbstractSettings} e ne arricchisce l'interfaccia.
 925 \medskip
 926
 927 \subsubsection*{\large{Operazioni}}
 928 \smallskip
 929
 930 \subsubsection{setPlayersInfo}
 931 \texttt{public void setPlayersInfo(QList<PlayerInfo> info) [abstract]}
 932 \smallskip
 933
 934 \subsubsection{setDifficulty1}
 935 \texttt{public void setDifficulty1(int d1) [abstract]}
 936 \smallskip
 937
 938 \subsubsection{setDifficulty2}
 939 \texttt{public void setDifficulty2(int d2) [abstract]}
 940 \smallskip
 941
 942 \subsubsection{playersInfo}
 943 \texttt{public QList<PlayerInfo> playersInfo() [abstract, const]}
 944 \smallskip
 945
 946 \subsubsection{difficulty1}
 947 \texttt{public int difficulty1() [abstract, const]}
 948 \smallskip
 949
 950 \subsubsection{difficulty2}
 951 \texttt{public int difficulty2() [abstract, const]}
 952
 953 \medskip
 954
 955 \subsection{Classe GUISettings}
 956
 957 \subsubsection*{Descrizione generale}
 958 Classe che deriva da \texttt{AbstractSettings} e ne implementa l'interfaccia utilizzando le funzionalità fornite dalla derivazione protetta dalla classe \texttt{QSettings}.
 959 \medskip
 960
 961 \subsubsection*{\large{Operazioni}}
 962 \smallskip
 963
 964 \subsubsection{setLanguage}
 965 \texttt{public void setLanguage(QString lang) [virtual]}
 966 \begin{itemize}
 967         \item Comportamento: \verb!setValue("GUI/language", lang)!
 968 \end{itemize}
 969 \smallskip
 970
 971 \subsubsection{setGeometry}
 972 \texttt{public void setGeometry(QByteArray geom) [virtual]}
 973 \begin{itemize}
 974         \item Comportamento: \verb!setValue("GUI/geometry", geom)!
 975 \end{itemize}
 976 \smallskip
 977
 978 \subsubsection{setDockState}
 979 \texttt{public void setDockState(QByteArray state) [abstract]}
 980 \begin{itemize}
 981         \item Comportamento: \verb!setValue("GUI/dock_state", state)!
 982 \end{itemize}
 983 \smallskip
 984
 985 \subsubsection{setDefaultCubeColor}
 986 \texttt{public void setDefaultCubeColor(QColor color) [virtual]}
 987 \begin{itemize}
 988         \item Comportamento: \verb!setValue("GUI/cube_color", color)!
 989 \end{itemize}
 990 \smallskip
 991
 992 \subsubsection{setBackgroundColor}
 993 \texttt{public void setBackgroundColor(QColor color) [virtual]}
 994 \begin{itemize}
 995         \item Comportamento: \verb!setValue("GUI/bg_color", color)!
 996 \end{itemize}
 997 \smallskip
 998
 999 \subsubsection{language}
1000 \texttt{public QString language() [const, virtual]}
1001 \begin{itemize}
1002         \item Comportamento: \verb!return value("GUI/language", "").toString()!
1003 \end{itemize}
1004 \smallskip
1005
1006 \subsubsection{geometry}
1007 \texttt{public QByteArray geometry() [const, virtual]}
1008 \begin{itemize}
1009         \item Comportamento: \verb!return value("GUI/geometry",!\\\verb!QByteArray()).toByteArray()!
1010 \end{itemize}
1011 \smallskip
1012
1013 \subsubsection{dockState}
1014 \texttt{public QByteArray dockState() [abstract, const]}
1015 \begin{itemize}
1016         \item Comportamento: \verb!return value("GUI/dock_state",!\\\verb!QByteArray()).toByteArray()!
1017 \end{itemize}
1018 \smallskip
1019
1020 \subsubsection{defaultCubeColor}
1021 \texttt{public QColor defaultCubeColor() [const, virtual]}
1022 \begin{itemize}
1023         \item Comportamento: \verb!return value("GUI/cube_color",!\\\verb!QColor(parametri)).value<QColor>()!
1024 \end{itemize}
1025 \smallskip
1026
1027 \subsubsection{backgroundColor}
1028 \texttt{public QColor backgroundColor() [const, virtual]}
1029 \begin{itemize}
1030         \item Comportamento: \verb!return value("GUI/bg_color",!\\\verb!QColor(parametri)).value<QColor>()!
1031 \end{itemize}
1032
1033 \medskip
1034
1035 \subsection{Classe LocalSettings}
1036
1037 \subsubsection*{Descrizione generale}
1038 Classe che deriva da \texttt{GUISettings} e \texttt{SettingsManager}, della quale implementa l'interfaccia dichiarata utilizzando le funzionalità fornite dalla derivazione protetta dalla classe \texttt{QSettings} attraverso la classe \texttt{GUISettings}. \`E la classe pensata per mantenere la persistenza dei dati richiesti nella modalità stand-alone.
1039 \medskip
1040
1041 \subsubsection*{\large{Operazioni}}
1042 \smallskip
1043
1044 \subsubsection{setPlayersInfo}
1045 \texttt{public void setPlayersInfo(QList<PlayerInfo> info) [virtual]}
1046 \begin{itemize}
1047         \item Comportamento: se \texttt{info.size() == 2} allora esegue \\\verb!info.append(PlayerInfo())!.
1048         \\Poi $\forall i$ in $[0, 2]$:
1049         \begin{itemize}
1050                 \item \verb!setValue("Local/player_" + QString::number(!$i$\verb!) +!\\\verb! "_name", info.at(!$i$\verb!).name())!
1051                 \item \verb!setValue("Local/player_" + QString::number(!$i$\verb!) +!\\\verb! "_color", info.at(!$i$\verb!).color())!
1052                 \item \verb!setValue("Local/player_" + QString::number(!$i$\verb!) +!\\\verb! "_type", info.at(!$i$\verb!).type())!
1053         \end{itemize}
1054 \end{itemize}
1055 \smallskip
1056
1057 \subsubsection{setDifficulty1}
1058 \texttt{public void setDifficulty1(int d1) [virtual]}
1059 \begin{itemize}
1060         \item Comportamento: \verb!setValue("Local/d1", d1)!
1061 \end{itemize}
1062 \smallskip
1063
1064 \subsubsection{setDifficulty2}
1065 \texttt{public void setDifficulty2(int d2) [virtual]}
1066 \begin{itemize}
1067         \item Comportamento: \verb!setValue("Local/d2", d2)!
1068 \end{itemize}
1069 \smallskip
1070
1071 \subsubsection{playersInfo}
1072 \texttt{public QList<PlayerInfo> playersInfo() [const, virtual]}
1073 \begin{itemize}
1074         \item Comportamento: crea una \texttt{QList<PlayerInfo> info} vuota; crea una \texttt{QList<QColor> defaultColors} e inserisce gli elementi \verb!QColor(255, 0, 0)!, \verb!QColor(0, 255, 0)! e \verb!QColor(0, 0, 255)!; crea una \texttt{QList<QString>} e inserisce gli elementi \verb!"H"!, \verb!"A"! e \verb!""!.
1075         \\Poi $\forall i$ in $[0, 2]$:
1076         \begin{itemize}
1077                 \item \verb!n = value("Local/player_" + QString::number(!$i$\verb!) +!\\\verb! "_name", "").toString()!
1078                 \item \verb!c = value("Local/player_" + QString::number(!$i$\verb!) +!\\\verb! "_color",defaultColors[!$i$\verb!]).value<QColor>()!
1079                 \item \verb!t = value("Local/player_" + QString::number(!$i$\verb!) +!\\\verb! "_type", defaultTypes[!$i$\verb!]).toString()!
1080                 \item se \verb|t != ""| esegue \verb!info.append(PlayerInfo(n, c, t))!.
1081         \end{itemize}
1082         Infine ritorna la lista \texttt{info}.
1083 \end{itemize}
1084 \smallskip
1085
1086 \subsubsection{difficulty1}
1087 \texttt{public int difficulty1() [const, virtual]}
1088 \begin{itemize}
1089         \item Comportamento: \verb!return value("Local/d1", 5).toInt()!
1090 \end{itemize}
1091 \smallskip
1092
1093 \subsubsection{difficulty2}
1094 \texttt{public int difficulty2() [const, virtual]}
1095 \begin{itemize}
1096         \item Comportamento: \verb!return value("Local/d2", 1).toInt()!
1097 \end{itemize}
1098
1099 \medskip
1100
1101 \subsection{Classe ServerSettings}
1102
1103 \subsubsection*{Descrizione generale}
1104 Classe che deriva da \texttt{GUISettings} e \texttt{SettingsManager}, della quale implementa l'interfaccia dichiarata utilizzando le funzionalità fornite dalla derivazione protetta dalla classe \texttt{QSettings} attraverso la classe \texttt{GUISettings}. \`E la classe pensata per mantenere la persistenza dei dati richiesti nella modalità server.
1105 \medskip
1106
1107 \subsubsection*{\large{Operazioni}}
1108 \smallskip
1109
1110 \subsubsection{setPlayersInfo}
1111 \texttt{public void setPlayersInfo(QList<PlayerInfo> info) [virtual]}
1112 \begin{itemize}
1113         \item Comportamento: se \texttt{info.size() == 2} allora esegue \\\verb!info.append(PlayerInfo())!.
1114         \\Poi $\forall i$ in $[0, 2]$:
1115         \begin{itemize}
1116                 \item \verb!setValue("Server/player_" + QString::number(!$i$\verb!) +!\\\verb! "_name", info.at(!$i$\verb!).name())!
1117                 \item \verb!setValue("Server/player_" + QString::number(!$i$\verb!) +!\\\verb! "_color", info.at(!$i$\verb!).color())!
1118                 \item \verb!setValue("Server/player_" + QString::number(!$i$\verb!) +!\\\verb! "_type", info.at(!$i$\verb!).type())!
1119         \end{itemize}
1120 \end{itemize}
1121 \smallskip
1122
1123 \subsubsection{setDifficulty1}
1124 \texttt{public void setDifficulty1(int d1) [virtual]}
1125 \begin{itemize}
1126         \item Comportamento: \verb!setValue("Server/d1", d1)!
1127 \end{itemize}
1128 \smallskip
1129
1130 \subsubsection{setDifficulty2}
1131 \texttt{public void setDifficulty2(int d2) [virtual]}
1132 \begin{itemize}
1133         \item Comportamento: \verb!setValue("Server/d2", d2)!
1134 \end{itemize}
1135 \smallskip
1136
1137 \subsubsection{setServerPort}
1138 \texttt{public void setServerPort(quint16 port)}
1139 \begin{itemize}
1140         \item Comportamento: \verb!setValue("Server/port", port)!
1141 \end{itemize}
1142 \smallskip
1143
1144 \subsubsection{setTimerDuration}
1145 \texttt{public void setTimerDuration(int msec)}
1146 \begin{itemize}
1147         \item Comportamento: \verb!setValue("Server/timer", msec)!
1148 \end{itemize}
1149 \smallskip
1150
1151 \subsubsection{setMyColor}
1152 \texttt{public void setMyColor(QColor color)}
1153 \begin{itemize}
1154         \item Comportamento: \verb!setValue("Server/my_color", color)!
1155 \end{itemize}
1156 \smallskip
1157
1158 \subsubsection{playersInfo}
1159 \texttt{public QList<PlayerInfo> playersInfo() [const, virtual]}
1160 \begin{itemize}
1161         \item Comportamento: crea una \texttt{QList<PlayerInfo> info} vuota; crea una \texttt{QList<QColor> defaultColors} e inserisce gli elementi \verb!QColor(255, 0, 0)!, \verb!QColor(0, 255, 0)! e \verb!QColor(0, 0, 255)!.
1162         \\Poi $\forall i$ in $[0, 2]$:
1163         \begin{itemize}
1164                 \item \verb!n = value("Server/player_" + QString::number(!$i$\verb!) +!\\\verb! "_name", "").toString()!
1165                 \item \verb!c = value("Server/player_" + QString::number(!$i$\verb!) +!\\\verb! "_color",defaultColors[!$i$\verb!]).value<QColor>()!
1166                 \item \verb!t = value("Server/player_" + QString::number(!$i$\verb!) +!\\\verb! "_type", "R").toString()!
1167                 \item se \verb|t != ""| esegue \verb!info.append(PlayerInfo(n, c, t))!.
1168         \end{itemize}
1169         Infine ritorna la lista \texttt{info}.
1170 \end{itemize}
1171 \smallskip
1172
1173 \subsubsection{difficulty1}
1174 \texttt{public int difficulty1() [const, virtual]}
1175 \begin{itemize}
1176         \item Comportamento: \verb!return value("Server/d1", 5).toInt()!
1177 \end{itemize}
1178 \smallskip
1179
1180 \subsubsection{difficulty2}
1181 \texttt{public int difficulty2() [const, virtual]}
1182 \begin{itemize}
1183         \item Comportamento: \verb!return value("Server/d2", 1).toInt()!
1184 \end{itemize}
1185 \smallskip
1186
1187 \subsubsection{serverPort}
1188 \texttt{public quint16 serverPort() [const]}
1189 \begin{itemize}
1190         \item Comportamento: \verb!return value("Server/port", 42000).toUint()!
1191 \end{itemize}
1192 \smallskip
1193
1194 \subsubsection{timerDuration}
1195 \texttt{public int timerDuration() [const]}
1196 \begin{itemize}
1197         \item Comportamento: \verb!return value("Server/timer", 180000).toInt()! %% 3 minuti %%
1198 \end{itemize}
1199 \smallskip
1200
1201 \subsubsection{myColor}
1202 \texttt{public QColor myColor() [const]}
1203 \begin{itemize}
1204         \item Comportamento: \verb!return value("Server/my_color",!\\\verb!QColor(parametri)).value<QColor>()!
1205 \end{itemize}
1206
1207 \medskip
1208
1209 \subsection{Diagrammi UML} %%%%%%%%
1210
1211 \begin{figure}[hpbt]
1212 \centering
1213 \includegraphics[width=13cm]{HumanPlayer_doMove.png}
1214 \caption{Diagramma \texttt{HumanPlayer::doMove}}
1215 \label{fig:HP_doMove}
1216 \end{figure}
1217
1218 \begin{figure}[hpbt]
1219 \centering
1220 \includegraphics[width=13cm]{RemotePlayer_doMove.png}
1221 \caption{Diagramma \texttt{RemotePlayer::doMove}}
1222 \label{fig:RP_doMove}
1223 \end{figure}
1224
1225 \begin{figure}[hpbt]
1226 \centering
1227 \includegraphics[width=7cm]{AIPlayer_doMove.png}
1228 \caption{Diagramma \texttt{AIPlayer::doMove}}
1229 \label{fig:AP_doMove}
1230 \end{figure}
1231
1232 \begin{figure}[hpbt]
1233 \centering
1234 \includegraphics[width=13cm]{GameLoop_run.png}
1235 \caption{Diagramma \texttt{GameLoop::run}}
1236 \label{fig:GL_run}
1237 \end{figure}
1238
1239 \begin{figure}[hpbt]
1240 \centering
1241 \includegraphics[width=13cm]{GameMatrix_add.png}
1242 \caption{Diagramma \texttt{GameMatrix::add}}
1243 \label{fig:GM_add}
1244 \end{figure}