Il giardino del re nasconde magnifici tesori! Dovrai essere in grado di trovarli tutti!
Il giardino si divide in 10 aiuole. In due di queste sono contenuti dei tesori che l’utente deve trovare. Se l’utente scopre le posizioni dei tesori vince la sfida. In tutto un utente può fare tre tentativi. (Gioco trova il tesoro).

Analisi del problema

Per prima cosa definiamo le strutture dati che ci possono servire. Una prima struttura fondamentale sarà un vettore con 10 caselle. Possiamo ipotizzare che ogni casella rappresenti un aiuola del giardino del re. Se una locazione contiene il valore 1 vuol dire che c’è un tesoro se invece se c’è 0 l’aiuola è vuota.

int aiuole[10];

Poichè il problema del gioco è complesso possiamo affrontarlo utilizzando la metodologia top-down:

La scomposizione che viene proposta consiste in tre sottoprogrammi:

  • caricaTesori: funzione che ha lo scopo di caricare i due tesori nella aiuole. Le posizioni devono essere scelte casualmente e non devono coincidere
  • partita: funzione che dovrà gestire l’interazione con l’utente. In questa funzione il computer farà la domanda all’utente sulle posizioni che contengono i tesori e questo risponderà. La funzione dovrà restituire un valore true o falsa a seconda che la posizione contenga un tesoro
  • gioco: la funzione gestisce la dinamica di gioco cioè permette all’utente di svolgere le partite (al massimo tre).

caricaTesori

Funzione che ha il compito di caricare i tesori nelle aiuole in due posizioni a caso non coincidenti.

Per prima cosa scrivo l’intestazione della funzione riflettendo sul fatto che la funzione non deve restituire nulla e non deve prendere in input nulla perchè il vettore delle aiuole è definito come variabile globale:

void caricaTesori() {

La strategia che scelgo è quella di mettere in tutte le celle il valore 0 in modo che nessuna aiuola all’inizio contenga un tesoro:

for (int i = 0; i < 10; i++) 
{
   aiuole[i] = 0;
}

A questo punto è possibile scegliere in maniera random due valori interi compresi tra 0 e 9 che rappresentano le posizioni dove casualmente verranno posti i tesori. Si ricorda che il fatto che ci sia un tesoro è rappresentato dal valore 1 nella cella:

srand(time(NULL));
int posizione1 = rand() % 10;
int posizione2 = rand() % 10;

E’ necessario controllare che le due posizioni siano differenti. Possiamo dire che fin tanto che le posizioni sono uguali la posizione2 deve essere riscelta:

while(posizione1==posizione2)
{		
   posizione2 = rand() % 10;
}

Infine metto nelle posizioni scelte in maniera random il numero 1:

aiuole[posizione1] = 1;
aiuole[posizione2] = 1;

La funzione completa è la seguente:

/*
* funzione che ha il compito di mettere in due
* posizioni del vettore il valore 1 e nelle altre 0
*/
void caricaTesori()
{
	//Metto in tutte le posizioni il valore 0
	for (int i = 0; i < 10; i++) {
		aiuole[i] = 0;
	}
	//genera a caso due numeri 
	srand(time(NULL));
	int posizione1 = rand() % 10;
	int posizione2 = rand() % 10;

	//controllo che posizione1 sia diversa da posizione2
	//fin tanto che posizione1=posizione2 scegli una nuova posizione
	while(posizione1==posizione2)
	{
		posizione2 = rand() % 10;
	}
	aiuole[posizione1] = 1;
	aiuole[posizione2] = 1;
}

partita

La funzione della partita gestisce l’interazione con l’utente e ritorna vero o falso a seconda che questo indovini:

bool partita() 
{
        //chiedo all'utente dove secondo lui si trovano i tesori
	cout << "Dove si trovano i tesori";
        //memorizzo le posizioni che lui sceglie
	int pos1;
	cin >> pos1;
	int pos2;
	cin >> pos2;
        
        //se le due posizioni(tolgo 1 perchè gli indici partono da 0 hanno il valore 1 significa che l'utente ha trovato il tesoro)
	if (aiuole[pos1-1] == 1 &amp;&amp; aiuole[pos2-1] == 1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

gioco

La funzione gioco ritorna un valore vero o falso a seconda che l’utente nelle tre partite che può fare trova o meno i tesori. Chiaramente appena l’utente trova un tesoro la funzione ritorna true.

bool gioco() {

Come prima cosa chiamiamo la funzione caricaTesori() per permettere di caricare i tesori a caso:

cout << "GIOCO TROVA IL TESORO!" << endl;
caricaTesori(); //chiamata caricaTesori

L’utente deve poter fare tre tentativi quindi gestiamo questo fatto col pattern contatore :

int cont = 0;
while (cont < 3) 
{
    if (partita()) 
    {
	return true;
    }
	cont++;
 }
return false;

La funzione completa è la seguente:

bool gioco() {
	cout << "GIOCO TROVA IL TESORO!" << endl;
	caricaTesori(); //chiamata caricaTesori
	int cont = 0;
	while (cont < 3) 
	{
		if (partita()) 
		{
			return true;
		}
		cont++;
	}
	return false;
}

Implementazione

Questo il programma completo:

#include <iostream>
#include <ctime>
int aiuole[10];

//prototipi
bool gioco();
bool partita();
void caricaTesori();

using namespace std;

int main()
{
	if (gioco()) { cout << "HAI VINTO!!!!!"; }
	else { cout << "HAI PERSO :-("; }
}

/*
* funzione che ha il compito di mettere in due
* posizioni del vettore il valore 1 e nelle altre 0
*/
void caricaTesori()
{
	//Metto in tutte le posizioni il valore 0
	for (int i = 0; i < 10; i++) {
		aiuole[i] = 0;
	}
	//genera a caso due numeri 
	srand(time(NULL));
	int posizione1 = rand() % 10;
	int posizione2 = rand() % 10;

	//controllo che posizione1 sia diversa da posizione2
	//fin tanto che posizione1=posizione2 scegli una nuova posizione
	while(posizione1==posizione2)
	{
		posizione2 = rand() % 10;
	}
	aiuole[posizione1] = 1;
	aiuole[posizione2] = 1;
}

bool partita() 
{
	cout << "Dove si trovano i tesori";
	int pos1;
	cin >> pos1;
	int pos2;
	cin >> pos2;

	if (aiuole[pos1-1] == 1 &amp;&amp; aiuole[pos2-1] == 1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool gioco() {
	cout << "GIOCO TROVA IL TESORO!" << endl;
	caricaTesori(); //chiamata caricaTesori
	int cont = 0;
	while (cont < 3) 
	{
		if (partita()) 
		{
			return true;
		}
		cont++;
	}
	return false;
}

Torna a vettori

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.