Briscola c++ problemi intelligenza artificiale
ragazzi salve a tutti ho scritto un programma di briscola in c++ e ora vorrei capire grazie a voi perchè nonostante abbia inserito l'intelligenza artificiale il pc gioca prendendo le carte k ha in mano in ordine per come vengono cioè la prima la seconda la terza e poi riinizia 
. scrivo qui di seguito il programma. 
. il prog e stato compilato cn dev c++.
. scrivo qui di seguito il programma. . il prog e stato compilato cn dev c++.#include <cstdlib>
#include <iostream>
#include <math.h>
#include <time.h>
using namespace std;
// mano: quella parte del gioco in cui i 2 giocatori tirano una carta ciascuno
// partita: quella fase di gioco in cui si usa tutto il mazzo
// gioco
struct carte
{ int val;
char seme;
int punteggio;
} briscola;
carte mazzo [46];
carte terra [2];
carte in_manoC[3];
carte in_manoU[3];
carte preseC[40];
carte preseU[40];
int puntC =0;
int puntU =0;
void i_a_attacco();
void i_a_difesa();
bool mazziereC;
bool primaU;
int cima_mazzo = 6;
int mani;
int carta_giocataC=2;
int carta_presaC=45;
void creamazzo ()
{ int aus;
for (int i=0; i<40; i++)
{mazzo[i].val = i%10 +1 ;
aus = i/10;
switch (aus)
{ case 0: mazzo[i].seme = 'd' ; break;
case 1: mazzo[i].seme = 'c' ; break;
case 2: mazzo[i].seme = 'b' ; break;
case 3: mazzo[i].seme = 's' ; break;
}
}
for (int i=40; i<46; i++)
{mazzo[i].val = 0 ;
mazzo[i].seme = ' ';
}
}
void stampamazzo()
{ char scelta;
cout << "\t\t...vuoi vedere le carte del mazzo si(s),no(n)?...scelta =";
cin >> scelta;
if (scelta=='s')
{cout << '\n';
for (int i=0; i<40; i++)
cout << mazzo[i].val << mazzo[i].seme << '\t' ;
cout << '\n';
}}
void mescolamazzo () // funzione per mescolare le carte create dalla funzione precedente.
{ int pos1, pos2, ausV;
char ausS;
for (int i=0; i<245; i++)
{pos1 = rand()% 40;
pos2 = rand()% 40;
ausV = mazzo[pos1].val;
ausS = mazzo[pos1].seme;
mazzo[pos1].val = mazzo[pos2].val;
mazzo[pos1].seme = mazzo[pos2].seme;
mazzo[pos2].val = ausV;
mazzo[pos2].seme = ausS;
}
}
void mostrabriscola ()
{ briscola.val = mazzo[39].val;
briscola.seme = mazzo[39].seme;
cout << "\n briscola = " << briscola.val << briscola.seme << '\n';
}
void stampamano()
{cout << "\n-----------------------------mano " << mani+1 << "--------------------\n\ntue carte : ";
for (int i=0; i<3; i++)
cout << in_manoU[i].val << in_manoU[i].seme << " | ";
cout << "# BRISCOLA: " << briscola.val << briscola.seme <<" # carte avversario : ";
{char scleta;
cout << "\n vuoi vedere le carte avversario si(s),no(n)? scleta=";
cin >> scleta;
if (scleta=='s')
for (int i=0; i<3; i++)
cout << in_manoC[i].val << in_manoC[i].seme << " | ";
cout << "\n\n";
}
}
int punteggio (int vn)
{ for (int i=0; i<40; i++)
{
if (mazzo[i].val == 1)
mazzo[i].punteggio = 11;
if (mazzo[i].val == 3)
mazzo[i].punteggio = 10;
if (mazzo[i].val == 10)
mazzo[i].punteggio = 4;
if (mazzo[i].val == 9)
mazzo[i].punteggio = 3;
if (mazzo[i].val == 8)
mazzo[i].punteggio = 2;
if (mazzo[i].val != 1 && mazzo[i].val != 3 && mazzo[i].val != 10 && mazzo[i].val != 9 && mazzo[i].val != 8)
mazzo[i].punteggio = 0;
}
}
bool supera1 (int vn1, int vn2)
{ int p1, p2;
vn1 = terra[1].val;
vn2 = terra[0].val;
p1 = terra[1].punteggio;
p2 = terra[0].punteggio;
bool m1;
p1 = punteggio(vn1);
p2 = punteggio(vn2);
if ((p1 != 0) || (p2 != 0)) m1 = (p1 > p2);
else m1 = (vn1 > vn2);
return (m1);
}
bool prendeI()
{ bool magg1,magg2, br2, eg ;
magg1 = supera1(terra[0].val,terra[1].val);
magg2= supera1(terra[0].punteggio, terra[1].punteggio);
br2 = (briscola.seme==terra[1].seme);
eg = (terra[0].seme==terra[1].seme);
return ((eg && magg1)||(!eg && !br2)|| (eg && magg2));
}
bool tiraprima ()
{ bool primo;
primo = rand() % 2;
if (primo) cout << "\n giochi per primo TU!\n " ;
else cout << "\n gioca per primo l'AVVERSARIO! \n " ;// inverti Umano /Comp
return primo;
}
void dai_carte ()
{ if (mazziereC)
for (int i=0; i<3; i++)
{in_manoU[i].val = mazzo[i*2].val;
in_manoU[i].seme = mazzo[i*2].seme;
in_manoC[i].val = mazzo[i*2+1].val;
in_manoC[i].seme = mazzo[i*2+1].seme;
}
else
for (int i=0; i<3; i++)
{in_manoU[i].val = mazzo[i*2+1].val;
in_manoU[i].seme = mazzo[i*2+1].seme;
in_manoC[i].val = mazzo[i*2].val;
in_manoC[i].seme = mazzo[i*2].seme;
}
}
int richiestaU ()
{int pos;
cout << " Quale carta giochi? 1 o 2 o 3 ? Pos carta = ";
cin >> pos;
if (primaU)
{terra[0].val = in_manoU[pos-1].val;
terra[0].seme = in_manoU[pos-1].seme;
}
else
{terra[1].val = in_manoU[pos-1].val;
terra[1].seme = in_manoU[pos-1].seme;
}
cout << "Hai tirato " << in_manoU[pos-1].val << in_manoU[pos-1].seme;
cout << '\n';
return(pos-1);
}
//____________________________________________________________________________________________________________________________
int CgiocaII()
{ i_a_difesa ();
/*{ for (int i=0; i<=2; i++)
if (in_manoC[i].punteggio == terra[0].punteggio && in_manoC[i].val == terra [0].val && in_manoC[i].seme == terra [0].seme)
{
in_manoC[i].val; //cerca nella mano la carta tirata confrontando col tavolo.
}
}*/
cout << "Il computer ha tirato " << in_manoC[mani%3].val << in_manoC[mani%3].seme;
cout << '\n';
return (mani%3);
}
//_____________________________________________________________________________________________________________________
int CgiocaI()
{ i_a_attacco ();
/*{ for (int i=0; i<=2; i++)
if (in_manoC[i].punteggio == terra [0].punteggio && in_manoC[i].val == terra [0].val && in_manoC[i].seme == terra [0].seme)
{
in_manoC[i].val; //cerca nella mano la carta tirata confrontando con le carte a terra.
}
}*/
cout << "Il computer ha tirato " << in_manoC[mani%3].val << in_manoC[mani%3].seme;
cout << '\n';
return (mani%3);
}
//__________________________________________________________________________________________________________________________
void i_a_attacco ()
{
terra[0].punteggio = 46;
for(int j = 0; j <= 2; j++) //tirare la carta più piccola non briscola
{
if ( ((in_manoC[j].punteggio < terra[0].punteggio) || ( (in_manoC[j].punteggio == terra[0].punteggio) && (in_manoC[j].val < terra[0].val) ) ) && (in_manoC[j].seme != terra[0].seme) && (in_manoC[j].seme != briscola.seme) )
{
terra[0] = in_manoC[j];
}
}
if (terra[0].punteggio == 46)
{
for(int j = 0; j <= 2; j++) //in alternativa, la più piccola delle briscole
{
if ( ((in_manoC[j].punteggio < terra[0].punteggio) || ( (in_manoC[j].punteggio == terra[0].punteggio) && (in_manoC[j].val < terra[0].val) ) ) && (in_manoC[j].seme != terra[0].seme) )
{
terra[0] = in_manoC[j];
}
}
}
}
void i_a_difesa()
{
if ( ( (terra[1].punteggio < 10) && !(terra[1].seme == briscola.seme) ) || ((terra[1].punteggio >= 10) && (terra[1].seme == briscola.seme)) ) //se il giocatore tira un non carico non briscola, o un carico briscola
{
terra[0].punteggio = 46;
for(int j = 0; j <= 2; j++)
{
if ( ( ( (in_manoC[j].punteggio > terra[1].punteggio) && (in_manoC[j].seme == terra[1].seme) )|| ( ( (in_manoC[j].punteggio == terra[1].punteggio) && (in_manoC[j].val < terra[1].val) && (in_manoC[j].seme == terra[1].seme) ) ) ) && (in_manoC[j].seme != terra[1].seme) ) //provo a batterlo sul palo
{
terra[0] = in_manoC[j];
}
}
if (terra[0].punteggio == 46)
i_a_attacco (); //altrimenti perdo il meno possibile
}
if ((terra[1].punteggio >= 10) && !(terra[1].seme == briscola.seme)) //se tiro un carico non briscola
{
terra[0].punteggio = 46;
for(int j = 0; j <= 2; j++)
{
if ( ( ( (in_manoC[j].punteggio > terra[1].punteggio) && (in_manoC[j].seme == terra[1].seme) )|| ( ( (in_manoC[j].punteggio == terra[1].punteggio) && (in_manoC[j].val < terra[1].val) && (in_manoC[j].seme == terra[1].seme) ) ) ) && (in_manoC[j].seme != terra[1].seme) ) //provo a batterlo sul palo
{
terra[0] = in_manoC[j];
}
}
if (terra[0].punteggio == 46)
{
for(int j = 0; j <= 2; j++)
{
if ( ((in_manoC[j].punteggio < terra[0].punteggio) || ( (in_manoC[j].punteggio == terra[0].punteggio) && (in_manoC[j].val < terra[0].val) ) ) && (in_manoC[j].seme != ' ') && (in_manoC[j].seme == briscola.seme) ) //provo a tirare la più piccola delle briscole che possiedo per prendere
{
terra[0] = in_manoC[j];
}
}
}
if (terra[0].punteggio == 46)
{
for(int j = 0; j <= 2; j++)
{
if ( ((in_manoC[j].punteggio < terra[0].punteggio) || ( (in_manoC[j].punteggio == terra[0].punteggio) && (in_manoC[j].val < terra[0].val) ) ) && (in_manoC[j].seme != terra[1].seme) ) //altrimenti tiro la più piccola che ho in mano
{
terra[0] = in_manoC[j];
}
}
}
}
if ( (terra[1].punteggio < 10) && (terra[1].seme == briscola.seme) ) //se tira un non carico briscola
i_a_attacco (); //intelligenza dell'attacco
}
void chiprende(int ncU,int ncC)
{if (prendeI()==primaU)
{puntU=puntU+punteggio(terra[0].val)+punteggio(terra[1].val);
in_manoU[ncU].seme=mazzo[cima_mazzo].seme;
in_manoU[ncU].val =mazzo[cima_mazzo].val ;
in_manoU[ncU].punteggio = mazzo [cima_mazzo].punteggio;
cima_mazzo++;
in_manoC[ncC].seme=mazzo[cima_mazzo].seme;
in_manoC[ncC].val =mazzo[cima_mazzo].val ;
in_manoC[ncC].punteggio = mazzo [cima_mazzo].punteggio;
cima_mazzo++;
cout << "\t\t...prendi TU...";
primaU=true;
}
else
{puntC=puntC+punteggio(terra[0].val)+punteggio(terra[1].val);
in_manoC[ncC].seme=mazzo[cima_mazzo].seme;
in_manoC[ncC].val =mazzo[cima_mazzo].val ;
in_manoC[ncC].punteggio = mazzo [cima_mazzo].punteggio;
cima_mazzo++;
in_manoU[ncU].seme=mazzo[cima_mazzo].seme;
in_manoU[ncU].val =mazzo[cima_mazzo].val ;
in_manoU[ncU].punteggio = mazzo [cima_mazzo].punteggio;
cima_mazzo++;
cout << "...prende l'AVVERSARIO...";
primaU=false;
}
//stampamano();
}
void mano ()
{ int numU, numC;
if (primaU){
numU=richiestaU();
numC=CgiocaII();
}
else
{numC=CgiocaI();
numU=richiestaU();
}
chiprende(numU,numC);
//cout << "\n--------------------------------------------------------\n";
}
void partita ()
{ cima_mazzo=6;
dai_carte();
primaU=mazziereC;
for (int i=0; i<20; i++)
{mani=i;
stampamano();
mano();
}
cout << "\n ...la partita e' finita...\n\n";
}
main(int argc, char *argv[])
{ system("color 2F");
creamazzo();
stampamazzo();
srand (time (0));
mazziereC=tiraprima();
//stampamano();
{
mescolamazzo();
stampamazzo();
mostrabriscola();
partita();
mazziereC = ! mazziereC;
}
if (puntU>puntC) cout << "hai vinto TU\n\n";
else cout << "ha vinto l'AVVERSARIO\n\n";
system("PAUSE");
return EXIT_SUCCESS;
}
Risposte
Ciao, per favore edita il tuo post e racchiudi il codice tra i tag CODE.
es.
PS. Benvenuto nel forum!
es.
cout<<"ciao\n";
PS. Benvenuto nel forum!
Per Minomic grazie per il benvenuto. ho fatto come mi e stato chiesto per l'edit
questo e l'ultimo codice con le modifiche apportate ai bool per facilitarne le prese e migliorarlo ora persiste il problema sull'intelligenza artificialecosa mi consigliate?
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <time.h>
using namespace std;
// mano: quella parte del gioco in cui i 2 giocatori tirano una carta ciascuno
// partita: quella fase di gioco in cui si usa tutto il mazzo
// gioco
struct carte
{ int val;
char seme;
int punteggio;
} briscola;
carte mazzo [46];
carte terra [2];
carte in_manoC[3];
carte in_manoU[3];
carte preseC[40];
carte preseU[40];
int puntC =0;
int puntU =0;
void i_a_attacco();
void i_a_difesa();
bool mazziereC;
bool primaU;
int cima_mazzo = 6;
int mani;
int carta_giocataC=2;
int carta_presaC=45;
void creamazzo ()
{ int aus;
for (int i=0; i<40; i++)
{mazzo[i].val = i%10 +1 ;
aus = i/10;
switch (aus)
{ case 0: mazzo[i].seme = 'd' ; break;
case 1: mazzo[i].seme = 'c' ; break;
case 2: mazzo[i].seme = 'b' ; break;
case 3: mazzo[i].seme = 's' ; break;
}
}
for (int i=40; i<46; i++)
{mazzo[i].val = 0 ;
mazzo[i].seme = ' ';
}
}
void stampamazzo()
{ char scelta;
cout << "\t\t...vuoi vedere le carte del mazzo si(s),no(n)?...scelta =";
cin >> scelta;
if (scelta=='s')
{cout << '\n';
for (int i=0; i<40; i++)
cout << mazzo[i].val << mazzo[i].seme << '\t' ;
cout << '\n';
}}
void mescolamazzo () // funzione per mescolare le carte create dalla funzione precedente.
{ int pos1, pos2, ausV;
char ausS;
for (int i=0; i<245; i++)
{pos1 = rand()% 40;
pos2 = rand()% 40;
ausV = mazzo[pos1].val;
ausS = mazzo[pos1].seme;
mazzo[pos1].val = mazzo[pos2].val;
mazzo[pos1].seme = mazzo[pos2].seme;
mazzo[pos2].val = ausV;
mazzo[pos2].seme = ausS;
}
}
void mostrabriscola ()
{ briscola.val = mazzo[39].val;
briscola.seme = mazzo[39].seme;
cout << "\n briscola = " << briscola.val << briscola.seme << '\n';
}
void stampamano()
{cout << "\n-----------------------------mano " << mani+1 << "--------------------\n\ntue carte : ";
for (int i=0; i<3; i++)
cout << in_manoU[i].val << in_manoU[i].seme << " | ";
cout << "# BRISCOLA: " << briscola.val << briscola.seme <<" # carte avversario : ";
{char scleta;
cout << "\n vuoi vedere le carte avversario si(s),no(n)? scleta=";
cin >> scleta;
if (scleta=='s')
for (int i=0; i<3; i++)
cout << in_manoC[i].val << in_manoC[i].seme << " | ";
cout << "\n\n";
}
}
int punteggio (int vn)
{ for (int i=0; i<40; i++)
{
if (mazzo[i].val == 1)
mazzo[i].punteggio = 11;
if (mazzo[i].val == 3)
mazzo[i].punteggio = 10;
if (mazzo[i].val == 10)
mazzo[i].punteggio = 4;
if (mazzo[i].val == 9)
mazzo[i].punteggio = 3;
if (mazzo[i].val == 8)
mazzo[i].punteggio = 2;
if (mazzo[i].val != 1 && mazzo[i].val != 3 && mazzo[i].val != 10 && mazzo[i].val != 9 && mazzo[i].val != 8)
mazzo[i].punteggio = 0;
}
}
bool supera1 (int vn1, int vn2)
{ int p1, p2;
for (int j=0; j<40; j++)
{ vn1 = mazzo[j].val;
vn2 = mazzo[j].val;
p1 = mazzo[j].punteggio;
p2 = mazzo[j].punteggio;
}
bool m1;
//p1 = punteggio(vn1);
//p2 = punteggio(vn2);
if ((p1 != 0) || (p2 != 0)) m1 = (p1 > p2);
else m1 = (vn1 > vn2);
return (m1);
}
bool prendeI()
{ bool magg1,magg2, br2, eg ;
magg1 = supera1(terra[0].val,terra[1].val);
//magg2 = punteggio(magg1);
br2 = (briscola.seme==terra[1].seme);
eg = (terra[0].seme==terra[1].seme);
return ((eg && magg1)||(!eg && !br2));
}
bool tiraprima ()
{ bool primo;
primo = rand() % 2;
if (primo) cout << "\n giochi per primo TU!\n " ;
else cout << "\n gioca per primo l'AVVERSARIO! \n " ;// inverti Umano /Comp
return primo;
}
void dai_carte ()
{ if (mazziereC)
for (int i=0; i<3; i++)
{in_manoU[i].val = mazzo[i*2].val;
in_manoU[i].seme = mazzo[i*2].seme;
in_manoC[i].val = mazzo[i*2+1].val;
in_manoC[i].seme = mazzo[i*2+1].seme;
}
else
for (int i=0; i<3; i++)
{in_manoU[i].val = mazzo[i*2+1].val;
in_manoU[i].seme = mazzo[i*2+1].seme;
in_manoC[i].val = mazzo[i*2].val;
in_manoC[i].seme = mazzo[i*2].seme;
}
}
int richiestaU ()
{int pos;
cout << " Quale carta giochi? 1 o 2 o 3 ? Pos carta = ";
cin >> pos;
if (primaU)
{terra[0].val = in_manoU[pos-1].val;
terra[0].seme = in_manoU[pos-1].seme;
}
else
{terra[1].val = in_manoU[pos-1].val;
terra[1].seme = in_manoU[pos-1].seme;
}
cout << "Hai tirato " << in_manoU[pos-1].val << in_manoU[pos-1].seme;
cout << '\n';
return(pos-1);
}
//____________________________________________________________________________________________________________________________
int CgiocaII()
{ i_a_difesa ();
/*{ for (int i=0; i<=2; i++)
if (in_manoC[i].punteggio == terra[0].punteggio && in_manoC[i].val == terra [0].val && in_manoC[i].seme == terra [0].seme)
{
in_manoC[i].val; //cerca nella mano la carta tirata confrontando col tavolo.
}
}*/
cout << "Il computer ha tirato " << in_manoC[mani%3].val << in_manoC[mani%3].seme;
cout << '\n';
return (mani%3);
}
//_____________________________________________________________________________________________________________________
int CgiocaI()
{ i_a_attacco ();
/*{ for (int i=0; i<=2; i++)
if (in_manoC[i].punteggio == terra [0].punteggio && in_manoC[i].val == terra [0].val && in_manoC[i].seme == terra [0].seme)
{
in_manoC[i].val; //cerca nella mano la carta tirata confrontando con le carte a terra.
}
}*/
cout << "Il computer ha tirato " << in_manoC[mani%3].val << in_manoC[mani%3].seme;
cout << '\n';
return (mani%3);
}
//__________________________________________________________________________________________________________________________
void i_a_attacco ()
{
terra[0].punteggio = 46;
for(int j = 0; j <= 2; j++) //tirare la carta più piccola non briscola
{
if ( ((in_manoC[j].punteggio < terra[0].punteggio) || ( (in_manoC[j].punteggio == terra[0].punteggio) && (in_manoC[j].val < terra[0].val) ) ) && (in_manoC[j].seme != terra[0].seme) && (in_manoC[j].seme != briscola.seme) )
{
terra[0] = in_manoC[j];
}
}
if (terra[0].punteggio == 46)
{
for(int j = 0; j <= 2; j++) //in alternativa, la più piccola delle briscole
{
if ( ((in_manoC[j].punteggio < terra[0].punteggio) || ( (in_manoC[j].punteggio == terra[0].punteggio) && (in_manoC[j].val < terra[0].val) ) ) && (in_manoC[j].seme != terra[0].seme) )
{
terra[0] = in_manoC[j];
}
}
}
}
void i_a_difesa()
{
if ( ( (terra[1].punteggio < 10) && !(terra[1].seme == briscola.seme) ) || ((terra[1].punteggio >= 10) && (terra[1].seme == briscola.seme)) ) //se il giocatore tira un non carico non briscola, o un carico briscola
{
terra[0].punteggio = 46;
for(int j = 0; j <= 2; j++)
{
if ( ( ( (in_manoC[j].punteggio > terra[1].punteggio) && (in_manoC[j].seme == terra[1].seme) )|| ( ( (in_manoC[j].punteggio == terra[1].punteggio) && (in_manoC[j].val < terra[1].val) && (in_manoC[j].seme == terra[1].seme) ) ) ) && (in_manoC[j].seme != terra[1].seme) ) //provo a batterlo sul palo
{
terra[0] = in_manoC[j];
}
}
if (terra[0].punteggio == 46)
i_a_attacco (); //altrimenti perdo il meno possibile
}
if ((terra[1].punteggio >= 10) && !(terra[1].seme == briscola.seme)) //se tiro un carico non briscola
{
terra[0].punteggio = 46;
for(int j = 0; j <= 2; j++)
{
if ( ( ( (in_manoC[j].punteggio > terra[1].punteggio) && (in_manoC[j].seme == terra[1].seme) )|| ( ( (in_manoC[j].punteggio == terra[1].punteggio) && (in_manoC[j].val < terra[1].val) && (in_manoC[j].seme == terra[1].seme) ) ) ) && (in_manoC[j].seme != terra[1].seme) ) //provo a batterlo sul palo
{
terra[0] = in_manoC[j];
}
}
if (terra[0].punteggio == 46)
{
for(int j = 0; j <= 2; j++)
{
if ( ((in_manoC[j].punteggio < terra[0].punteggio) || ( (in_manoC[j].punteggio == terra[0].punteggio) && (in_manoC[j].val < terra[0].val) ) ) && (in_manoC[j].seme != ' ') && (in_manoC[j].seme == briscola.seme) ) //provo a tirare la più piccola delle briscole che possiedo per prendere
{
terra[0] = in_manoC[j];
}
}
}
if (terra[0].punteggio == 46)
{
for(int j = 0; j <= 2; j++)
{
if ( ((in_manoC[j].punteggio < terra[0].punteggio) || ( (in_manoC[j].punteggio == terra[0].punteggio) && (in_manoC[j].val < terra[0].val) ) ) && (in_manoC[j].seme != terra[1].seme) ) //altrimenti tiro la più piccola che ho in mano
{
terra[0] = in_manoC[j];
}
}
}
}
if ( (terra[1].punteggio < 10) && (terra[1].seme == briscola.seme) ) //se tira un non carico briscola
i_a_attacco (); //intelligenza dell'attacco
}
void chiprende(int ncU,int ncC)
{if (prendeI()==primaU)
{puntU=puntU+punteggio(terra[0].val)+punteggio(terra[1].val);
in_manoU[ncU].seme=mazzo[cima_mazzo].seme;
in_manoU[ncU].val =mazzo[cima_mazzo].val ;
in_manoU[ncU].punteggio = mazzo[cima_mazzo].punteggio;
cima_mazzo++;
in_manoC[ncC].seme=mazzo[cima_mazzo].seme;
in_manoC[ncC].val =mazzo[cima_mazzo].val ;
in_manoC[ncC].punteggio = mazzo[cima_mazzo].punteggio;
cima_mazzo++;
cout << "\t\t...prendi TU...";
primaU=true;
}
else
{puntC=puntC+punteggio(terra[0].val)+punteggio(terra[1].val);
in_manoC[ncC].seme=mazzo[cima_mazzo].seme;
in_manoC[ncC].val =mazzo[cima_mazzo].val ;
in_manoC[ncC].punteggio = mazzo[cima_mazzo].punteggio;
cima_mazzo++;
in_manoU[ncU].seme=mazzo[cima_mazzo].seme;
in_manoU[ncU].val =mazzo[cima_mazzo].val ;
in_manoU[ncU].punteggio = mazzo[cima_mazzo].punteggio;
cima_mazzo++;
cout << "...prende l'AVVERSARIO...";
primaU=false;
}
//stampamano();
}
void mano ()
{ int numU, numC;
if (primaU){
numU=richiestaU();
numC=CgiocaII();
}
else
{numC=CgiocaI();
numU=richiestaU();
}
chiprende(numU,numC);
//cout << "\n--------------------------------------------------------\n";
}
void partita ()
{ cima_mazzo=6;
dai_carte();
primaU=mazziereC;
for (int i=0; i<20; i++)
{mani=i;
stampamano();
mano();
}
cout << "\n ...la partita e' finita...\n\n";
}
main(int argc, char *argv[])
{ system("color 2F");
creamazzo();
stampamazzo();
srand (time (0));
mazziereC=tiraprima();
//stampamano();
{
mescolamazzo();
stampamazzo();
mostrabriscola();
partita();
mazziereC = ! mazziereC;
}
if (puntU>puntC) cout << "hai vinto TU\n\n";
else cout << "ha vinto l'AVVERSARIO\n\n";
system("PAUSE");
return EXIT_SUCCESS;
}
Hai provato a fare il debug e a vedere effettivamente come mai sceglie sempre quella carta?
no nn ci ho provato pure perchè a essere sincero sono incompetente a fare il debug potresti cortesemente spiegarmi come effettuarli grazie anticipatamente.
Ho provato a compilare il codice per provarlo e non sono riuscito neanche a compilarlo. Il principale problema che trova è che punteggio non restituisce alcun valore..
faccio una prova inserendo il return(p) alla parte dell int punteggio (int vn) =D
"peppelio93":
faccio una prova inserendo il return(p) alla parte dell int punteggio (int vn) =D
appena fatto aggiunto cio e apportate le corrette modifiche alle booleane il prog da sempre il problema con l'intelligenza artificiale
"peppelio93":
inserito l'intelligenza artificiale
non ho letto il codice, perciò domando.
Hai utilizzato una particolare tecnica, oppure intendi semplicemente sottolineare il modo in cui il tuo codice pesca le carte?
Non mi sembra sia stata implementata una qualche tecnica particolare. Credo si riferisca semplicemente all'implementazione di un giocatore non controllato dall'utente che sceglie quali carte giocare.
allora inizialmente il codice prendeva le carte per come venivano in mano senza alcuna strategia ho provato a inserire un minimo di intelligenza ma mi sa che a livello sintattico ci siamo e non ci siamo a livello di logica per il pc perché non ostante tutto continua a sballare . vi ringrazio tanto se mi sapreste dire come mai da questo comportamento.
. vi ringrazio tanto se mi sapreste dire come mai da questo comportamento.
Un po' di commenti sparsi.
Butta Dev-Cpp (usa ad esempio Code::Blocks) e imposta il compilatore per mostrare i warning. Sempre!
Il secondo warning ti dice che nella funzione "punteggio", che dovrebbe restituire un int, si raggiunge la fine senza incontrare un'istruzione "return". Nella funzione "chiprende" però assegni il valore restituito da "punteggio" a delle variabili. Restituisci il punteggio:
Hai definito una struttura "carte" (che sarebbe meglio chiamare cartA), però fai sempre riferimento ai singoli campi. Il motivo per cui esistono le strutture è proprio per fare riferimento all'aggregato, e non ai singoli campi. Ad esempio la funzione "dai_carte"
sarebbe meglio scriverla così:
Dichiara le variabili "il più tardi possibile", cioè solo quando ti servono, e se possibile usa delle costanti (ti accorgerai più facilmente di piccoli errori, come modificare una variabile che non deve essere modificata).
Ad esempio la funzione "mescolamazzo":
sarebbe meglio scriverla così:
Evita le variabili globali. Un approccio migliore sarebbe definire una struttura "gioco" contenente le informazioni sul mazzo, le carte in mano ai giocatori, le carte prese e la briscola. Crei una variabile di questo tipo nel "main" e la passi alle funzioni.
Meglio ancora creare una classe, e definire le funzioni come funzioni membro, in modo da rendere implicito il passaggio.
Usa le strutture dati offerte dalla libreria standard. Evita sempre gli array, usa invece std::vector.
Soprattutto se dovessi usare array a dimensione dinamica, che in C++ non esistono, dovresti per forza usare l'allocazione dinamica di memoria con new/delete o malloc/free (std::vector è molto più sicuro).
Usa le funzioni offerte dalla libreria standard. Ad esempio nella funzione "mescolamazzo" puoi scambiare due variabili con la funzione std::swap:
Inoltre l'intera funzione è già implementata come std::random_shuffle:
Poni attenzione all'indentazione. In particolare quando apri una graffa non scrivere niente sulla stessa linea, vai a capo:
La funzione "punteggio" ha senso? Nella struttura "carte" c'è già un campo "punteggio", non è meglio assegnare il valore di ogni carta quando la crei?
Perché il mazzo ha 46 carte, e non 40?
Fino alla fine della partita mostri le 3 carte in mano al giocatore. Ma negli ultimi due turni non sono 3, ma rispettivamente 2 e 1.
In generale dovresti tenere traccia di quante carte sono nel mazzo e in mano ai giocatori, e la funzione "partita" dovrebbe essere qualcosa del genere:
Butta Dev-Cpp (usa ad esempio Code::Blocks) e imposta il compilatore per mostrare i warning. Sempre!
> clang++ -std=c++98 -pedantic -Wall -Wextra b.cpp
C:\Users\claudio\Desktop\b.cpp:99:20: warning: unused parameter 'vn' [-Wunused-parameter]
int punteggio (int vn)
^
C:\Users\claudio\Desktop\b.cpp:115:1: warning: control reaches end of non-void function [-Wreturn-type]
}
^
C:\Users\claudio\Desktop\b.cpp:134:14: warning: unused variable 'magg2' [-Wunused-variable]
{ bool magg1,magg2, br2, eg ;
^
3 warnings generated.Il secondo warning ti dice che nella funzione "punteggio", che dovrebbe restituire un int, si raggiunge la fine senza incontrare un'istruzione "return". Nella funzione "chiprende" però assegni il valore restituito da "punteggio" a delle variabili. Restituisci il punteggio:
int punteggio (int vn)
{ for (int i=0; i<40; i++)
{
if (mazzo[i].val == 1)
return mazzo[i].punteggio = 11;
if (mazzo[i].val == 3)
return mazzo[i].punteggio = 10;
if (mazzo[i].val == 10)
return mazzo[i].punteggio = 4;
if (mazzo[i].val == 9)
return mazzo[i].punteggio = 3;
if (mazzo[i].val == 8)
return mazzo[i].punteggio = 2;
if (mazzo[i].val != 1 && mazzo[i].val != 3 && mazzo[i].val != 10 && mazzo[i].val != 9 && mazzo[i].val != 8)
return mazzo[i].punteggio = 0;
}
return 0;
}Hai definito una struttura "carte" (che sarebbe meglio chiamare cartA), però fai sempre riferimento ai singoli campi. Il motivo per cui esistono le strutture è proprio per fare riferimento all'aggregato, e non ai singoli campi. Ad esempio la funzione "dai_carte"
void dai_carte ()
{ if (mazziereC)
for (int i=0; i<3; i++)
{in_manoU[i].val = mazzo[i*2].val;
in_manoU[i].seme = mazzo[i*2].seme;
in_manoC[i].val = mazzo[i*2+1].val;
in_manoC[i].seme = mazzo[i*2+1].seme;
}
else
for (int i=0; i<3; i++)
{in_manoU[i].val = mazzo[i*2+1].val;
in_manoU[i].seme = mazzo[i*2+1].seme;
in_manoC[i].val = mazzo[i*2].val;
in_manoC[i].seme = mazzo[i*2].seme;
}
}sarebbe meglio scriverla così:
void dai_carte()
{
if (mazziereC)
for (int i=0; i<3; i++)
{
in_manoU[i] = mazzo[i*2];
in_manoC[i] = mazzo[i*2+1];
}
else
for (int i=0; i<3; i++)
{ in_manoU[i] = mazzo[i*2+1];
in_manoC[i] = mazzo[i*2];
}
}Dichiara le variabili "il più tardi possibile", cioè solo quando ti servono, e se possibile usa delle costanti (ti accorgerai più facilmente di piccoli errori, come modificare una variabile che non deve essere modificata).
Ad esempio la funzione "mescolamazzo":
void mescolamazzo()
{ int pos1, pos2, ausV;
char ausS;
for (int i=0; i<245; i++)
{pos1 = rand()% 40;
pos2 = rand()% 40;
ausV = mazzo[pos1].val;
ausS = mazzo[pos1].seme;
mazzo[pos1].val = mazzo[pos2].val;
mazzo[pos1].seme = mazzo[pos2].seme;
mazzo[pos2].val = ausV;
mazzo[pos2].seme = ausS;
}
}sarebbe meglio scriverla così:
void mescolamazzo()
{
for (int i = 0; i < 245; i++)
{
const int pos1 = rand() % 40;
const int pos2 = rand() % 40;
const carte aus = mazzo[pos1];
mazzo[pos1] = mazzo[pos2];
mazzo[pos2] = aus;
}
}Evita le variabili globali. Un approccio migliore sarebbe definire una struttura "gioco" contenente le informazioni sul mazzo, le carte in mano ai giocatori, le carte prese e la briscola. Crei una variabile di questo tipo nel "main" e la passi alle funzioni.
Meglio ancora creare una classe, e definire le funzioni come funzioni membro, in modo da rendere implicito il passaggio.
class Gioco
{
public:
void creaMazzo()
{
for (int i = 0; i < 46; ++i) {
mazzo[i] = ...
}
}
void dai_carte()
{
if (mazziereC)
for (int i=0; i<3; i++)
{
in_manoU[i] = mazzo[i*2];
in_manoC[i] = mazzo[i*2+1];
}
else
for (int i=0; i<3; i++)
{ in_manoU[i] = mazzo[i*2+1];
in_manoC[i] = mazzo[i*2];
}
}
...
private:
carte mazzo[46];
carte terra [2];
carte in_manoC[3];
carte in_manoU[3];
...
};Usa le strutture dati offerte dalla libreria standard. Evita sempre gli array, usa invece std::vector.
Soprattutto se dovessi usare array a dimensione dinamica, che in C++ non esistono, dovresti per forza usare l'allocazione dinamica di memoria con new/delete o malloc/free (std::vector è molto più sicuro).
Usa le funzioni offerte dalla libreria standard. Ad esempio nella funzione "mescolamazzo" puoi scambiare due variabili con la funzione std::swap:
void mescolamazzo()
{
for (int i = 0; i < 245; i++)
{
const int pos1 = rand() % 40;
const int pos2 = rand() % 40;
std::swap(mazzo[pos1], mazzo[pos2]);
}
}Inoltre l'intera funzione è già implementata come std::random_shuffle:
// mescolamazzo(); std::random_shuffle(mazzo, mazzo + 46);
Poni attenzione all'indentazione. In particolare quando apri una graffa non scrivere niente sulla stessa linea, vai a capo:
void creamazzo ()
{ int aus;
for (int i=0; i<40; i++)
{mazzo[i].val = i%10 +1 ;
aus = i/10;
switch (aus)
{ case 0: mazzo[i].seme = 'd' ; break;
case 1: mazzo[i].seme = 'c' ; break;
case 2: mazzo[i].seme = 'b' ; break;
case 3: mazzo[i].seme = 's' ; break;
}
}
for (int i=40; i<46; i++)
{mazzo[i].val = 0 ;
mazzo[i].seme = ' ';
}
}void creamazzo()
{
int aus;
for (int i=0; i<40; i++)
{
mazzo[i].val = i%10 + 1;
aus = i/10;
switch (aus)
{
case 0: mazzo[i].seme = 'd';
break;
case 1: mazzo[i].seme = 'c';
break;
case 2: mazzo[i].seme = 'b';
break;
case 3: mazzo[i].seme = 's';
break;
}
}
for (int i=40; i<46; i++)
{
mazzo[i].val = 0 ;
mazzo[i].seme = ' ';
}
}La funzione "punteggio" ha senso? Nella struttura "carte" c'è già un campo "punteggio", non è meglio assegnare il valore di ogni carta quando la crei?
Perché il mazzo ha 46 carte, e non 40?
Fino alla fine della partita mostri le 3 carte in mano al giocatore. Ma negli ultimi due turni non sono 3, ma rispettivamente 2 e 1.
In generale dovresti tenere traccia di quante carte sono nel mazzo e in mano ai giocatori, e la funzione "partita" dovrebbe essere qualcosa del genere:
creaMazzo()
briscola = ultima del mazzo // Senza rimuoverla dal mazzo
dai 2 carte a ciascun giocatore
while (mazzo non vuoto):
dai una carta a ciascun giocatore
mano()
while (giocatori hanno carte in mano):
mano()
ecco il file sorgente quasi terminato ragazzi ora mi appello a voi affinché potiate aiutarmi a evitare problemi che sorgono come quando deve decidere chi prende che in alcuni momenti fa errori . allego il codice compilato con dev c++.
. allego il codice compilato con dev c++.#include <cstdlib>
#include <iostream>
#include <math.h>
#include <time.h>
#include <stdlib.h>
using namespace std;
// mano: quella parte del gioco in cui i 2 giocatori tirano una carta ciascuno
// partita: quella fase di gioco in cui si usa tutto il mazzo
// gioco
struct carte // struttura fornita per definire le carte per poter giocare.
{ int val;
char seme; // s,b,c,o.
int punteggio;
} briscola;
carte mazzo [46];
carte terra [2];
carte in_manoC[3];
carte in_manoU[3];
carte preseC[40];
carte preseU[40];
int puntC =0;
int puntU =0;
bool mazziereC;
bool primaU;
int cima_mazzo = 6;
int mani;
int carta_giocataC=2;
int carta_presaC=45;
void creamazzo()
{
int aus;
for (int i=0; i<40; i++)
{
mazzo[i].val = i%10 + 1;
aus = i/10;
switch (aus)
{
case 0: mazzo[i].seme = 'd';
break;
case 1: mazzo[i].seme = 'c';
break;
case 2: mazzo[i].seme = 'b';
break;
case 3: mazzo[i].seme = 's';
break;
}
}
for (int i=40; i<46; i++)
{
mazzo[i].val = 0 ;
mazzo[i].seme = ' ';
}
}
void stampamazzo()
{ char scelta;
cout << "\t\t...vuoi vedere le carte del mazzo si(s),no(n)?...scelta =";
cin >> scelta;
if (scelta=='s')
{cout << '\n';
for (int i=0; i<40; i++)
cout << mazzo[i].val << mazzo[i].seme << '\t' ;
cout << '\n';
}}
void mescolamazzo() // funzione per mescolare le carte create dalla funzione precedente.
{
for (int i = 0; i < 245; i++)
{
const int pos1 = rand() % 40; // utilizzo costante per dichiarare la posizione per iniziare a mescolare.
const int pos2 = rand() % 40;
const carte aus = mazzo[pos1]; //costante ausiliaria per il mescolamento .
mazzo[pos1] = mazzo[pos2];
mazzo[pos2] = aus;
}
}
void mostrabriscola ()
{ briscola.val = mazzo[39].val;
briscola.seme = mazzo[39].seme;
cout << "\n briscola = " << briscola.val << briscola.seme << '\n';
}
void stampamano()
{cout << "\n-----------------------------mano " << mani+1 << "--------------------\n\ntue carte : ";
for (int i=0; i<3; i++)
cout << in_manoU[i].val << in_manoU[i].seme << " | ";
cout << "# BRISCOLA: " << briscola.val << briscola.seme <<" # carte avversario : ";
/*{char scleta;
cout << "\n vuoi vedere le carte avversario si(s),no(n)? scleta=";
cin >> scleta;
if (scleta=='s')*/
for (int i=0; i<3; i++)
cout << in_manoC[i].val << in_manoC[i].seme << " | ";
cout << "\n\n";
}
//}
int punteggio (int vn)
{ int p;
for (int i=0; i<40; i++)
{ vn=mazzo[i].val;
p=mazzo[i].punteggio;
}
switch (vn)
{ case 1: p=11 ; break;
case 3: p=10 ; break;
case 10: p=4 ; break;
case 9: p=3 ; break;
case 8: p=2 ; break;
default: p=0 ;
}
return(p);
}
bool supera1 (int vn1, int vn2)
{ /*int p1, p2;
bool m1;
p1 = punteggio(vn1);
p2 = punteggio(vn2);
if ((p1 != 0) || (p2 != 0)) m1 = (p1 > p2);
else m1 = (vn1 > vn2);*/
char s1,s2,br; //dichiarazione dei semi delle carte e della briscola
int p1,p2; //dichiarazione dei punteggi delle carte.
br= briscola.seme;
bool su, m1, b2; //dichiarazione delle var. booleane.
vn1 = terra[0].val;
vn2 = terra[1].val;
s1 = terra[0].seme;
s2 = terra[1].seme;
p1 = terra[0].punteggio; //e richiamo su questi la funzione punteggio
p2 = terra[1].punteggio;
su = (s1 == s2); //su è la variabile che indica che le due carte hanno lo stesso seme
m1 = (p1 > p2 || (p1 == p2 && vn1 > vn2)); //m1 è la variabile che indica che la carta 1 ha valore maggiore della carta 2
b2 = (s2 == br); //s2 è la variabile che indica che la carta 2 ha lo stesso seme della briscola
if ((su && m1) || (!su && !b2))
return (m1);
}
bool prendeI()
{ bool magg1,b2, su ;
magg1 = supera1(terra[0].val,terra[1].val);
b2 = (briscola.seme==terra[1].seme);
su = (terra[0].seme==terra[1].seme);
return ((su && magg1)||(!su && !b2));
}
bool tiraprima ()
{ bool primo;
primo = rand() % 2;
if (primo) cout << "\n giochi per primo TU!\n " ;
else cout << "\n gioca per primo l'AVVERSARIO! \n " ;
return primo;
}
void dai_carte() // funzione per dare le carte ai giocatori
{
if (mazziereC)
for (int i=0; i<3; i++) //utilizzo del for per variare in numero di carte preso nella prima mano.
{
in_manoU[i] = mazzo[i*2]; // caso in cui le carte vengono date prima all'utente e poi all'avversario.
in_manoC[i] = mazzo[i*2+1];
}
else
for (int i=0; i<3; i++)
{ in_manoU[i] = mazzo[i*2+1]; // caso in cui le carte vengono date prima all'avversario e poi all'utente.
in_manoC[i] = mazzo[i*2];
}
}
int richiestaU ()
{int pos;
cout << " Quale carta giochi? 1 o 2 o 3 ? Pos carta = ";
cin >> pos;
if (primaU)
{terra[0].val = in_manoU[pos-1].val;
terra[0].seme = in_manoU[pos-1].seme;
}
else
{terra[1].val = in_manoU[pos-1].val;
terra[1].seme = in_manoU[pos-1].seme;
}
cout << "Hai tirato " << in_manoU[pos-1].val << in_manoU[pos-1].seme;
cout << '\n';
return(pos-1);
}
//____________________________________________________________________________________________________________________________
int CgiocaII()
{ int m;
{ if ( terra[1].punteggio > 9) // punteggio a terra alto.
{ for (int i=0;i<3;i++)
{ if (in_manoC[i].val == terra[1].val)
{ terra[0].val = in_manoC[i].val;
terra[0].val=i;
}
}
if ( terra[1].seme != briscola.seme) // caso seme a terra diverso da briscola.
for (int i=0; i<3; i++)
{ if (( in_manoC[i].seme == terra[1].seme) && ( in_manoC[i].punteggio > 3) && (in_manoC[i].punteggio > terra[1].punteggio))
{ terra[0].seme=in_manoC[i].seme;
terra[0].val=i;
}
}
for ( int i=0;i<3; i++)
{ if(in_manoC[i].punteggio < terra [1].punteggio) // caso punteggio in mano più basso di quello a terra.
{ terra[0].punteggio = in_manoC[i].punteggio;
terra[0].val=i;
}
}
}
else
{ for (int i=0;i<3;i++)
{ if ( in_manoC[i].val < terra[1].val) // caso val in mano più basso di quello a terra.
{ terra[0].val= in_manoC[i].val;
terra[0].val=i;
}
}
}
}
m = rand()%3;
cout << "l'AVVERSARIO ha tirato " << in_manoC[m].val << in_manoC[m].seme;
cout << '\n';
return(m);
}
//____________________________________________________________________________________________________
int CgiocaI()
{ int m;
if ( terra[0].punteggio >9)
{
for (int i=0;i<3; i++)
{ if (in_manoC[i].punteggio < terra[0].punteggio) // punteggio in mano più basso di quello a terra.
terra[0].val=in_manoC[i].val;
terra[0].val=i;
}
}
terra[0].val;
briscola.seme == terra[0].seme; // seme a terra uguale alla briscola.
for (int j=0;j<3;j++)
{ if (terra[0].seme == in_manoC[j].seme)
in_manoC[j].seme;
}
m= rand()%3;
cout << "l'AVVERSARIO ha tirato " << in_manoC[m].val << in_manoC[m].seme;
cout << '\n';
return(m);
}
void chiprende(int ncU,int ncC)
{if (prendeI()==primaU)
{((puntU=puntU+punteggio(terra[0].val)+punteggio(terra[1].val)) || (puntU=puntU+punteggio(terra[0].punteggio)+punteggio(terra[1].punteggio)));
in_manoU[ncU].seme=mazzo[cima_mazzo].seme;
in_manoU[ncU].val =mazzo[cima_mazzo].val ;
in_manoU[ncU].punteggio = mazzo[cima_mazzo].punteggio;
cima_mazzo++;
in_manoC[ncC].seme=mazzo[cima_mazzo].seme;
in_manoC[ncC].val =mazzo[cima_mazzo].val ;
in_manoC[ncC].punteggio = mazzo[cima_mazzo].punteggio;
cima_mazzo++;
cout << "\t\t...prendi TU...";
primaU=true;
}
else
{((puntC=puntC+punteggio(terra[0].val)+punteggio(terra[1].val)) || (puntU=puntU+punteggio(terra[0].punteggio)+punteggio(terra[1].punteggio)));
in_manoC[ncC].seme=mazzo[cima_mazzo].seme;
in_manoC[ncC].val =mazzo[cima_mazzo].val ;
in_manoC[ncC].punteggio = mazzo[cima_mazzo].punteggio;
cima_mazzo++;
in_manoU[ncU].seme=mazzo[cima_mazzo].seme;
in_manoU[ncU].val =mazzo[cima_mazzo].val ;
in_manoU[ncU].punteggio = mazzo[cima_mazzo].punteggio;
cima_mazzo++;
cout << "...prende l'AVVERSARIO...";
primaU=false;
}
//stampamano();
}
void mano ()
{ int numU, numC;
if (primaU){
numU=richiestaU();
numC=CgiocaII();
}
else
{numC=CgiocaI();
numU=richiestaU();
}
chiprende(numU,numC);
//cout << "\n--------------------------------------------------------\n";
}
void partita ()
{ cima_mazzo=6;
dai_carte();
primaU=mazziereC;
for (int i=0; i<20; i++)
{mani=i;
stampamano();
mano();
}
cout << "\n ...la partita e' finita...\n\n";
}
main(int argc, char *argv[])
{ system("color 2F");
creamazzo();
stampamazzo();
srand (time (0));
mazziereC=tiraprima();
//stampamano();
{
mescolamazzo();
stampamazzo();
mostrabriscola();
partita();
mazziereC = ! mazziereC;
}
if (puntU>puntC) cout << "hai vinto TU\n\n";
else cout << "ha vinto l'AVVERSARIO\n\n";
system("PAUSE");
return EXIT_SUCCESS;
}
Accedi a tutti gli appunti
Tutor AI: studia meglio e in meno tempo