Scrivere una briscola in C++

typedef

il 27 giu 2018, 17:06

33 risposte

33 Risposte - Pagina 2

jfet
Utente Attivo
Iscritto da
mar, 2018
Messaggi:
106
Re: Scrivere una briscola in C++
03 lug 2018, 15:47
Nippolo mi ha preceduto, quell'unsigned non ha senso e il mazzo non è presettato, dentro sono presenti valori spazzatura.
Mi scuso comunque, non ho guardato tutti i precedenti post.

typedef

Pochi posts

Iscritto da: giu, 2018

Messaggi:: 21

Re: Scrivere una briscola in C++

03 lug 2018, 15:54

Ho apportato le correzioni suggerite e ora funziona:

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;

int main () {
	
	srand(time(0));
	
	int mazzo [40];
	int j;
	int box;
	
	for (int i=0; i<40; i++){
		mazzo[i] = i; 
	}
	
	for (int i=0; i<40; i++)
	{
		j = i + rand()%(40 - i);  
					
		box = mazzo[i];
		mazzo[i] = mazzo[j];
		mazzo [j] = box;
	}
//visualizzare il mazzo mescolato per verificare il mescolamento	
	for (int i=0; i<40; i++) 
	{
		
		cout << mazzo[i]<<endl;
		
	}
	return 0;
}

Ho aggiunto il mazzo ordinato. ed eliminato unsigned che avevo inserito come prova per eliminare i valori negativi nel primo tentativo e postando il codice non lo avevo eliminato.

*Ho aggiunto la nuova parte di codice nel programma della briscola e funziona. Rimangono però gli altri problemi già citati.

Nippolo
Molto attivo
Iscritto da
mar, 2018
Messaggi:
1238
Re: Scrivere una briscola in C++
03 lug 2018, 16:20
Va bene, ma vale ancora il suggerimento di prima:
- nel secondo for deve essere i<39, infatti per i=39 j può assumere il solo valore 39.
Per quanto riguarda il resto del programma sto pensando ad un'impostazione più semplice e chiara. Se ho tempo dopo ti posto la mia idea.
T
typedef
Pochi posts
Iscritto da
giu, 2018
Messaggi:
21
Re: Scrivere una briscola in C++
03 lug 2018, 16:27
- nel secondo for deve essere i<39, infatti per i=39 j può assumere il solo valore 39.
Pensavo di averlo corretto, lo faccio subito, grazie.

Per quanto riguarda il resto del programma sto pensando ad un'impostazione più semplice e chiara. Se ho tempo dopo ti posto la mia idea.
Grazie mille

Nippolo

Molto attivo

Iscritto da: mar, 2018

Messaggi:: 1238

Re: Scrivere una briscola in C++

04 lug 2018, 08:53

Ho provato ad implementare l'intero programma (senza utilizzare puntatori, "classi" e vector che da quanto ho capito sono argomenti che non hai trattato) e sembra funzionare, anche se non l'ho testato per bene.
Ti posto lo scheletro:

#include <iostream>
#include <ctime>
#include <windows.h>

using namespace std;

struct carta
{
   unsigned int valore;
   unsigned int seme;
   unsigned int punti;
};

struct gruppo
{
    carta v[40];
    unsigned int dim = 0;
};

struct giocatore
{
    gruppo mano;
    gruppo prese;
    unsigned int scelta; //conterrà l'indice della carta che G1 e PC giocano dalla mano
};

carta briscola;
gruppo mazzo;
giocatore G1;
giocatore PC;

void colore(const unsigned int n)
{
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), n);
}

void mostra_carta(const carta &c)
{
    colore(c.seme);
    cout << c.valore << endl;
    colore(7);
}

void scambia_carte(carta &c_1, carta &c_2)
{
    //scambia il contenuto di 2 carte
}

void mescola_mazzo()
{
    unsigned int j;
    for(unsigned int i = 0; i < 39; ++i)
    {
        j = rand() % (40 - i) + i;
        scambia_carte(mazzo.v[i], mazzo.v[j]);
    }
}

void prepara_mazzo()
{
    for(unsigned int i = 0; i < 40; ++i)
    {
        ++mazzo.dim;
        switch(mazzo.v[i].valore = i % 10 + 1)
        {
            case 1  : mazzo.v[i].punti = 11;
            break;
            case 3  : mazzo.v[i].punti = 10;
            break;
            case 10 : mazzo.v[i].punti = 4;
            break;
            case 9  : mazzo.v[i].punti = 3;
            break;
            case 8  : mazzo.v[i].punti = 2;
            break;
            default : mazzo.v[i].punti = 0;
        }
        switch(i / 10)
        {
            case 0 : mazzo.v[i].seme = 10; //BASTONI
            break;
            case 1 : mazzo.v[i].seme = 11; //SPADE
            break;
            case 2 : mazzo.v[i].seme = 12; //COPPE
            break;
            case 3 : mazzo.v[i].seme = 14; //DENARI
        }
    }
    mescola_mazzo();
}

void sposta_carta(gruppo &origine, gruppo &destinazione, const unsigned int i)
{
    //sposta la carta di indice i dall'origine alla destinazione
}

void distribuisci_carte(giocatore &G)
{
    //distribuisce carte al giocatore G finché non ne ha 3 in mano
}

void scelta_G1(const bool prima_G1)
{
    //chiede a G1 di scegliere quale carta giocare dalla mano. Viene visualizzata la briscola e la scelta del PC se il PC gioca per primo
}

void scelta_PC()
{
    //scelta della carta da parte del PC. Inizialmente mi limiterei a selezionare una carta a caso dalla mano e poi quando tutto funziona correttamente potrai divertirti a implementare una CPU
}

void analizza_presa(giocatore &G_1, giocatore &G_2, bool &prima_G1)
{
    //stabilisce chi vince la presa, sposta le due carte tra le prese del vincitore e modifica la variabile prima_G1 di conseguenza
}

unsigned int calcola_punti(const giocatore &G)
{
    //calcola i punti di G
}

int partita(bool prima_G1)
{
    prepara_mazzo();
    briscola = mazzo.v[0];
    while(G1.prese.dim + PC.prese.dim < 40)
    {
        if(prima_G1)
        {
            if(mazzo.dim)
            {
                distribuisci_carte(G1);
                distribuisci_carte(PC);
            }
            scelta_G1(prima_G1);
            scelta_PC();
            analizza_presa(G1, PC, prima_G1);
        }
        else
        {
            if(mazzo.dim)
            {
                distribuisci_carte(PC);
                distribuisci_carte(G1);
            }
            scelta_PC();
            scelta_G1(prima_G1);
            analizza_presa(PC, G1, prima_G1);
        }
    }
    unsigned int n = calcola_punti(G1);
    if(n < 60)
    {
        return -1;
    }
    else if(n == 60)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

int main()
{
    srand(time(0));
    bool prima_G1 = rand() % 2;
    unsigned int vittoria = partita(prima_G1);
    if(vittoria == -1)
    {
        cout << "HAI PERSO!";
    }
    else if(vittoria == 0)
    {
        cout << "PAREGGIO!";
    }
    else
    {
        cout << "HAI VINTO!";
    }
}

Puoi prendere qualche spunto oppure se l'impostazione ti piace puoi passare ad implementare le varie funzioni.

typedef

Pochi posts

Iscritto da: giu, 2018

Messaggi:: 21

Re: Scrivere una briscola in C++

04 lug 2018, 09:48

Ora cerco di implementare il gioco come suggerito.

Come posso distribuire le carte ad ogni mano facendo in modo che la carta giocata venga sostituita da una nuova? Avevo creato questo codice ma non funziona adeguatamente..

void distribuireCarte() {         				 								// Funzione per dare le carte ai giocatori

    if (mazzierePc) {
        for (int i=0; i<3; i++){           										//utilizzo del for per variare in numero di carte preso nella prima mano.
        manoGiocatore[i] = mazzo[i*2];   										// caso in cui le carte vengono date prima all'utente e poi all'avversario.
        manoPC[i] = mazzo[i*2+1];
        } 
    }
		else {
        for (int i=0; i<3; i++)
        {   manoGiocatore[i] = mazzo[i*2+1]; 									// caso in cui le carte vengono date prima all'avversario e poi all'utente.
            manoPC[i] = mazzo[i*2];
      }
  }

}

O
oregon
Super Famoso
Iscritto da
nov, 2011
Messaggi:
21785
Re: Scrivere una briscola in C++
04 lug 2018, 11:29
Discutere in un forum di un errore/malfunzionamento ha un senso e si può risolvere con qualche risposta che risolve il thread.

Ma che tu non abbia chiaro "tutto" l'algoritmo da usare per "tutto" il programma, inviando codice che magari non ha molto senso tanto da doverlo rivedere tutto, secondo me allunga infinitamente il thread e non permette di usufruire correttamente dello strumento forum.

E' mia opinione personale che il thread non possa continuare in questo modo ... terminerà solo quando qualcuno scriverà tutto il codice al posto tuo.

Affronta problema dopo problema e crea singoli thread per singoli problemi, altrimenti diventa una chat.

IMHO
T
typedef
Pochi posts
Iscritto da
giu, 2018
Messaggi:
21
Re: Scrivere una briscola in C++
04 lug 2018, 14:56
Non è mia intenzione articolare in questo modo il thread, ho riassunto tutto in un solo thread per evitare troppe discussioni.

Seppur il codice può apparire senza alcun senso ho solo cercato aiuto per chiarire le mie lacune,non voglio che qualcuno scriva tutto il codice al posto mio, mi sto impegnando molto ma sto trovando difficoltà.

Se si ritiene opportuno la chiusura di questo argomento non ci sono problemi per me.

Mi spiace per l'inconveniente, sono molto grato a chi mi ha aiutato.
O
oregon
Super Famoso
Iscritto da
nov, 2011
Messaggi:
21785
Re: Scrivere una briscola in C++
04 lug 2018, 15:06
Non devi evitare "troppe" discussioni. Devi evitare che in una sola discussione si parli di tutto. Così diventa ingestibile un thread.

Semmai "devi" aprire più thread, spezzando il problema in tanti sottoproblemi, in modo che il tutto, alla fine, funzioni.
T
typedef
Pochi posts
Iscritto da
giu, 2018
Messaggi:
21
Re: Scrivere una briscola in C++
04 lug 2018, 16:25
Seguirò il consiglio proposto, grazie.
Nippolo
Molto attivo
Iscritto da
mar, 2018
Messaggi:
1238
Re: Scrivere una briscola in C++
05 lug 2018, 14:06
Ora cerco di implementare il gioco come suggerito.
Nel codice che ho postato, oltre alle funzioni preparaMazzo() e mescolaMazzo() che avevi già implementato, ho lasciato il main e la funzione partita() in modo che tu potessi capire il modo in cui ho pensato di impostare il programma. Per quanto riguarda le altre funzioni invece ho sostituito il codice con un commento che spiega lo scopo della funzione; ciò, insieme alla dichiarazione delle stesse funzioni, dovrebbe essere sufficiente per comprendere l'algoritmo che ho ideato.
Ovviamente non sei costretto a seguire questa linea, d'altronde uno stesso programma può essere sviluppato in diversi modi... lo scopo del codice fondamentalmente era quello di accelerare un po' il processo di indirizzamento verso la soluzione del problema. I problemi del tuo codice (tra cui ridondanza e poca chiarezza) secondo me derivano soprattutto dal fatto che non hai una visione d'insieme, nel senso che hai iniziato ad implementare qualche funzione, ma non hai ancora ben chiaro l'algoritmo complessivo.
Per esempio ho visto che hai aperto un topic in cui chiedi aiuto per l'implementazione della CPU; se il resto è già fatto e funzionante ok, nel caso contrario non sarebbe meglio prima soffermarsi sul resto limitandosi a selezionare una carta a caso dalla mano del PC (come ho anche suggerito nel commento inserito nel codice)?!
Fatta questa premessa, ti sei fatto un'idea di come dovrebbe funzionare il codice che ho postato e di come implementare le funzioni rimaste in sospeso? Hai capito lo scopo della struct gruppo? Hai notato che l'array che tu chiami "terra" può (nel caso in cui i giocatori sono solo 2) essere evitato?
T
typedef
Pochi posts
Iscritto da
giu, 2018
Messaggi:
21
Re: Scrivere una briscola in C++
05 lug 2018, 14:23
Ho compreso il codice che mi hai suggerito (mi permetto di usare il tu bonariamente) anche se mi rimangono alcune lacune, l'uso della struct gruppo non mi è chiarissima, tuttavia in linea di massima mi è abbastanza chiaro nella visione di insieme.

Concordo sul fatto che non sia chiaro e che mi manchi una visione di insieme, infatti sto cercando di migliorare il codice seguendo l'ordine di quello suggerito.

Si, ho notato la mancanza dell'array terra..

Ho seguito il consiglio di partire prima da una scelta random e ha funzionato, solo che dal professore è richiesto l'uso di una sequenza di if per simulare ''intelligenza'' da parte del computer..
Nippolo
Molto attivo
Iscritto da
mar, 2018
Messaggi:
1238
Re: Scrivere una briscola in C++
05 lug 2018, 15:02
(mi permetto di usare il tu bonariamente)
Utilizza pure il pronome personale che preferisci!
Ho seguito il consiglio di partire prima da una scelta random e ha funzionato ...
Funzionato in che senso? Potresti postare per intero il codice aggiornato?
l'uso della struct gruppo non mi è chiarissima, tuttavia in linea di massima mi è abbastanza chiaro nella visione di insieme.
Un esempio:
- a fine partita l'array "prese" (con capacità di 40 carte) del generico giocatore conterrà x carte (con x compreso tra 0 e 40); se non conosci x come fai a sapere quando fermarti nel momento in cui vai a scorrere l'array per calcolare i punti a fine partita? Ecco il motivo del membro "dim".
In alternativa si sarebbe potuto inizializzare a 0 il membro "valore" dei vari elementi di "prese"; in questo caso nel calcolo dei punti andremo a scorrere l'array "prese" fino a quando valore!=0.
Un altro modo ancora di procedere potrebbe essere quello di prevedere un membro "punteggio" inizializzato a 0 nella struct "giocatore". In pratica ad ogni turno andremo a sommare al punteggio del "vincitore" la somma dei punti delle 2 carte che costituiscono la presa. In questo modo inoltre non ci sarà più bisogno né di una funziona calcolaPunti() né dell'array "prese".
Come vedi ci possono essere più soluzioni (più o meno performanti) per uno stesso problema, basta ragionare!

typedef

Pochi posts

Iscritto da: giu, 2018

Messaggi:: 21

Re: Scrivere una briscola in C++

05 lug 2018, 15:21

Per ora sto riorganizzando la briscola, ho provato il caso in cui il primo a giocare sia il computer e sono riuscito a spostare le carte dalla mano del Pc a a terra per poi sommare i punti, mi manca ancora molto, devo rivedere il criterio di presa e reiterare il gioco fino ad esaurire le carte, allego il codice che ho scritto parzialmente fino ad ora, tuttavia ancora è solo una bozza:

#include<iostream>
#include<windows.h> 						//Contiene alcune utili librerie
#include<cstdlib>							//Contiene il prototipo della funzione srand
#include<ctime>								//Contiene il prototipo della funzione time
#include<iomanip>							//Contiene il prototipo della funzione setw

using namespace std;


struct carte {									//Definisce la struttura delle carte
	int valore;
	int punti;
	char seme;
};


carte briscola;
carte mazzo [40];						//Il mazzo è composto da 40 carte
carte terra [2];						//Sul 'tavolo' sono presenti 2 carte
carte manoPC [3];						//Il computer ha 3 carte in 'mano'
carte manoGiocatore [3];				//Il giocatore  ha 3 carte in 'mano'
carte presaPC [40];						//Numero massimo di carte del PC
carte presaG [40]; 			  			//Numero massimo di carte del giocatore

int puntiPc;						    //Punti di partenza del PC
int puntiGiocatore;						//Punti di partenza del giocatore
bool mazzierePc;						//Il computer è il mazziere
bool primoGiocatore;					//Serve a stabilire il turno del giocatore umano
bool primaUmano;
bool prendeGiocatore;
bool prendePc;
int x = 6;
int box;

void mescolaMazzo() {															//Mescola il mazzo di carte
	
	/* Questa funzione restituisce un vettore che rappresenta un mazzo di carte mescolato.
	Il mazzo viene mescolato scambiando l'elemento di indice 0 con quello di indice casuale compreso tra 0 e 39, poi
	si scambiare l'elemento di indice 1 con quello di indice casuale compreso tra 1 e 39 e si continua fino a scambiare 
	tutti gli elementi tra loro. */
      
 //  srand(time(0));
	
	int j;
		
	for (int i=0; i<39; i++)
	{
	j = i + rand()%(40 - i);  
					
    carte valore = mazzo[i];								
    mazzo[i] = mazzo[j];
    mazzo[j] = valore ;
    
	}

}


void preparaMazzo () {																	//Rappresenta le carte del mazzo
	
	/* Il mazzo è un array di 40 elementi. Esso viene diviso in gruppi di 10
	calcolando il resto della divisione per 10. Si aggiunge 1 al risultato perchè
	l'array comprende 40 valori da 0 a 39.  Il valore risultante corrisponde al VALORE.
	Il seme della carta viene definito usando l'intervallo di valori 0-9 per denari,
	10-19 per bastoni 20-29 per coppe e 30-39 per spade.*/
			
	for (int i=0; i<40; i++){
		mazzo[i].valore = i%10+1;	
						
	int seme = i/10;	
								
		switch (seme) 
	{
		case 0 : mazzo[i].seme = 'D';				//Denari
				break;
		case 1 : mazzo[i].seme = 'B';				//Bastoni
				break;
		case 2 : mazzo[i].seme = 'C';				//Coppe
				break;
		case 3 : mazzo[i].seme = 'S';				//Spade
				break;
	}
	
	int valore = mazzo[i].valore; 					//Stabilisce il punteggio associato ad ogni carta
 	  
		switch (valore)
	 {
	 	case 1 : mazzo[i].punti = 11;
	 		break;
	 	case 3 : mazzo[i].punti = 10;
	 		break;
	 	case 10 : mazzo[i].punti = 4;
	 		break;
	 	case 9 : mazzo[i].punti = 3;
	 		break;
	 	case 8 : mazzo[i].punti=2;
	 		break;
	 	default : mazzo[i].punti = 0;
	 }
	}
		mescolaMazzo();
}


void distribuireCarte() {         				 								// Funzione per dare le carte ai giocatori

        for (int i=0; i<3; i++){           										//utilizzo del for per variare in numero di carte preso nella prima mano.
        manoGiocatore[i] = mazzo[i*2];   										// caso in cui le carte vengono date prima all'utente e poi all'avversario.
        manoPC[i] = mazzo[i*2+1];
        } 
    }


void mostraBriscola () {														//Mostra la briscola 
	briscola.valore = mazzo[39].valore;											//Seleziona la carta in cima al mazzo
	briscola.seme = mazzo[39].seme;
	briscola.punti = mazzo[39].punti;
	cout<<endl<<"La briscola e' : "<<briscola.valore<<" di "<<briscola.seme<<endl<<endl;
}		

int scegliCarta () {															//Permette all'utente di scegliere la carta da giocare
	/*La scelta della carta avviene tramite un costrutto if..else che permette
	di stabilire la posizione della carta sul tavolo (primo o secondo turno).
	Dopo che si sceglie la carta da giocare viene prelevata la carta corrispondente
	nell'array manoGiocatore. */
	
	int scelta;
	for (int j=0; j<3; j++){
		cout<<j+1<<setw(5)<<manoGiocatore[j].valore<<" di "<<manoGiocatore[j].seme<<endl;
	}
	cout<<"Quale carta desideri giocare? \n";
	cin>>scelta;
	
//	if (primoGiocatore == true) 
//	{
		box = manoGiocatore[scelta-1].valore;
		terra[0].valore = manoGiocatore[scelta-1].valore;
		terra[0].valore = box;
		
		box = manoGiocatore[scelta-1].seme;
		terra[0].seme = manoGiocatore[scelta-1].seme;
		terra[0].seme = box;
		
		box = manoGiocatore[scelta-1].punti;
		terra[0].punti = manoGiocatore[scelta-1].punti;
		terra[0].punti = box;
		
		
		/*terra[0].seme=manoGiocatore[scelta-1].seme; 
		terra[0].punti=manoGiocatore[scelta-1].punti;*/
//	} 
/*	else 
	{
		box = manoGiocatore[scelta-1].valore;
		terra[1].valore = manoGiocatore[scelta-1].valore;
		terra[1].valore = box;
		
		box = manoGiocatore[scelta-1].seme;
		terra[1].seme = manoGiocatore[scelta-1].seme;
		terra[1].seme = box;
		
		box = manoGiocatore[scelta-1].punti;
		terra[1].punti = manoGiocatore[scelta-1].punti;
		terra[1].punti = box;
		
	 */
//	}
	
	cout<<"Hai tirato "<<manoGiocatore[scelta-1].valore<<" di "<<manoGiocatore[scelta-1].seme<<endl;
	return (box);
	//return (scelta-1);
}


primaManoPC (){
	
	int i = rand()%3;
	cout<<endl;
		
	cout<<"Il PC gioca: "<<manoPC[i].valore<<manoPC[i].seme<<endl<<endl;
	
	box = manoPC[i].valore;
	manoPC[i].valore = terra[0].valore;
	terra[0].valore = box;
		
	box = manoPC[i].seme;
	manoPC[i].seme = terra[0].seme;
	terra[0].seme = box;
	
	box = manoPC[i].punti;
	manoPC[i].punti = terra[0].punti;
	terra[0].punti = box;

}

int PcGiocaSecondo (){																//Il calcolatore decide la carta da giocare se è il secondo a tirare

						
	for (int i=0; i<3; i++){
	cout<<manoPC[i].valore<<manoPC[i].seme<<endl;
	}						
												     	


if (terra[0].seme != briscola.seme){ 												//Seme briscola diverso dal seme a terra

cout<<"Il seme e diverso";				// solo controllo funzionamento

for (int i=0; i<3; i++){
			if ((terra[0].seme == manoPC[i].seme) && (manoPC[0].punti > terra[0].punti))
			{
				box = manoPC[i].valore;
				manoPC[i].valore = terra[1].valore;
				terra[1].valore = box;
		
				box = manoPC[i].seme;
				manoPC[i].seme = terra[1].seme;
				terra[1].seme = box;
	
				box = manoPC[i].punti;
				manoPC[i].punti = terra[1].punti;
				terra[1].punti = box;
				
				cout<<"L'avversario ha lanciato la carta "<<manoPC[i].valore<<manoPC[i].seme<<endl;
			}
	
	
			if ((terra[0].seme == manoPC[i].seme) && (manoPC[0].punti < terra[0].punti))				//Punteggio in mano minore di quello a terra
			{												
				box = manoPC[i].valore;
				manoPC[i].valore = terra[1].valore;
				terra[1].valore = box;
		
				box = manoPC[i].seme;
				manoPC[i].seme = terra[1].seme;
				terra[1].seme = box;
	
				box = manoPC[i].punti;
				manoPC[i].punti = terra[1].punti;
				terra[1].punti = box;	
				
				cout<<"L'avversario ha lanciato la carta "<<manoPC[i].valore<<manoPC[i].seme<<endl;
			}
		
				 if ((terra[0].seme == manoPC[i].seme) && (manoPC[0].punti = terra[0].punti) && (manoPC[i].valore < terra[0].valore))  									//Valore carte in mano più basso di quello a terra
        	{  
				box = manoPC[i].valore;
				manoPC[i].valore = terra[1].valore;
				terra[1].valore = box;
		
				box = manoPC[i].seme;
				manoPC[i].seme = terra[1].seme;
				terra[1].seme = box;
	
				box = manoPC[i].punti;
				manoPC[i].punti = terra[1].punti;
				terra[1].punti = box;
				
				cout<<"L'avversario ha lanciato la carta "<<manoPC[i].valore<<manoPC[i].seme<<endl;
        	}
        	
    }  
}
    if ((terra[0].seme == briscola.seme) && (manoPC[0].punti < terra[0].punti))
       	{
       		
       		cout<<"Il seme e uguale ";   		// solo controllo funzionamento
       		
       		for (int i=0; i<3; i++){
       		
       			box = manoPC[i].valore;
				manoPC[i].valore = terra[1].valore;
				terra[1].valore = box;
		
				box = manoPC[i].seme;
				manoPC[i].seme = terra[1].seme;
				terra[1].seme = box;
	
				box = manoPC[i].punti;
				manoPC[i].punti = terra[1].punti;
				terra[1].punti = box;
				
				cout<<"L'avversario ha lanciato la carta "<<manoPC[i].valore<<manoPC[i].seme<<endl;
		}
	}	
}

mostraterra(){
	cout<<endl<<endl;
	cout<<"------TERRA-------\n";
	cout<<terra[0].valore<<" di "<<terra[0].seme<<" vale punti: "<<terra[0].punti<<endl;
	cout<<terra[1].valore<<" di "<<terra[1].seme<<" vale punti: "<<terra[1].punti<<endl;
	
	int punti = 0;
	punti += punti + terra[0].punti + terra[1].punti;
	
	cout<<endl<<"Punti totali: "<<punti<<endl;
	
	cout<<"------------------"<<endl;
}
main (){
	
	srand (time (0));
	
	preparaMazzo();
	
	distribuireCarte();
	
	mostraBriscola ();
	
//	primaManoPC ();
	
	scegliCarta ();
	
	PcGiocaSecondo ();
	
	mostraterra();
	
	return 0;
}

Nel codice avevo escluso il turno del Pc come giocatore per verificare il funzionamento del criterio di lancio..

Ora grazie agli esempi mi è più chiaro l'uso della struttura gruppo e giocatore

Nippolo

Molto attivo

Iscritto da: mar, 2018

Messaggi:: 1238

Re: Scrivere una briscola in C++

05 lug 2018, 22:16

Sulla scia dell'esempio che ti ho fatto nel post precedente ho semplificato ulteriormente il programma. Ti posto il codice aggiornato:

#include <iostream>
#include <ctime>
#include <windows.h>

using namespace std;

struct carta
{
   unsigned int valore;
   unsigned int seme;
   unsigned int punti;
};

struct giocatore
{
    carta mano[3];
    unsigned int dim_mano = 0;
    unsigned int scelta_mano;
    unsigned int punteggio;
    unsigned int vittorie = 0;
};

carta briscola;
carta mazzo[40];
unsigned int dim_mazzo;
giocatore G1;
giocatore PC;

void colore(const unsigned int n)
{
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), n);
}

void mostra_carta(const carta &c)
{
    colore(c.seme);
    cout << c.valore << endl;
    colore(7);
}

void scambia_carte(carta &c_1, carta &c_2)
{
    //scambia il contenuto di 2 carte
}

void mescola_mazzo()
{
    unsigned int j;
    for(unsigned int i = 0; i < 39; ++i)
    {
        j = rand() % (40 - i) + i;
        scambia_carte(mazzo[i], mazzo[j]);
    }
}

void prepara_mazzo()
{
    for(unsigned int i = 0; i < 40; ++i)
    {
        switch(mazzo[i].valore = i % 10 + 1)
        {
            case 1  : mazzo[i].punti = 11;
            break;
            case 3  : mazzo[i].punti = 10;
            break;
            case 10 : mazzo[i].punti = 4;
            break;
            case 9  : mazzo[i].punti = 3;
            break;
            case 8  : mazzo[i].punti = 2;
            break;
            default : mazzo[i].punti = 0;
        }
        switch(i / 10)
        {
            case 0 : mazzo[i].seme = 10; //BASTONI
            break;
            case 1 : mazzo[i].seme = 11; //SPADE
            break;
            case 2 : mazzo[i].seme = 12; //COPPE
            break;
            case 3 : mazzo[i].seme = 14; //DENARI
        }
    }
    mescola_mazzo();
    dim_mazzo = 40;
}

void distribuisci_carte(giocatore &G)
{
    //distribuisce carte al giocatore G finché non ne ha 3 in mano. In pratica alla carta in mano di indice G.dim_mano 
    //viene assegnata l'ultima carta del mazzo(di indice dim_mazzo-1). 
    //G.dim_mano e dim_mazzo vanno quindi opportunamente aggiornate   
}

void scelta_G1(const bool prima_G1)
{
    //chiede a G1 di scegliere quale carta giocare dalla mano. Viene visualizzata la briscola e la scelta 
    //del PC se il PC gioca per primo
}

void scelta_PC()
{
    //scelta della carta da parte del PC. Inizialmente mi limiterei a selezionare una carta a caso dalla mano e poi 
    //quando tutto funziona correttamente potrai divertirti a implementare una CPU
}

void risolvi_mano(giocatore &G_1, giocatore &G_2, bool &prima_G1)
{
    //(G_1 e G_2 sono rispettivamente il giocatore che ha tirato per primo e quello che ha tirato per secondo)
    //stabilisce chi vince la mano, aggiorna il punteggio del vincitore e modifica la variabile prima_G1 di conseguenza. 
    //Se la generica scelta_mano non coincide con l'ultima carta della mano(ossia quella di indice G.dim_mano-1), 
    //queste vengono scambiate.
}

void partita(bool &prima_G1)
{
    prepara_mazzo();
    briscola = mazzo[0];
    G1.punteggio = 0;
    PC.punteggio = 0;
    while(G1.dim_mano || G1.punteggio + PC.punteggio < 120)
    {
        if(prima_G1)
        {
            if(dim_mazzo)
            {
                distribuisci_carte(G1);
                distribuisci_carte(PC);
            }
            scelta_G1(prima_G1);
            scelta_PC();
            risolvi_mano(G1, PC, prima_G1);
        }
        else
        {
            if(dim_mazzo)
            {
                distribuisci_carte(PC);
                distribuisci_carte(G1);
            }
            scelta_PC();
            scelta_G1(prima_G1);
            risolvi_mano(PC, G1, prima_G1);
        }
    }
    if(G1.punteggio < 60)
    {
        cout << "HAI PERSO!" << endl;
        ++PC.vittorie;
        prima_G1 = false;
    }
    else if(G1.punteggio == 60)
    {
        cout << "PAREGGIO" << endl;
    }
    else
    {
        cout << "HAI VINTO!" << endl;
        ++G1.vittorie;
        prima_G1 = true;
    }
}

int main()
{
    srand(time(0));
    bool prima_G1 = rand() % 2;
    while(G1.vittorie < 3 && PC.vittorie < 3)
    {
        partita(prima_G1);
        cout << "G1:" << G1.vittorie << "  -  PC:" << PC.vittorie << endl << endl;
    }
}

Ho aggiunto qualche dettaglio in più ai commenti in modo che ti possa risultare più facile comprendere l'algoritmo e implementarlo.
Se hai dubbi relativi all'implementazione delle singole funzioni chiedi pure.

Devi accedere o registrarti per scrivere nel forum

33 risposte