Console 8: DoppioUno (if annidati)

Si tratta di fare un gioco, chiamato DoppioUno, le cui regole siano le seguenti:

Ci sono due giocatori: il computer e l'utente. Inizia a giocare il computer.
Si gioca con due dadi a 6 facce. Le facce sono numerate da 1 a 6, ma al posto di 1 c'è il simbolo :<
Il giocatore corrente lancia due dadi, d1, d2. Ci sono tre casi:
1. d1 > 1 e d2 > 1: in questo caso d1+d2 viene aggiunto al punteggio del giocatore corrente. Il giocatore può scegliere di rigiocare o passare il turno.
2. d1 = 1, d2 > 1 (o d1 > 1 e d2 = 1): il giocatore perde il turno: il suo punteggio rimane invariato e il turno passa all'altro giocatore.
3. d1 = d2 = 1: il punteggio del giocatore viene azzerato e il turno passa all'altro giocatore.
Il primo giocatore il cui punteggio è superiore o uguale a WIN, ha vinto (qui WIN = 40)

Provando a mettere in pratica queste regole (in informatichese si dice "implementare"), ci vengono subito in mente le seguenti cose:

il risultato di un tiro di un dado può essere rappresentato da un numero (int) aleatorio ("random") tra 1 e 6, e questo lo sappiamo fare. Per esempio:
```
dado1 = (int)(Math.random()*6)+1; /* (int)(Math.random()*6) fornisce un intero "quasi aleatorio" tra 0 e 5;
aggiungendo 1, abbiamo il risultato ricercato*/
```
Inizia a giocare il computer. Bene. Supponiamo che al primo turno il computer tiri: d1 = 2, d2 = 3. Il suo punteggio diventa 5. A questo punto, il computer può scegliere di rigiocare o di passare, come si fa a decidere se il computer passa o rigioca? In un primo tempo, per semplificare, possiamo assumere che il computer non abbia una strategia di gioco ben definita, ma che si affidi al caso: il computer butta in aria una monetina, se esce faccia, rigioca, altrimenti passa. Quindi, per esempio:
```
 int r = (int)(Math.random()*10);  // r = intero aleatorio, 0 <= r <= 9
 if(r % 2 == 0){ rigioca};   //se r è pari, rigioca
 else{ passa};               // altrimenti (cioè se r è dispari); passa
```
Se il computer deve rigiocare, un certo ciclo deve continuare; se invece il computer deve passare, quel ciclo deve finire. Quindi, per esempio, la giocata iniziale del computer potrebbe presentarsi così:
Il diagramma precedente riassume la prima giocata del computer (o una qualsiasi giocata). Il codice corrispondente è:
```
 while(c == 1){       //mentre c=1, si gioca

 tiraDadi();   // tira i dadi d1, d2 (abbiamo visto come si tira un dado)

 if(d1 == 1 & d2 == 1){ 
 Punt = 0;		//il punteggio viene azzerato
 c = 0;}			
/* c = 0 significa passa(); infatti se c = 0, il ciclo while(c == 1) finisce */

 else if((d1 == 1 & d2 > 1) || (d1 > 1 & d2 == 1)){  
/*altrimenti se d1 e d2 > 1 
 o d2 = 1 e d1 > 1 (cioè uno solo tra d1 e d2 è uguale a 1)*/

// Punt = quello di prima; 
// quindi possiamo ignorare questa riga che non porta niente di nuovo

c=0;  
/* c = 0 significa passa(), perchè se c = 0, il ciclo while(c == 1) finisce */

	}

 else{   	Punt = Punt +d1+d2;  //aggiornamento del punteggio
		rigiocare?();
		if(no){
			c = 0; /* come già detto, c = 0, significa
passa();*/
	}  // fine else

}  //fine while: fine della giocata
```
Osserviamo l'istruzione:
```
else if((d1 == 1 & d2 > 1) || (d1 > 1 & d2 == 1)){
```
che introduce gli operatori logici &, ||:
a & b; significa a e b
questa proposizione è vera se e solo se sia a che b sono vere.
a || b; significa a o b
questa proposizione è vera se e solo se uno dei due, almeno, tra a e b è vero. Torneremo più dettagliatamente su questi operatori in futuro.

Questo disegno, purtroppo non è del tutto completo: infatti se il giocatore ha già vinto, è inutile chiedergli se vuole continuare a giocare... Manca decisamente il test per verificare se la partita è finita o meno. Ovviamente questo test andrebbe inserito prima di: "Rigiocare". Per esempio:
```
.......
 else{		Punt = Punt+d1+d2;
		if(Punt > Win){
			System.out.println("Hai vinto!");
   			finePartita();
				}
		rigiocare?();
		if(no){
			c=0;}
	}
```
Comunque sia, abbiamo usato (nel codice precedente) degli if annidati cioè la seguente struttura:
```
 if(condizione 1){
		Istruzione_1;}
 else if(condizione 2){
		Istruzione_2;}
 ........
 else if(condizione n){
		Istruzione_n;}
 else{
		Istruzione_D;}
```
Le varie istruzioni sono eseguite dall'alto in basso. Quando il programma incontra una condizione vera (per esempio condizione 3), esegue l'istruzione corrispondente (per es. Istruzione_3) e il resto della struttura viene ignorato. Se nessuna condizione è vera, viene eseguita l'istruzione dell'else finale (Istruzione_D: istruzione di default). Se manca l'else e se tutte le condizioni sono false, non viene eseguita alcuna istruzione.

Questa struttura permette di fare delle scelte multiple.

Next

Home

Previous