Lezione 7 - sequenze e mazzi

#include <iostream>
#include <string>
#include <cstdlib>
#include <vector> // aggiungere la libreria vector

using namespace std;

//enumerazione seme
enum Seme{
    cuori = 0,
    quadri = 1,
    fiori = 2,
    picche = 3,
};

//enumerazione per i valori
enum Valori{
    Asso = 1,
    Fante = 11,
    Donna = 12,
    Re = 13,
};

class Carta{
public:
    // funzione di inizializzazione - costruttore
    Carta(int ivalore, int iseme){
        // i valori sono passati all'interno della funzione e assegnati agli
        // attributi della classe
        this->seme = iseme;
        this->valore = ivalore;
    }

    // funzione che stampa la carta
    string stampa_carta(){
        string nome_seme; // dichiarazione variabile seme

        // switch per determinare il seme
        switch(seme){
            case 0:
                nome_seme = "cuori";
                break;
            case 1:
                nome_seme = "quadri";
                break;
            case 2:
                nome_seme = "fiori";
                break;
            case 3:
                nome_seme = "picche";
                break;
            default:
                nome_seme = "seme non definito";
        }

        // valore della carta

        string nome_valore; // dichiarazione della variabile nome_valore

        switch(valore){
            case 1:
                nome_valore = "Asso";
                break;
            case 11:
                nome_valore = "Fante";
                break;
            case 12:
                nome_valore = "Donna";
                break;
            case 13:
                nome_valore = "Re";
                break;
            default:
                char buffer[33];
                itoa(valore, buffer, 10);
                nome_valore = buffer;
        }

        // costruiamo ora per intero il nome della carta
        string nome_carta = nome_valore + " di " + nome_seme;
        return nome_carta;
    }

// Attributi della classe, seme e valore
    int valore;
    int seme;
};

// swap in inglese significa scambia
// qui introduciamo il concetto di referenza
// la nostra funzione deve prendere un mazzo e scambiarne le carte.
// swap prende come argomenti un mazzo, un intero chiamato indice 1
// e uno chiamato indice 2, all'interno della funzione la carta nell
// indice i1 passerà all'indice i2 e i2 a i1
// come ben ricordi il mazzo è un vettore di carte. Il mazzo viene preso come
// referenza. Cioè si vede l'ampersand dopo la dichiarazione del tipo
// quel simbolo significa che la funzione cambierà la variabile passata
// faremo altri esempi in merito, per ora ricorda potremmo scrivere 2 tipi di
// funzioni
// uno che restituisce un nuovo mazzo
// vector<Carta> swap(vector<Carta> mazzo, int i1, int i2)
// e l'altro che cambia il mazzo in place (sul posto)
// void swap(vector<Carta>& mazzo, int i1, int i2)
// queste sono preferenze di design, che vedrai in futuro
void swap(vector<Carta>& mazzo, int i1, int i2){

    // salva la carta iniziale in una variabile temporanea
    Carta tmp_carta = mazzo[i1];

    // sovrascrivi il valore contenuto nel mazzo i2 su i1
    mazzo[i1] = mazzo[i2];

    // rimpiazza il valore contenuto in i2 con la carta temporanea
    mazzo[i2] = tmp_carta;
}


// funzione che mescola
// prendiamo come argomento il mazzo e sostituiremo le carte nel mazzo in modo
// procedurale.
void mescola(vector<Carta>& mazzo){
    cout << "mescolo mazzo..." << endl;

    // definiamo quante volte vogliamo spostar le carte, più è lugna più tempo ci vorrà
    // a mescolare il mazzo, più è corto meno il mazzo sarà mescolato
    int n_carte_mescolate = 100;



    for(int i = 0; i < n_carte_mescolate; ++i){
        // useremo la funzione rand() per generare dei numeri casuali
        // rand() genera numeri da 0 a RAND_MAX (che è dipendente da compilatori)
        // ora avremo un numero da 0 a 2147483647 però vogliamo che questo numero
        // sia da 0 il primo indice del vettore mazzo, fino a 51, ultimo indice
        // dunque useremo l'operatore modulo (%)
        int indice_casuale = rand() % 52;

        // stamperemo così i valori su una riga (nota l'assenza dell endl)
        //cout << indice_casuale << ", ";

        // Il mazzo ha 52 carte, i arrivera fino a 100
        // se i diventerà maggiore di 51, allora mazzo[i] darà un errrore
        // dato che non troverà l'elemento
        // dunque limitiamo i con lo stesso trucco per il numero casuale
        int indice_iniziale = i % 52;

        //faremo la sostituzione
        swap(mazzo, indice_iniziale, indice_casuale);


    }
    cout << endl;
}


// somma i valori contenti in un mazzo di carte:
// questa volta non modificheremo il mazzo, ma lo useremo in modalità lettura
// dunque si dice che la variabile mazzo resterà costante all interno della
// funzione
int somma(const vector<Carta>& mazzo){
    // useremo un ciclo for per sommare i valori
    int s = 0;

    for(unsigned int i = 0; i < mazzo.size(); ++i){
        s += mazzo[i].valore;
    }
    return s;
}

// Lezione 7 - Le sequenze
int main()
{
    /*---------------------
    Introduzione
    ---------------------*/
    // il prossimo passo sono delle strutture dati che sono una sequenza.
    // molte cose sono una sequenza più o meno ordinata.
    // tipo il mazzo, è una sequenza di carte

    // in C++ il container standard per contenere delle sequenze è il
    // vector. Ci sono altre strutture dati per sequenze di oggetti,
    // ognuna ha le sue proprietà, ci sono linked lists, ci sono stacks
    // ci sono maps, deque, ecc...
    // per ora impareremo a usare il vector.

    // creiamo un vettore chiamato carta fatto di una sequenza di classi Carta
    //      tipo    nome
    vector <Carta> carte;

    // ora aggiungiamo al vettore delle carte, 3 carte
    carte.push_back(Carta(Asso, cuori));
    carte.push_back(Carta(2, cuori));
    carte.push_back(Carta(3, cuori));

    // il nostro vettore carte ha ora un Asso di cuori, un 2 di cuori e un 3
    // di cuori.

    // stampa il primo elemento del vector carte
    cout << "Le tre carte nel vettore carta" << endl;
    cout << carte[0].stampa_carta() << endl;
    cout << carte[1].stampa_carta() << endl;
    cout << carte[2].stampa_carta() << endl;

    cout << endl;
    cout << "Creazione mazzo" << endl;

    // ora creeremo il mazzo!
    vector <Carta> mazzo;
    // per le sequenze in genere si preferisce usare un ciclo FOR al posto di un
    // WHILE, perchè in genere si conosce il numero di cicli effettuato.
    // il ciclo for racchiude nella sua forma 3 frasi
    // FOR(condizione_iniziale; condizione_termine; incremento)

    // in genere per i vettori si tende ad utilizzare un indice, base 0 come
    // mostrato sopra

    // facciamo il ciclo per i 13 indici delle carte
    for(int i = 0; i < 13;  ++i){
        // introduciamo il ciclo per i semi
        for(int j = 0; j < 4;  ++j){
            // per aggiungere una carta al vettore mazzo possiamo usare come
            // sopra un indice
            // mazzo[i*4 + j] = carta
            // oppure possiamo semplicemente usare una funzione che dice
            // aggiungi l'elemento in fondo alla sequenza
            Carta carta = Carta(i + 1, j);
            mazzo.push_back(carta);

            cout << "Aggiunta la carta: " << carta.stampa_carta() << " al mazzo" << endl;
            cout << "nella posizione [" << i*4 + j << "]" << endl;
        }
    }

    // Ora abbiamo creato la nostra sequenza di carte!
    // possiamo accedere alla lunghezza del mazzo
    cout << "Il mazzo ha: " << mazzo.size() << " carte" << endl;

    // ora se vogliamo la 31esima carta nella sequenza ci basterà accedere per
    // il suo indice
    cout << mazzo[31].stampa_carta() << endl;

    /*---------------------
    Mescolare il mazzo
    ---------------------*/
    // possiamo costrurire un piccolo black jack

    // prima di tutto mescoliamo il mazzo
    // per mescolare il mazzo generiamo una sequenza di numeri
    // che andranno a sostituire le carte nella sequenza

    // stampiamo le prime 5 carte
    cout << "Prima di mescolare" << endl;
    for(int i = 0; i < 5; ++i){
        cout << mazzo[i].stampa_carta() << endl;
    }

    // il principio di base è
    int random_index = 4; // assegniamo un valore random
    int initial_index = 0; // assegniamo un altro valore, chiamato valore iniziale

    // copiamo una carta dalla posizione iniziale dal mazzo
    // e la salviamo in istanza temporanea
    Carta tmp_carta = mazzo[initial_index];
    // ora assegnamo (sovrascriviamo) alla posizione iniziale del mazzo la carta random
    mazzo[initial_index] = mazzo[random_index];
    // rimettiamo la carta iniziale dove stava il random index
    mazzo[random_index] = tmp_carta;
    // se non dovessimo avere la carta temporanea sovrascriveremmo la posizione
    // del mazzo e non sapremmo più quale carta venne sovrascritta

    // possiamo ora creare una funzione di swap basata sugli indici
    cout << "Dopo il mescolamento" << endl;
    for(int i = 0; i < 5; ++i){
        cout << mazzo[i].stampa_carta() << endl;
    }

    // funzione di swap
    // al posto di scrivere le 3 istruzioni, ora scriveremo una funzione
    // che fa quello
    swap(mazzo, 4, 0);

    //creeremo ora una funzione che mescola il mazzo

    // funzione di mescolamento
    mescola(mazzo);

    for(unsigned int i = 0; i < mazzo.size(); ++i){
        cout << mazzo[i].stampa_carta() << endl;
    }

    cout << endl;

    /*---------------------
    Semplice Black Jack
    ---------------------*/
    // Black jack
    cout << "------------------" << endl;
    cout << "Game of Black Jack" << endl;
    cout << "------------------" << endl;

    // mescoliamo il mazzo rispetto a prima
    mescola(mazzo);

    cout << endl;

    // definiamo le variabili che ci servono per il gioco
    int carte_giocate = 0; // numero di carte giocate
    string answer;

    // il gioco avviene con l'utente che pesca una carta ogni volta una carta
    // se la somma dei valori delle carte supera 21 allora il giocatore perde
    // se il giocatore si ferma prima di 21
    //    se la prossima carta da un valore maggiore di 21 alla sequenza allora
    //    il giocatore vince
    //    se la prossima carta darà un valore minore di 21 il giocatore perde

    vector<Carta> carte_giocatore;
    while (answer != "fine"){

        // turno
        cout << "Turno " << carte_giocate << endl;

        // prendiamo la prima carta nel mazzo
        Carta carta_pescata = mazzo[carte_giocate];

        // Diamo la carta in mano al giocatore
        carte_giocatore.push_back(carta_pescata);

        // stampiamo le carte nella mano
        cout << "Hai pescato:" << endl;
        cout << endl;
        for(unsigned int i = 0; i < carte_giocatore.size(); ++i){
            string spacer = "";
            for(unsigned int j = 0; j < i; ++j){
                spacer += " ";
            }
            cout << spacer << carte_giocatore[i].stampa_carta() << endl;
        }
        cout << endl;

        // chiediamo al giocatore se vuole una carta
        cout << "Prossima carta?" << endl;
        cin >> answer;

        if (answer == "yes"){
            carte_giocate += 1;
        }
        else if(answer != "fine"){
            carte_giocate += 1;

            // peschiamo la prossima carta e vediamo se ha vinto
            Carta prossima_carta = mazzo[carte_giocate];

            cout << "La prossima carta è un" << endl;
            cout << prossima_carta.stampa_carta() << endl;

            // sommiamo i valori delle carte con una funzione apposta
            int somma_carte_giocatore = somma(carte_giocatore);
            int somma_totale = somma_carte_giocatore + prossima_carta.valore;

            cout << "Le tue carte sommano " << somma_totale << endl;
            // qui inseriamo le condizioni di vittoria
            cout << endl;

            if (somma_carte_giocatore <= 21 && somma_totale >= 21){
                cout << "HAI VINTO!!" << endl;
            }
            else {
                cout << "HAI PERSO!!" << endl;
            }

            // resettiamo i valori inziali
            carte_giocatore.clear(); // svuota il vettore
            mescola(mazzo);

            carte_giocate = 0;


        }

        cout << endl;
    }

    return 0;
}





/* OUTPUT
Valore della mia_carta: 1 Seme della mia_carta: 0
La mia_carta: Asso di cuori
------Il mazzo------
Asso di cuori
2 di cuori
3 di cuori
4 di cuori
5 di cuori
6 di cuori
7 di cuori
8 di cuori
9 di cuori
10 di cuori
Fante di cuori
Donna di cuori
Re di cuori
Asso di quadri
2 di quadri
3 di quadri
4 di quadri
5 di quadri
6 di quadri
7 di quadri
8 di quadri
9 di quadri
10 di quadri
Fante di quadri
Donna di quadri
Re di quadri
Asso di fiori
2 di fiori
3 di fiori
4 di fiori
5 di fiori
6 di fiori
7 di fiori
8 di fiori
9 di fiori
10 di fiori
Fante di fiori
Donna di fiori
Re di fiori
Asso di picche
2 di picche
3 di picche
4 di picche
5 di picche
6 di picche
7 di picche
8 di picche
9 di picche
10 di picche
Fante di picche
Donna di picche
Re di picche
*/