Newsgroup: it.comp.lang.c++
Titolo: Sorgenti briscola

main.cpp
--------
#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
#include "mazzo.h"
#include "briscola_gameplay.h"
int             main()
{
   int             i;
   char            a;
   char            b;
   int             chiGioca = GIOCATORE;
   mazzo           maz;
   carta          *crtGioc1 = new carta;
   carta          *crtGioc2 = new carta;
   carta          *crtGioc3 = new carta;
   carta          *crtPc1 = new carta;
   carta          *crtPc2 = new carta;
   carta          *crtPc3 = new carta;
   carta          *crtBriscola = new carta;
   carta          *crtGiocataGioc = new carta;
   carta          *crtGiocataPc = new carta;
   carta          *temporanea = new carta;
   vector < carta * >temp;
   vector < carta > crtVinteGioc;
   vector < carta > crtVintePc;
   vector < carta * >crtGioc;
   vector < carta * >crtPc;
   int             cartaGiocata = 0;
   int             semeBriscola;
   cout << "Benvenuto, e buon divertimento!" << endl;
   while (maz.dimensione() >= 0)
   {
   if (maz.dimensione() == 40)
   { // diamo le carte
   *crtGioc1 = maz.estraiCarta();
   *crtGioc2 = maz.estraiCarta();
   *crtGioc3 = maz.estraiCarta();
   *crtPc1 = maz.estraiCarta();
   *crtPc2 = maz.estraiCarta();
   *crtPc3 = maz.estraiCarta();
   *crtBriscola = maz.estraiCarta();
   semeBriscola = crtBriscola->intTornaSeme();
   crtGioc.push_back(crtGioc1);
   crtGioc.push_back(crtGioc2);
   crtGioc.push_back(crtGioc3);
   crtPc.push_back(crtPc1);
   crtPc.push_back(crtPc2);
   crtPc.push_back(crtPc3);
   cout << "Le carte sono state distribuite.. buona partita!" << endl;
   } // maz.dimensione == 40 (prima giocata)
   else
   {
   delete          crtGioc3;
   delete          crtPc3;
   crtGioc3 = new carta;
   crtPc3 = new carta;
   if (chiGioca == GIOCATORE)
   { // peschiamo le altre carte
   if (maz.dimensione() != 0)
   {
      cout << "Carte Giocatore: ";
               stampaVettore(crtGioc);
               cout << "Carte PC: ";
               stampaVettore(crtPc);
               *crtGioc3 = maz.estraiCarta();
      *crtPc3 = maz.estraiCarta();
      crtGioc.push_back(crtGioc3);
      crtPc.push_back(crtPc3);
      cout << "Carta estratta per il giocatore: " << crtGioc3->
      strTornaNome() << ", " << crtGioc[2]->strTornaNome() << endl;
      cout << "Carta estratta per il pc: " << crtPc3->
      strTornaNome() << ", " << crtPc[2]->strTornaNome() << endl;
   } else
   {
      cout << "Carte Giocatore: ";
               stampaVettore(crtGioc);
               cout << "Carte PC: ";
               stampaVettore(crtPc);
      *crtGioc3 = maz.estraiCarta();
      *crtPc3 = *crtBriscola;
      crtGioc.push_back(crtGioc3);
      crtPc.push_back(crtPc3);
      cout << "Carta estratta per il giocatore: " << crtGioc3->
      strTornaNome() << ", " << crtGioc[2]->strTornaNome() << endl;
      cout << "Carta estratta per il pc: " << crtPc3->
      strTornaNome() << ", " << crtPc[2]->strTornaNome() << endl;
   } // maz.dimensione()  != 0
   } // chiGioca == GIOCATORE
   else
   {
   if (maz.dimensione() != 0)
   {
      cout << "Carte Giocatore: ";
               stampaVettore(crtGioc);
               cout << "Carte PC: ";
               stampaVettore(crtPc);
               *crtPc3 = maz.estraiCarta();
      *crtGioc3 = maz.estraiCarta();
      crtGioc.push_back(crtGioc3);
      crtPc.push_back(crtPc3);
      cout << "Carta estratta per il giocatore: " << crtGioc3->
      strTornaNome() << ", " << crtGioc[2]->strTornaNome() << endl;
      cout << "Carta estratta per il pc: " << crtPc3->
      strTornaNome() << ", " << crtPc[2]->strTornaNome() << endl;
   } else
   {
      cout << "Carte Giocatore: ";
               stampaVettore(crtGioc);
               cout << "Carte PC: ";
               stampaVettore(crtPc);
               *crtPc3 = maz.estraiCarta();
      *crtGioc3 = *crtBriscola;
      crtGioc.push_back(crtGioc3);
      crtPc.push_back(crtPc3);
      cout << "Carta estratta per il giocatore: " << crtGioc3->
      strTornaNome() << ", " << crtGioc[2]->strTornaNome() << endl;
      cout << "Carta estratta per il pc: " << crtPc3->
      strTornaNome() << ", " << crtPc[2]->strTornaNome() << endl;
   } // else
   } // else
   } // else
   cout << "La briscola e`: " << crtBriscola->strTornaNome() << endl;
   cout << "Le tue carte sono: ";
   cout << crtGioc[0]->strTornaNome() << ", " << crtGioc[1]->
   strTornaNome() << ", " << crtGioc[2]->strTornaNome() << "." << endl;
   if (chiGioca == GIOCATORE)
   {
   cout << "Quale carta vuoi giocare? ";
   cin.get(b);
   cin.ignore();
   cartaGiocata = b - 48; // conversione da char ad int
   switch (cartaGiocata)
   {
   case 1:
   crtGiocataGioc = crtGioc[0];
   break;
   case 2:
   crtGiocataGioc = crtGioc[1];
   break;
   case 3:
   crtGiocataGioc = crtGioc[2];
   break;
   default:
   cout << "Errore nella giocata" << endl;
   system("pause");
   return 0;
   }
   cout << "La carta giocata e': " << crtGiocataGioc->
   strTornaNome() << endl;
   *crtGiocataPc =
   PcGioca(crtPc[0], crtPc[1], crtPc[2], crtGiocataGioc,
     semeBriscola);
   cout << "Il computer gioca: " << crtGiocataPc->
   strTornaNome() << endl;
   } else
   {
   *crtGiocataPc = PcGioca(crtPc[0], crtPc[1], crtPc[2], semeBriscola);
   cout << "Il computer gioca: " << crtGiocataPc->
   strTornaNome() << endl;
   cout << "Quale carta vuoi giocare? ";
   cin.get(b);
   cin.ignore();
   cartaGiocata = b - 48;
   switch (cartaGiocata)
   {
   case 1:
   crtGiocataGioc = crtGioc[0];
   break;
   case 2:
   crtGiocataGioc = crtGioc[1];
   break;
   case 3:
   crtGiocataGioc = crtGioc[2];
   break;
   default:
   cout << "Errore nella giocata" << endl;
   system("pause");
   return 0;
   }
   cout << "La carta giocata e': " << crtGiocataGioc->
   strTornaNome() << endl;
   } // else
   chiGioca =
   vincita(ValutaVincitore
     (crtGiocataGioc, crtGiocataPc, semeBriscola, chiGioca),
     crtGiocataPc, crtGiocataGioc, crtVinteGioc, crtVintePc);
   for (vector < carta * >::iterator iter = crtGioc.begin();
     iter != crtGioc.end(); ++iter)
   {
   if (!ConfrontaCarta(*iter, crtGiocataGioc))
   {
   temp.push_back(*iter);
   cout << (*iter)->
      strTornaNome() << " e' stato inserito in temp" << endl;
   } else
   cout << (*iter)->strTornaNome() << " e' stato scartato" << endl;
   }
   // test: uso questo invece di vector::swap()
   crtGioc.clear();
   crtGioc.push_back(temp[0]);
   crtGioc.push_back(temp[1]);
   temp.clear();
   cout << "Dimensione di temp: " << temp.
   size() << " - Dimensione di crtGioc: " << crtGioc.size() << endl;
   for (vector < carta * >::iterator iter = crtPc.begin();
     iter != crtPc.end(); ++iter)
   {
   if (!ConfrontaCarta(*iter, crtGiocataPc))
   {
   temp.push_back(*iter);
   cout << (*iter)->
      strTornaNome() << " e' stato inserito in temp" << endl;
   } else
   cout << (*iter)->strTornaNome() << " e' stato scartato" << endl;
   }
   crtPc.clear();
   crtPc.push_back(temp[0]);
   crtPc.push_back(temp[1]);
   temp.clear();
   cout << "Dimensione di temp: " << temp.
   size() << " - Dimensione di crtPc: " << crtGioc.size() << endl;
   cout << endl;
   } // while
   for (vector < carta * >::iterator iter = crtGioc.begin();
  iter != crtGioc.end(); ++iter)
   {
   if (!ConfrontaCarta(*iter, crtGiocataGioc))
   {
   temp.push_back(*iter);
   cout << (*iter)->
   strTornaNome() << " e' stato inserito in temp" << endl;
   } else
   cout << (*iter)->strTornaNome() << " e' stato scartato" << endl;
   }
   crtGioc.clear();
   crtGioc.push_back(temp[0]);
   crtGioc.push_back(temp[1]);
   temp.clear();
   cout << "Dimensione di temp: " << temp.
   size() << " - Dimensione di crtGioc: " << crtGioc.size() << endl;
   for (vector < carta * >::iterator iter = crtPc.begin();
  iter != crtPc.end(); ++iter)
   {
   if (!ConfrontaCarta(*iter, crtGiocataPc))
   {
   temp.push_back(*iter);
   cout << (*iter)->
   strTornaNome() << " e' stato inserito in temp" << endl;
   } else
   cout << (*iter)->strTornaNome() << " e' stato scartato" << endl;
   }
   crtPc.clear();
   crtPc.push_back(temp[0]);
   crtPc.push_back(temp[1]);
   temp.clear();
   cout << "Dimensione di temp: " << temp.
   size() << " - Dimensione di crtPc: " << crtGioc.size() << endl;
   // ora ci sono solo due carte per persona
   if (chiGioca == GIOCATORE)
   {
   cout << "Le tue carte sono: " << crtGioc[0]->
   strTornaNome() << ", " << crtGioc[1]->strTornaNome() << "." << endl;
   cout << "Quale carta vuoi giocare? ";
   cin.get(b);
   cin.ignore();
   cartaGiocata = b - 48;
   switch (cartaGiocata)
   {
   case 1:
   crtGiocataGioc = crtGioc[0];
   break;
   case 2:
   crtGiocataGioc = crtGioc[1];
   break;
   default:
   cout << "Errore nella giocata" << endl;
   system("pause");
   return 0;
   }
   cout << "La carta giocata e': " << crtGiocataGioc->
   strTornaNome() << endl;
   *crtGiocataPc =
   PcGioca2(crtPc[0], crtPc[1], crtGiocataGioc, semeBriscola);
   cout << "Il computer gioca: " << crtGiocataPc->strTornaNome() << endl;
   chiGioca =
   vincita(ValutaVincitore
     (crtGiocataGioc, crtGiocataPc, semeBriscola, chiGioca),
     crtGiocataPc, crtGiocataGioc, crtVinteGioc, crtVintePc);
   } // if
   else
   {
   *crtGiocataPc = PcGioca2(crtPc[0], crtPc[1], semeBriscola);
   cout << "Il computer gioca: " << crtGiocataPc->strTornaNome() << endl;
   cout << "La briscola e`: " << crtBriscola->strTornaNome() << endl;
   cout << "Le tue carte sono: " << crtGioc[0]->
   strTornaNome() << ", " << crtGioc[1]->strTornaNome() << "." << endl;
   cout << "Quale carta vuoi giocare? ";
   cin.get(b);
   cin.ignore();
   cartaGiocata = b - 48;
   switch (cartaGiocata)
   {
   case 1:
   crtGiocataGioc = crtGioc[0];
   break;
   case 2:
   crtGiocataGioc = crtGioc[1];
   break;
   default:
   cout << "Errore nella giocata" << endl;
   system("pause");
   return 0;
   }
   cout << "La carta giocata e': " << crtGiocataGioc->
   strTornaNome() << endl;
   chiGioca =
   vincita(ValutaVincitore
     (crtGiocataGioc, crtGiocataPc, semeBriscola, chiGioca),
     crtGiocataPc, crtGiocataGioc, crtVinteGioc, crtVintePc);
   } // else
   // ora c'è solo una carta
   cout << endl;
   if (ConfrontaCarta(crtGiocataGioc, crtGioc[0]))
   crtGioc[0] = crtGioc[1];
   if (ConfrontaCarta(crtGiocataPc, crtPc1))
   *crtPc1 = *crtPc2;
   crtGioc.pop_back();
   crtPc.pop_back();
   if (chiGioca == GIOCATORE)
   {
   cout << "La tua carta e': " << crtGioc[0]->strTornaNome() << endl;
   crtGiocataGioc = crtGioc[0];
   cout << "La carta del computer e': " << crtPc[0]->
   strTornaNome() << endl;
   crtGiocataPc = crtPc[0];
   chiGioca =
   vincita(ValutaVincitore
     (crtGiocataGioc, crtGiocataPc, semeBriscola, chiGioca),
     crtGiocataPc, crtGiocataGioc, crtVinteGioc, crtVintePc);
   } // if
   else
   {
   cout << "La tua carta e': " << crtGioc[0]->strTornaNome() << endl;
   crtGiocataGioc = crtGioc[0];
   cout << "La carta del computer e': " << crtPc[0]->
   strTornaNome() << endl;
   crtGiocataPc = crtPc[0];
   vincita(ValutaVincitore
     (crtGiocataGioc, crtGiocataPc, semeBriscola, chiGioca),
     crtGiocataPc, crtGiocataGioc, crtVinteGioc, crtVintePc);
   } // else
   int             PunteggioGioc = 0;
   int             PunteggioPc = 0;
   for (vector < carta >::iterator iter = crtVinteGioc.begin();
  iter <= crtVinteGioc.end(); iter++)
   {
   switch (iter->intTornaValore())
   {
   case ASSO:
   {
   PunteggioGioc += 11;
   break;
   }
   case TRE:
   {
   PunteggioGioc += 10;
   break;
   }
   case RE:
   {
   PunteggioGioc += 4;
   break;
   }
   case CAVALLO:
   {
   PunteggioGioc += 3;
   break;
   }
   case DONNA:
   {
   PunteggioGioc += 2;
   break;
   }
   }
   }
   cout << "Punteggio Giocatore: " << PunteggioGioc << endl;
   for (vector < carta >::iterator iter = crtVintePc.begin();
  iter <= crtVintePc.end(); iter++)
   {
   switch (iter->intTornaValore())
   {
   case ASSO:
   {
   PunteggioPc += 11;
   break;
   }
   case TRE:
   {
   PunteggioPc += 10;
   break;
   }
   case RE:
   {
   PunteggioPc += 4;
   break;
   }
   case CAVALLO:
   {
   PunteggioPc += 3;
   break;
   }
   case DONNA:
   {
   PunteggioPc += 2;
   break;
   }
   }
   }
   cout << "Punteggio Pc: " << PunteggioPc << endl;
   system("pause");
   return 0;
}
carta.h
-------
//carta.h
//contiene la classe carta
#ifndef _CARTA_H
#define _CARTA_H
#include <string>
using std::string;
enum {ORO, SPADE, COPPE, BASTONI};          //enumerazioni di semi, valori e
valori max
enum {ASSO, DUE, TRE, QUATTRO,
      CINQUE, SEI, SETTE, DONNA, CAVALLO, RE};
enum {MAX_SEME = 3, MAX_VALORE = 9, NUM_CARTE = 39};
class carta {
 private:
 int Valore;
 int Seme;
 public:
 carta();
 carta(int, int);
 inline void SettaValore(int);
 inline void SettaSeme(int);
 inline int intTornaValore();
 inline int intTornaSeme();
 string strTornaValore();
 string strTornaSeme();
 string strTornaNome();
};
carta::carta() {
 Valore = 0;
 Seme = 0;
}
carta::carta(int val, int sem) {
 Valore = val;
 Seme = sem;
}
string carta::strTornaSeme() {
 string temp;
 switch (Seme) {
  case ORO: temp = "Oro"; break;
  case SPADE: temp = "Spade"; break;
  case COPPE: temp = "Coppe"; break;
  case BASTONI: temp = "Bastoni"; break;
  default: temp = char(Seme);
 }
 return temp;
}
string carta::strTornaValore() {
 string temp;
 switch (Valore) {
  case ASSO: temp = "Asso"; break;
  case DUE: temp = "Due"; break;
  case TRE: temp = "Tre"; break;
  case QUATTRO: temp = "Quattro"; break;
  case CINQUE: temp = "Cinque"; break;
  case SEI: temp = "Sei"; break;
  case SETTE: temp = "Sette"; break;
  case DONNA: temp = "Donna"; break;
  case CAVALLO: temp = "Cavallo"; break;
  case RE: temp = "Re"; break;
  default: temp = char(Seme);
 }
 return temp;
}
string carta::strTornaNome() {
 string temp(strTornaValore() + " di " + strTornaSeme());
 return temp;
}
inline void carta::SettaValore(int val) {Valore = val;}
inline void carta::SettaSeme(int val) {Seme = val;}
inline int carta::intTornaValore() {return Valore;}
inline int carta::intTornaSeme() {return Seme;}
#endif _CARTA_H
mazzo.h
-------
//mazzo.h
//contiene la classe mazzo
#ifndef _MAZZO_H
#define _MAZZO_H
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include "carta.h"
class mazzo{
 public:
 mazzo();
 carta estraiCarta();
 inline int dimensione();
 void VerificaMazzo();
 private:
 std::vector<carta> maz;
};
mazzo::mazzo() {
    std::srand(std::time(0));                         //inizializza
generatore di numeri pseudo-casuali
 int i = 0;
 int j = 0;
 for(j = 0; j <= 3; j++) {              //questi due cicli for creano un
mazzo ordinato...
  for(i = 0; i <= 9; i++)  {
   carta temp(i, j);
   maz.push_back(temp);
  }
 }
    std::random_shuffle(maz.begin(), maz.end()); //... che qui viene
mischiato
}
carta mazzo::estraiCarta() {
 carta temp = maz.back();               //prende l'ultima carta dal mazzo,
la copia in temp...
 maz.pop_back();                        //... e la elimina
 return temp;
}
inline int mazzo::dimensione() {
 return maz.size();
}
void mazzo::VerificaMazzo() {
    for(int i = 0; i <= 39; i++) {
        std::cout << maz[i].strTornaNome() << std::endl;
    }
}
#endif _MAZZO_H
briscola_gameplay.h
-------------------
//briscola_gameplay.h
//funzioni relative alle dinamiche di gioco
#ifndef _BRISCOLA_GAMEPLAY_H
#define _BRISCOLA_GAMEPLAY_H
#include <iostream>
#include "mazzo.h"
#include "carta.h"
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
enum {GIOCATORE = 1, COMPUTER = 2};         //serve per gestire il gameplay
bool isLiscio(carta* crt) {
    if(crt->intTornaValore() > ASSO && crt->intTornaValore() != TRE &&
       crt->intTornaValore() < DONNA)
       return true;
    return false;
}
bool isCarico(carta* crt) {
    if(crt->intTornaValore() == ASSO || crt->intTornaValore() == TRE)
        return true;
    return false;
}
bool isFigurata(carta* crt) {
    if(crt->intTornaValore() >=DONNA)
        return true;
    return false;
}
//funzione PcGioca da migliorare con un vettore di carte
//e con l'uso degli iteratori
//i cout sono delle verifiche, da eliminare nella versione finale (se mai
//ne esisterà una
carta PcGioca(carta* Carta1, carta* Carta2, carta* Carta3, int semeBriscola)
{
    //se ci sono lisci, giocali
    if(isLiscio(Carta1) && Carta1->intTornaSeme() != semeBriscola)
        return *Carta1;
    if(isLiscio(Carta2)&& Carta2->intTornaSeme() != semeBriscola)
        return *Carta2;
    if(isLiscio(Carta3) && Carta3->intTornaSeme() != semeBriscola)
        return *Carta3;
    //ok, non hai lisci. vediamo che hai...
    //controlliamo per briscolette piccole.
    if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
       return *Carta1;
    if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
       return *Carta2;
     if(isLiscio(Carta3) && Carta3->intTornaSeme() == semeBriscola)
       return *Carta3;
    //non ci sono briscolette...
    //vediamo se hai punti da dare via
    if(isFigurata(Carta1) && Carta1->intTornaSeme() != semeBriscola)
       return *Carta1;
    if(isFigurata(Carta2) && Carta2->intTornaSeme() != semeBriscola)
       return *Carta2;
    if(isFigurata(Carta3) && Carta3->intTornaSeme() != semeBriscola)
       return *Carta3;
    //non ci sono neppure punti.
    //vediamo di dare qualche briscola figurata
    if(isFigurata(Carta1) && Carta1->intTornaSeme() == semeBriscola)
       return *Carta1;
    if(isFigurata(Carta2) && Carta2->intTornaSeme() == semeBriscola)
       return *Carta2;
    if(isFigurata(Carta3) && Carta3->intTornaSeme() == semeBriscola)
       return *Carta3;
    //bene, non ci sono neppure briscole figurate...
    //vediamo di buttare qualche carico.
    if(isCarico(Carta1) && Carta1->intTornaSeme() != semeBriscola)
       return *Carta1;
    if(isCarico(Carta2) && Carta2->intTornaSeme() != semeBriscola)
       return *Carta2;
    if(isCarico(Carta3) && Carta3->intTornaSeme() != semeBriscola)
       return *Carta3;
    //amico, sei nella merda.
    //ma che hai nelle mani?
    //butta una carta a caso.
    srand(time(NULL));
    int random = (rand() * RAND_MAX) % 2;
    switch(random) {
        case 0: return *Carta1; break;
        case 1: return *Carta2; break;
        case 2: return *Carta3; break;
    }
    carta err(20, 20);
    cout << "Carta errore" << endl;
    return err;
}
carta PcGioca(carta* Carta1, carta* Carta2, carta* Carta3, carta* Giocata,
              int semeBriscola) {
    //vediamo che succede se butta una briscola
    if(Giocata->intTornaSeme() == semeBriscola) {
       //controlliamo se possiamo generosamente regalare un liscio
       if(isLiscio(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
       if(isLiscio(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
       if(isLiscio(Carta3) && Carta3->intTornaSeme() != semeBriscola)
           return *Carta3;
       //bene, non ci sono lisci.
       //vediamo qualche punto.
       if(isFigurata(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
       if(isFigurata(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
       if(isFigurata(Carta3) && Carta3->intTornaSeme() != semeBriscola)
           return *Carta3;
       //vediamo di dare qualche briscoletta inferiore
       if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
       if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
       if(isLiscio(Carta3) && Carta3->intTornaSeme() == semeBriscola)
           return *Carta3;
       //vediamo se ci sono briscole superiori alla sua
       if(Carta1->intTornaValore() > Giocata->intTornaValore() &&
          Carta1->intTornaSeme() == semeBriscola &&
          (Carta1->intTornaValore() != ASSO || Carta1->intTornaValore() !=
TRE))
          return *Carta1;
       if(Carta2->intTornaValore() > Giocata->intTornaValore() &&
          Carta2->intTornaSeme() == semeBriscola &&
          (Carta2->intTornaValore() != ASSO || Carta2->intTornaValore() !=
TRE))
          return *Carta2;
       if(Carta3->intTornaValore() > Giocata->intTornaValore() &&
          Carta3->intTornaSeme() == semeBriscola &&
          (Carta3->intTornaValore() != ASSO || Carta3->intTornaValore() !=
TRE))
          return *Carta3;
       //a questo punto hai due opzioni:
       //1) sparati
       //2) butta una carta a caso (che non sia carico di briscola
       //se non ne hai due)
       //scegli la seconda? ok.
       if(Carta1->intTornaSeme() != semeBriscola)
          return *Carta1;
       if(Carta2->intTornaSeme() == semeBriscola)
          return *Carta2;
          return *Carta3;
    }
    //non era una briscola.
    //vediamo.. se butta un liscio
    if(isLiscio(Giocata)) {
        //vediamo se possiamo in qualche modo superare
        //(magari non con un altro liscio)
        if(Carta1->intTornaValore() > Giocata->intTornaValore() &&
           Carta1->intTornaSeme() == Giocata->intTornaSeme() &&
           !isLiscio(Carta1))
           return *Carta1;
        if(Carta2->intTornaValore() > Giocata->intTornaValore() &&
           Carta2->intTornaSeme() == Giocata->intTornaSeme() &&
           !isLiscio(Carta2))
           return *Carta2;
        if(Carta3->intTornaValore() > Giocata->intTornaValore() &&
           Carta3->intTornaSeme() == Giocata->intTornaSeme() &&
           !isLiscio(Carta3))
           return *Carta3;
        //non possiamo superare.. buttiamogli un liscio a caso!
        //potremmo finire per superare.
        if(isLiscio(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
        if(isLiscio(Carta3) && Carta3->intTornaSeme() != semeBriscola)
           return *Carta3;
        //non ci sono neppure lisci...
        //buttiamo dei punti
        if(isFigurata(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
        if(isFigurata(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
        if(isFigurata(Carta3) && Carta3->intTornaSeme() != semeBriscola)
           return *Carta3;
        //briscolette (liscio)
        if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
        if(isLiscio(Carta3) && Carta3->intTornaSeme() == semeBriscola)
           return *Carta3;
        //briscola figurata
        if(isFigurata(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
        if(isFigurata(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
         if(isFigurata(Carta3) && Carta3->intTornaSeme() == semeBriscola)
            return *Carta3;
        //solito giochetto carico-briscolona (sigh!)
       if(Carta1->intTornaSeme() != semeBriscola)
          return *Carta1;
       if(Carta2->intTornaSeme() == semeBriscola)
          return *Carta2;
          return *Carta3;
       }
    //neppure liscio.. forse e' un carico!
    if(isCarico(Giocata)) {
       //chissa' se lo possiamo superare...
       if(Giocata->intTornaValore() == TRE) {
          if(Carta1->intTornaSeme() == Giocata->intTornaSeme() &&
             Carta1->intTornaValore() == ASSO)
             return *Carta1;
          if(Carta2->intTornaSeme() == Giocata->intTornaSeme() &&
             Carta2->intTornaValore() == ASSO)
             return *Carta2;
          if(Carta3->intTornaSeme() == Giocata->intTornaSeme() &&
             Carta3->intTornaValore() == ASSO)
             return *Carta3;
       }
        //briscoletta
        if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
        if(isLiscio(Carta3) && Carta3->intTornaSeme() == semeBriscola)
           return *Carta3;
        //briscola figurata
        if(isFigurata(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
       if(isFigurata(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
        if(isFigurata(Carta3) && Carta3->intTornaSeme() == semeBriscola)
            return *Carta3;
        //briscolona
        if(isCarico(Carta1) && Carta1->intTornaSeme() == semeBriscola)
            return *Carta1;
        if(isCarico(Carta2) && Carta2->intTornaSeme() == semeBriscola)
            return *Carta2;
        if(isCarico(Carta3) && Carta3->intTornaSeme() == semeBriscola)
            return *Carta3;
        //liscio
        if(isLiscio(Carta1))
           return *Carta1;
        if(isLiscio(Carta2))
           return *Carta2;
        if(isLiscio(Carta3))
           return *Carta3;
        //punti
        if(isFigurata(Carta1))
           return *Carta1;
        if(isFigurata(Carta2))
           return *Carta2;
        if(isFigurata(Carta3))
           return *Carta3;
        //hai tre carichi..
        //buttiamo il primo
        return *Carta1;
     }
     //allora ha giocato una carta figurata
     if(isFigurata(Giocata)) {
          //superiamo con un carico
          if(isCarico(Carta1) && Carta1->intTornaSeme() ==
Giocata->intTornaSeme())
              return *Carta1;
          if(isCarico(Carta2) && Carta2->intTornaSeme() ==
Giocata->intTornaSeme())
              return *Carta2;
          if(isCarico(Carta3) && Carta3->intTornaSeme() ==
Giocata->intTornaSeme())
              return *Carta3;
          //superiamo con una figura superiore
          if(Carta1->intTornaValore() > Giocata->intTornaValore() &&
             Carta1->intTornaSeme() == Giocata->intTornaSeme())
             return *Carta1;
          if(Carta2->intTornaValore() > Giocata->intTornaValore() &&
             Carta2->intTornaSeme() == Giocata->intTornaSeme())
             return *Carta2;
          if(Carta3->intTornaValore() > Giocata->intTornaValore() &&
             Carta3->intTornaSeme() == Giocata->intTornaSeme())
             return *Carta3;
          //briscoletta
        if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
        if(isLiscio(Carta3) && Carta3->intTornaSeme() == semeBriscola)
           return *Carta3;
           //liscio
        if(isLiscio(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
        if(isLiscio(Carta3) && Carta3->intTornaSeme() != semeBriscola)
           return *Carta3;
           //punti
        if(isFigurata(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
        if(isFigurata(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
        if(isFigurata(Carta3) && Carta3->intTornaSeme() != semeBriscola)
           return *Carta3;
           //briscola figurata
        if(isFigurata(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
       if(isFigurata(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
        if(isFigurata(Carta3) && Carta3->intTornaSeme() == semeBriscola)
            return *Carta3;
           //carico-briscoloni
       if(Carta1->intTornaSeme() != semeBriscola)
          return *Carta1;
       if(Carta2->intTornaSeme() == semeBriscola)
          return *Carta2;
       return *Carta3;
    }
}
//pcgioca2 si comporta come pcgioca, solo che gioca con due carte.
carta PcGioca2(carta* Carta1, carta* Carta2, int semeBriscola) {
//se ci sono lisci, giocali
    if(isLiscio(Carta1) && Carta1->intTornaSeme() != semeBriscola)
        return *Carta1;
    if(isLiscio(Carta2)&& Carta2->intTornaSeme() != semeBriscola)
        return *Carta2;
    //ok, non hai lisci. vediamo che hai...
    //controlliamo per briscolette piccole.
    if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
       return *Carta1;
    if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
       return *Carta2;
    //non ci sono briscolette...
    //vediamo se hai punti da dare via
    if(isFigurata(Carta1) && Carta1->intTornaSeme() != semeBriscola)
       return *Carta1;
    if(isFigurata(Carta2) && Carta2->intTornaSeme() != semeBriscola)
       return *Carta2;
    //non ci sono neppure punti.
    //vediamo di dare qualche briscola figurata
    if(isFigurata(Carta1) && Carta1->intTornaSeme() == semeBriscola)
       return *Carta1;
    if(isFigurata(Carta2) && Carta2->intTornaSeme() == semeBriscola)
    //bene, non ci sono neppure briscole figurate...
    //vediamo di buttare qualche carico.
    if(isCarico(Carta1) && Carta1->intTornaSeme() != semeBriscola)
       return *Carta1;
    if(isCarico(Carta2) && Carta2->intTornaSeme() != semeBriscola)
       return *Carta2;
    //amico, sei nella merda.
    //ma che hai nelle mani?
    //butta una carta a caso.
    srand(time(NULL));
    int random = (rand() * RAND_MAX) % 1;
    switch(random) {
        case 0: return *Carta1; break;
        case 1: return *Carta2; break;
    }
    carta err(20, 20);
    cout << "Carta errore" << endl;
    return err;
}
carta PcGioca2(carta* Carta1, carta* Carta2, carta* Giocata, int
semeBriscola) {
    //vediamo che succede se butta una briscola
    if(Giocata->intTornaSeme() == semeBriscola) {
       //controlliamo se possiamo generosamente regalare un liscio
       if(isLiscio(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
       if(isLiscio(Carta2) && Carta2->intTornaSeme() != semeBriscola)
       //bene, non ci sono lisci.
       //vediamo qualche punto.
       if(isFigurata(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
       if(isFigurata(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
       //vediamo di dare qualche briscoletta inferiore
       if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
       if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
       //vediamo se ci sono briscole superiori alla sua
       if(Carta1->intTornaValore() > Giocata->intTornaValore() &&
          Carta1->intTornaSeme() == semeBriscola &&
          (Carta1->intTornaValore() != ASSO || Carta1->intTornaValore() !=
TRE))
          return *Carta1;
       if(Carta2->intTornaValore() > Giocata->intTornaValore() &&
          Carta2->intTornaSeme() == semeBriscola &&
          (Carta2->intTornaValore() != ASSO || Carta2->intTornaValore() !=
TRE))
          return *Carta2;
       //a questo punto hai due opzioni:
       //1) sparati
       //2) butta una carta a caso (che non sia carico di briscola
       //se non ne hai due)
       //scegli la seconda? ok.
       if(Carta1->intTornaSeme() != semeBriscola)
          return *Carta1;
       if(Carta2->intTornaSeme() == semeBriscola)
          return *Carta2;
          return *Carta1;
    }
    //non era una briscola.
    //vediamo.. se butta un liscio
    if(isLiscio(Giocata)) {
        //vediamo se possiamo in qualche modo superare
        //(magari non con un altro liscio)
        if(Carta1->intTornaValore() > Giocata->intTornaValore() &&
           Carta1->intTornaSeme() == Giocata->intTornaSeme() &&
           !isLiscio(Carta1))
           return *Carta1;
        if(Carta2->intTornaValore() > Giocata->intTornaValore() &&
           Carta2->intTornaSeme() == Giocata->intTornaSeme() &&
           !isLiscio(Carta2))
           return *Carta2;
        //non possiamo superare.. buttiamogli un liscio a caso!
        //potremmo finire per superare.
        if(isLiscio(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
       //non ci sono neppure lisci...
        //buttiamo dei punti
        if(isFigurata(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
        if(isFigurata(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
        //briscolette (liscio)
        if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
        //briscola figurata
        if(isFigurata(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
        if(isFigurata(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
        //solito giochetto carico-briscolona (sigh!)
       if(Carta1->intTornaSeme() != semeBriscola)
          return *Carta1;
       if(Carta2->intTornaSeme() == semeBriscola)
          return *Carta2;
          return *Carta1;
       }
    //neppure liscio.. forse e' un carico!
    if(isCarico(Giocata)) {
       //chissa' se lo possiamo superare...
       if(Giocata->intTornaValore() == TRE) {
          if(Carta1->intTornaSeme() == Giocata->intTornaSeme() &&
             Carta1->intTornaValore() == ASSO)
             return *Carta1;
          if(Carta2->intTornaSeme() == Giocata->intTornaSeme() &&
             Carta2->intTornaValore() == ASSO)
             return *Carta2;
        }
        //briscoletta
        if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
        //briscola figurata
        if(isFigurata(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
       if(isFigurata(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
        //briscolona
        if(isCarico(Carta1) && Carta1->intTornaSeme() == semeBriscola)
            return *Carta1;
        if(isCarico(Carta2) && Carta2->intTornaSeme() == semeBriscola)
            return *Carta2;
        //liscio
        if(isLiscio(Carta1))
           return *Carta1;
        if(isLiscio(Carta2))
           return *Carta2;
        //punti
        if(isFigurata(Carta1))
           return *Carta1;
        if(isFigurata(Carta2))
           return *Carta2;
        //hai tre carichi..
        //buttiamo il primo
        return *Carta1;
     }
     //allora ha giocato una carta figurata
     if(isFigurata(Giocata)) {
          //superiamo con un carico
          if(isCarico(Carta1) && Carta1->intTornaSeme() ==
Giocata->intTornaSeme())
              return *Carta1;
          if(isCarico(Carta2) && Carta2->intTornaSeme() ==
Giocata->intTornaSeme())
              return *Carta2;
          //superiamo con una figura superiore
          if(Carta1->intTornaValore() > Giocata->intTornaValore() &&
             Carta1->intTornaSeme() == Giocata->intTornaSeme())
             return *Carta1;
          if(Carta2->intTornaValore() > Giocata->intTornaValore() &&
             Carta2->intTornaSeme() == Giocata->intTornaSeme())
             return *Carta2;
          //briscoletta
        if(isLiscio(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
           //liscio
        if(isLiscio(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
        if(isLiscio(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
           //punti
        if(isFigurata(Carta1) && Carta1->intTornaSeme() != semeBriscola)
           return *Carta1;
        if(isFigurata(Carta2) && Carta2->intTornaSeme() != semeBriscola)
           return *Carta2;
           //briscola figurata
        if(isFigurata(Carta1) && Carta1->intTornaSeme() == semeBriscola)
           return *Carta1;
       if(isFigurata(Carta2) && Carta2->intTornaSeme() == semeBriscola)
           return *Carta2;
           //carico-briscoloni
       if(Carta1->intTornaSeme() != semeBriscola)
          return *Carta1;
       if(Carta2->intTornaSeme() == semeBriscola)
          return *Carta2;
       return *Carta1;
    }
}
int ValutaVincitore(carta* crtGiocatore, carta* crtPc, int semeBriscola, int
primoAgiocare) {
    //controlliamo se hanno lo stesso seme
    if(crtGiocatore->intTornaSeme() == crtPc->intTornaSeme()) {
        if(crtGiocatore->intTornaValore() == ASSO)
            return GIOCATORE;
        if(crtPc->intTornaValore() == ASSO)
            return COMPUTER;
        if(crtGiocatore->intTornaValore() == TRE && crtPc->intTornaValore()
!= ASSO)
            return GIOCATORE;
        if(crtPc->intTornaValore() == TRE && crtGiocatore->intTornaValore()
!= ASSO)
            return COMPUTER;
        if(crtGiocatore->intTornaValore() > crtPc->intTornaValore())
            return GIOCATORE;
        else
            return COMPUTER;
    }
    //vediamo se qualcuno ha giocato una briscola
    if(crtGiocatore->intTornaSeme() == semeBriscola)
        return GIOCATORE;
    if(crtPc->intTornaSeme() == semeBriscola)
        return COMPUTER;
    //si gioca alla carta
    //chi gioca per primo vince
    return primoAgiocare;
}
bool ConfrontaCarta(carta* crt1, carta* crt2) {
    if((crt1)->intTornaValore() == crt2->intTornaValore() &&
       (crt1)->intTornaSeme() == crt2->intTornaSeme())
       return TRUE;
    return FALSE;
}
int vincita(int a, carta* crtPc, carta* crtGioc, vector<carta> gioc,
vector<carta> pc) {
    switch(a) {
        case GIOCATORE: {
            cout << "Hai preso tu" << endl;
            gioc.push_back(*crtPc);
            gioc.push_back(*crtGioc);
            return GIOCATORE;
            break;
            }
        case COMPUTER: {
            cout << "Ha preso il computer" << endl;
            pc.push_back(*crtPc);
            pc.push_back(*crtGioc);
            return COMPUTER;
            break;
        }//case
    }//switch
    return 0;
}
void stampaVettore(vector<carta*> vettore) {
    for(vector<carta*>::iterator iter = vettore.begin(); iter !=
vettore.end(); ++iter) {
        cout << (*iter)->strTornaNome();
    }
    cout << endl
}
#endif _BRISCOLA_GAMEPLAY_H
non so perché, ma alcune indentazioni sono andate perse nel processo di
copincolla..
mi dispiace per la non-leggibilità >_<
--
Lupin85©
FILSer #2 - Founder di #fils
"It is not important what you believe, only that you believe"

Lupin85Š wrote:
[maxy - ultra - mega - cut]
Che main immenso hai fatto scusa? Saranno 500 righe! Come fai ad 
orientarti e a fare un po' di debug? Ti consiglio di iniziare a ridurre il 
main...
Eccoti un esempio di progettazione che, a grandi linee, seguirei io:
classe Carta
classe Mazzo
	- gestisce un mazzo di carte
classe Giocatore
	- rappresenta un giocatore
classe Umano: Giocatore
	- rappresenta un giocatore umano
classe UmanoInternet: Umano
	- rappresenta un giocatore umano via internet (se hai voglia di sbatterti 
coi socket)
classe Computer: Giocatore
	- rappresenta un giocatore controllato dal computer
classe Partita
	- gestisce i giocatori in gioco
	- gestisce il punteggio
	- consente caricamento e salvataggio
	- gestisce il mazzo di carte
classe Videgioco
	- gestisce un elenco di partite
main
	- inizializza un Videogioco e lascia fare tutto a lui
-- 
Andrea Bergia - studente
Linux Registred User #281550

Andrea Bergia, hai turbato la mia meditazione scrivendo questo:

in effetti mi sono accorto di averlo progettato decisamente male (una
merda, per dirla pulita)
ho tenuto solo mazzo.h e carta.h, mi sto buttando a riscrivere tutto
dall'inizio
grazie :)
--
Lupin85Š


 dall'inizio
se conosci java dai un'occhiata qui.

dimenticavo il link:
http://www.sauronsoftware.it/software/java/jbriscola/index.html

 se conosci java dai un'occhiata qui.
grazie del link ^_^
purtroppo non conosco java, ma può servire comunque
--
Lupin85©
