main.c

/*
..::WHAT'S NEW::..

v 1.4-beta - Eliminato il puntatore int_pointer.

v 1.3-beta - Modificata macro INWHITE (correzione colore).

v 1.2-beta - Inglobato il puntatore int_pointer nella funzione checkMatches.

v 1.1-beta - . Aggiunto controllo iniziale sulla lettura delle istruzioni da parte dell'utente: se l'utente prova ad
             avviare il gioco senza aver prima letto le istruzioni, viene visualizzato un messaggio che consiglia di leggerle.
             . Corretto typo nelle istruzioni.

v 1.0-beta - Release iniziale (disponibile anche per Windows).
*/


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>


//DICHIARAZIONI FUNZIONI
//int charToInt(char mn, int startAscii, int endAscii);
void ignoreInputUntil(const char endCh);
void getSequence(char usrSeq[], const int sz);
bool checkSequence(const char usrSeq[], const int sz);
void printSequence(const char seq[]);
void randomizeSequence(char cpuSeq[], const int sz);
void startGame(void);
bool printHowTo(void);
void printCredits(void);
int chooseDifficultyLevel(void);
void checkMatches(const char usrSeq[], const char cpuSeq[], const int sz);
bool checkExit(const char usrSeq[]);


//PARTI GRAFICHE
/*
#define RED printf("\033[1;31m");
#define GREEN printf("\033[1;32m");
#define YELLOW printf("\033[1;33m");
#define BLUE printf("\033[1;34m");
#define RESETCOLOR printf("\033[0m");
*/

#define INRED "\033[1;31m"
#define INGREEN "\033[1;32m"
#define INYELLOW "\033[1;33m"
#define INBLUE "\033[1;34m"
#define INWHITE "\033[1;39m"
#define INRESETCOLOR "\033[0m"
#define ERRORCOLOR "\033[1;31m\a"
#define WINCOLOR "\033[5;1;39m"

#define BLOCK "\u2B24"
#define BLACKMATCH "\u25A0 "
#define WHITEMATCH "\u25A1 "

#define RBLOCK INRED BLOCK INRESETCOLOR "  "
#define GBLOCK INGREEN BLOCK INRESETCOLOR "  "
#define BBLOCK INBLUE BLOCK INRESETCOLOR "  "
#define YBLOCK INYELLOW BLOCK INRESETCOLOR "  "

#define TITLE printf(INWHITE "               _                 _       _ \n");\
              printf(INWHITE " _____ ___ ___| |_ ___ ___ _____|_|___ _| | by\n");\
              printf(INWHITE "|     | .'|_ -|  _| -_|  _|     | |   | . | Davide\n");\
              printf(INWHITE "|_|_|_|__,|___|_| |___|_| |_|_|_|_|_|_|___| Dettori\n" INRESETCOLOR);\
              printf("                                 v 1.4-beta\n");

#define PROMPT printf("\n> ");
#define CLEARSCR printf("\033[H\033[J");


//CONDIZIONI
#define IS_LOWER_CASE(x) (((x)>='a') && ((x)<='z'))
#define IS_A_COLOR(x) (((x)=='R') || ((x)=='G') || ((x)=='V') || ((x)=='B'))
#define IS_NOT_A_COLOR(x) (((x)!='R') && ((x)!='G') && ((x)!='V') && ((x)!='B'))
#define IS_NOT_YES_OR_NO(x) (((x)!='y') && ((x)!='Y') && ((x)!='n') && ((x)!='N'))
#define IS_YES(x) (((x)=='y') || ((x)=='Y'))


//VARIABILI GLOBALI
/*Queste variabili sono settate come globali perché verranno utilizzate in 2 differenti funzioni.*/
int whMatch;
int blMatch;
/*Questa variabile è settata come globale perché verrà utilizzata in 3 differenti funzioni. Serve da flag nel caso l'utente, durante una
sessione di gioco, digiti la sequenza speciale EXIT per tornare immediatamente al menu principale.*/
bool exitNow;





int main(void)
{
    char menu;
    /*Selettore del menu iniziale.*/
    bool readHowTo;
    /*Flag che segnala se sono state lette le istruzioni*/
    char howTo;

    do
    {
        CLEARSCR
        TITLE

        printf("Benvenuto in Mastermind.\n");

        do
        {
            printf("1. Gioca\n2. Istruzioni\n3. Crediti\n4. Esci");
            PROMPT
            menu=getchar();
            ignoreInputUntil('\n');

            switch(menu)
            {
                case '1':
                    if(!readHowTo)
                    /*Nel caso in cui si tenti di iniziare una partita senza aver letto le istruzioni, il programma consiglia di leggerle.*/
                    {
                        CLEARSCR
                        printf(INWHITE "ATTENZIONE: prima di giocare si consiglia di leggere le istruzioni.\n\n" INRESETCOLOR);
                        do
                        /*Ciclo di controllo valore in input: vengono accettate solo le risposte y, Y, n, N.*/
                        {
                            printf("Vuoi leggere le istruzioni? [Y/N]");
                            PROMPT
                            howTo=getchar();
                            ignoreInputUntil('\n');
                            if(IS_NOT_YES_OR_NO(howTo))
                                printf(ERRORCOLOR "ERRORE: scelta non valida.\n" INRESETCOLOR);
                        }while(IS_NOT_YES_OR_NO(howTo));

                        if(IS_YES(howTo))
                        /*Se il giocatore decide di leggere le istruzioni, queste vengono mostrate prima della prima partita.*/
                            readHowTo=printHowTo();
                        else
                        /*Altrimenti il flag readHowTo viene posto a true e questo suggerimento iniziale non viene più mostrato fino al
                        prossimo avvio del programma.*/
                            readHowTo=true;
                    }
                    startGame();
                    break;
                case '2':
                    readHowTo=printHowTo();
                    break;
                case '3':
                    printCredits();
                    break;
                case '4':
                    return 0;
                    break;
                default:
                    ignoreInputUntil('\n');
                    printf(ERRORCOLOR "ERRORE: scelta non valida.\n" INRESETCOLOR);
            }
        }while(menu<'1' || menu>'4');
    }while(menu!='4');

    return 0;
}


/*La funzione ignora tutti i caratteri in input finché non viene digitato un carattere uguale a endCh*/
void ignoreInputUntil(const char endCh)
{
    char ch;

    do
    /*Questo ciclo serve per ignorare tutti gli eventuali caratteri che l'utente potrebbe digitare dopo l'uscita dal ciclo precedente.*/
    {
        ch=getchar();
    }while(ch!=endCh);
}


/*La funzione prende in ingresso un carattere char e un range di codici ASCII (startAscii, endAscii), verifica che il carattere rientri
in questo range e lo converte nel rispettivo valore intero. Se il carattere non rientra nel range viene restituito il valore NULL
int charToInt(char mn, int startAscii, int endAscii)
{
	int intValue;

	if(mn<startAscii || mn>endAscii)
		return NULL;
	else
	{
		intValue=mn-'0';
		return intValue;
	}
}
*/


/*La funzione acquisisce una sequenza digitata dal giocatore ed effettua tutti i controlli per verificare se tale sequenza sia corretta.*/
void getSequence(char usrSeq[], const int sz)
{
    int i=0;
    char ch;
    bool isOk;

    do
    /*Ciclo di controllo valore in input: viene ripetuto finché non viene inserita una sequenza di colori correttamente
    riconosciuta dalla funzione checkSequence. La variabile booleana isOk viene utilizzata per questo controllo e viene posta a true
    se la sequenza di colori è corretta.*/
    {
        i=0;
        PROMPT

        do
        /*Questo ciclo serve per popolare la stringa usrSeq con una sequenza di colori. Continua finché non viene premuto il tasto return
        (condizione while finale) o finché l'indice i non sia uguale al valore di size (che varia in base alla difficoltà scelta).*/
        {
            if(i==sz)
            /*Se l'indice i è uguale alla dimensione massima della stringa, viene memorizzato return in ch causando
            l'uscita immediata dal ciclo.*/
            {
                ch='\n';
                usrSeq[i]=ch;

                i++;
            }
            else
            {
                ch=getchar();
                /*Legge un carattere in input.*/
                if(IS_LOWER_CASE(ch))
                /*Controlla che il carattere letto sia una lettera minuscola e, nel caso, la trasforma in maiuscola.*/
                    ch-=32;
                usrSeq[i]=ch;
                /*Memorizza il carattere letto nell'array usrSeq.*/

                i++;
            }
        }while(ch!='\n');

        ignoreInputUntil('\n');

        usrSeq[i-1]='\0';
        /*Il return alla fine dell'array viene sostituito col carattere nullo.*/

        exitNow=checkExit(usrSeq);
        /*La variabile booleana exitNow viene posta a true qualora il giocatore decidesse di interrompere una sessione di gioco per tornare
        immediatamente al menu principale digitando EXIT.*/

        /*
        //ISTRUZIONE DI CHECK
        printf("%i", exitNow);
        */

        if(!exitNow)
        /*Se exitNow è uguale a false, significa che il giocatore non ha inserito la sequenza exit.*/
        {
            isOk=checkSequence(usrSeq, sz);
            /*La sequenza viene quindi controllata per vedere se è valida (ossia se tutti i caratteri in essa contenuti sono
            associabili ad un colore).*/
            if(!isOk)
            /*Se non è valida viene visualizzato un messaggio di errore*/
                printf(ERRORCOLOR "ERRORE: la sequenza inserita non è valida." INRESETCOLOR);
        }
        else
        /*Se exitNow è uguale a true, significa che il giocatore ha inserito la sequenza exit. La variabile bool isOk
        viene quindi posta a true causando così l'uscita dalla funzione.*/
            isOk=true;

        /*
        //INIZIO BLOCCO DI CHECK
        printf("\n%s", usrSeq);
        printf("\nisOk = %i", isOk);
        for(; i>=0; i--)
            printf("\nusrSeq[%i] vale %c", i, usrSeq[i]);
        printf("\n");
        //FINE BLOCCO DI CHECK
        */
    }while(!isOk);
}


/*La funzione controlla che se l'utente, durante una sessione di gioco, digita la sequenza speciale EXIT per tornare
immediatamente al menu principale.*/
bool checkExit(const char usrSeq[])
{
    const char exitKey[]="EXIT";
    int i=0;

    while(usrSeq[i]==exitKey[i] && usrSeq[i]!='\0' && exitKey[i]!='\0')
    /*Fintanto che usrSeq e exitKey sono uguali nella posizione i e in queste posizioni non sia presente il carattere nullo viene
    incrementato di uno l'indice i. Si esce dal ciclo quando viene trovato un carattere nullo.*/
        i++;

    if(usrSeq[i]==exitKey[i])
    /*Se dopo essere usciti dal ciclo precedente, entrambe le stringhe nell'indice i contengono il carattere nullo, allora possiamo
    essere sicuri che usrSeq sia uguale a exitKey, e che quindi il giocatore abbia digitato EXIT. Viene restituito true.*/
        return true;

    else
    /*Altrimenti, se le stringhe non coincidono, significa che il giocatore non ha digitato exit e viene quindi restituito false.*/
        return false;
}


/*La funzione controlla che i caratteri inseriti dall'utente siano validi, ossia "trasformabili" in un colore dalla funzione printSequence.*/
bool checkSequence(const char usrSeq[], const int sz)
{
    int i;

    for(i=0; i<sz; i++)
        if(IS_NOT_A_COLOR(usrSeq[i]))
            return false;

    return true;
}


/*La funzione stampa una sequenza di colori.*/
void printSequence(const char seq[])
{
    int i;

    for(i=0; seq[i]!='\0'; i++)
        switch(seq[i])
        {
            case 'R':
                printf(RBLOCK);
                break;
            case 'G':
                printf(YBLOCK);
                break;
            case 'V':
                printf(GBLOCK);
                break;
            case 'B':
                printf(BBLOCK);
                break;
        }
}


/*La funzione crea la sequenza casuale di colori che l'utente dovrà indovinare.*/
void randomizeSequence(char cpuSeq[], const int sz)
{
    int i, chaos;

    srand(time(0));

    for(i=0; i<sz; i++)
    {
        chaos=rand()%4;
        /*Nella variabile chaos viene memorizzato un numero casuale tra 0 e 3 che andrà poi switchato e associato ad
        un colore da inserire nell'array cpuSeq.*/

        switch(chaos)
        {
            case 0:
                cpuSeq[i]='R';
                break;
            case 1:
                cpuSeq[i]='G';
                break;
            case 2:
                cpuSeq[i]='V';
                break;
            case 3:
                cpuSeq[i]='B';
                break;
        }
    }

    cpuSeq[i]='\0';

    /*
    //INIZIO BLOCCO DI CHECK
    printf("\n%s", cpuSeq);
    for(; i>=0; i--)
        printf("\ncpuSeq[%i] vale %c", i, cpuSeq[i]);
    printf("\n");
    //FINE BLOCCO DI CHECK
    */
}


/*La funzione serve per selezionare il livello di difficoltà del gioco: in base alla scelta viene restituito il numero di colori che
il giocatore dovrà decifrare, ossia la lunghezza delle stringhe userSequence e cpuSequence.*/
int chooseDifficultyLevel(void)
{
    char diff;

    do
    {
        printf("Seleziona il livello di difficoltà:\n1. Facile\n2. Medio\n3. Difficile");
        PROMPT
        diff=getchar();
        ignoreInputUntil('\n');

        switch(diff)
        {
            case '1':
                return 4;
                break;
            case '2':
                return 5;
                break;
            case '3':
                return 6;
                break;
            default:
                ignoreInputUntil('\n');
                printf(ERRORCOLOR "ERRORE: scelta non valida.\n" INRESETCOLOR);
        }
    }while(diff<'1' || diff>'3');
}


/*La funzione confronta la sequenza immessa dall'utente con quella del computer e calcola il numero di match bianchi e match neri.
Fa uso di due array di flag per tenere traccia delle posizioni per le quali è già stato trovato un match, in maniera tale da evitare
la ripetizione dei match bianchi in alcune situazioni critiche.*/
void checkMatches(const char usrSeq[], const char cpuSeq[], const int sz)
{
    int i, j;
    bool usrFlags[7], cpuFlags[7];
    /*Variabile puntatore utilizzata per modificare i valori delle variabili globali blMatch e whMatch nella stessa funzione.*/

    for(i=0; i<7; i++)
    {
        usrFlags[i]=false;
        cpuFlags[i]=false;
    }

    blMatch=0;
    /*Il valore di blMatch viene inizializzato a 0*/

    for(i=0; i<sz; i++)
    /*Questo ciclo for serve a calcolare il numero di match neri, che indicano i cerchi di colore esatto nella corretta posizione:
    finché i è minore della dimensione della stringa contenuta in usrSeq (ad esclusione del carattere nullo)...*/
        if(usrSeq[i]==cpuSeq[i])
        /*...se usrSeq[i] è uguale a cpuSeq[i] significa che c'è un colore giusto nel posto giusto.*/
        {
            blMatch++;
            /*Viene quindi incrementato di 1 il numero dei match neri,*/
            usrFlags[i]=true;
            /*nell'array usrFlag viene posta a true la posizione coincidente con quella di usrSeq[i]*/
            cpuFlags[i]=true;
            /*e nell'array cpuFlag viene posta a true la posizione coincidente con quella di cpuSeq[i]*/
        }

    /*
    //ISTRUZIONE DI CHECK
    printf("%i", blMatch);
    */

    whMatch=0;
    /*Il valore di whMatch viene inizializzato a 0*/

    for(i=0; i<sz; i++)
    /*Questo ciclo for serve a calcolare il numero di match bianchi, che indicano i cerchi di colore esatto in una posizione sbagliata:
    finché i è minore della dimensione della stringa contenuta in usrSeq (ad esclusione del carattere nullo)...*/
        for(j=0; j<sz; j++)
        /*...viene fatto scorrere l'array cpuSeq tramite l'indice j.*/
            if(i!=j && usrSeq[i]==cpuSeq[j] && usrFlags[i]==false && cpuFlags[j]==false)
            /*Se i è diverso da j significa che le posizioni di usrSeq e cpuSeq alle quali stanno puntando i due indici sono differenti,
            pertanto potrebbe esserci la possibilità di un white match. Se usrFlags e cpuFlags nelle posizioni puntati dagli indici i e j
            sono uguali a false, significa che per quelle stesse posizioni negli array usrSeq e cpuSeq non è stato ancora trovato un white match.
            Allora, se usrSeq[i] e cpuSeq[i] contengono lo stesso valore, ci troviamo sicuramente di fronte ad un white match.*/
            {
                whMatch++;
                /*Viene incrementato di 1 il numero dei white match,*/
                usrFlags[i]=true;
                /*nell'array usrFlag viene posta a true la posizione coincidente con quella di usrSeq[i],*/
                cpuFlags[j]=true;
                /*e nell'array cpuFlag viene posta a true la posizione coincidente con quella di cpuSeq[i].*/
            }

    /*
    //ISTRUZIONE DI CHECK
    printf("%i", whMatch);
    */
}


/*La funzione dà il via ad una partita.*/
void startGame(void)
{
    char userSequence[7], cpuSequence[7], replay;
    int size, i, tryCounter;
    /*In tryCounter vengono memorizzati il numero di tentativi effettuati per decifrare la sequenza.*/

    do
    /*Questo ciclo è associato alla variabile char replay e serve a far cominciare un'altra partita nel caso
    il valore di replay sia 'y' o 'Y'.*/
    {
        CLEARSCR
        size=chooseDifficultyLevel();
        CLEARSCR

        randomizeSequence(cpuSequence, size);
        //printSequence(cpuSequence);
        /*NB: DECOMMENTARE LA FUNZIONE PRECEDENTE SE SI VUOLE VISUALIZZARE LA SEQUENZA DEL COMPUTER DURANTE LA PARTITA.*/

        tryCounter=0;
        printf("Inserisci una sequenza di %i colori: ", size);

        do
        /*Questo è il ciclo dove si svolge il gioco: il giocatore digita la sequenza da decifrare e riceve i relativi indizi. Il ciclo si
        può fermare in due modi: o il giocatore vince indovinando la sequenza del computer (e quindi ottenendo tanti black match quanti
        sono i colori della sequenza) o il giocatore digita la sequenza speciale EXIT per tornare immediatamente al menu principale.*/
        {
            getSequence(userSequence, size);
            /*Il giocatore inserisce una sequenza.*/
            if(!exitNow)
            /*Se la sequenza non è EXIT, allora questa viene stampata e confrontata con quella del computer.*/
            {
                printSequence(userSequence);
                checkMatches(userSequence, cpuSequence, size);

                printf(" ");
                for(i=0; i<blMatch; i++)
                    printf(BLACKMATCH);
                for(i=0; i<whMatch; i++)
                    printf(WHITEMATCH);

                tryCounter++;
                /*Il numero dei tentativi viene incrementato.*/

                if(blMatch==size && tryCounter==1)
                /*Se il numero dei black match è uguale al numero dei colori da indovinare, viene visualizzato il messaggio che
                indica la vittoria della partita.*/
                    printf(WINCOLOR "\n\nComplimenti: hai deficrato la sequenza in un tentativo!" INRESETCOLOR);
                else if(blMatch==size)
                    printf(WINCOLOR "\n\nComplimenti: hai decifrato la sequenza in %i tentativi!" INRESETCOLOR, tryCounter);
            }
            else
            /*Se la sequenza è EXIT, allora il numero dei black match viene posto uguale al numero dei colori da indovinare, causando
            l'uscita dal ciclo.*/
                blMatch=size;
        }while(blMatch<size);


        /*
        //INIZIO BLOCCO DI CHECK
        printf("\nblack: %i", blMatch);
        printf("\nwhite: %i\n", whMatch);
        //FINE BLOCCO DI CHECK
        */

        if(!exitNow)
        /*Se la sequenza inserita dal giocatore non è EXIT, gli viene chiesto se desidera iniziare un'altra partita.*/
        {
            PROMPT
            ignoreInputUntil('\n');

            printf("\n");

            do
            /*Ciclo di controllo valore in input: serve per acquisire un valore valido che permetta al giocatore di iniziare
            un'altra partita o ritornare al menu principale.*/
            {
                printf("Vuoi fare un'altra partita? [Y/N]");
                PROMPT
                replay=getchar();
                ignoreInputUntil('\n');
                if(IS_NOT_YES_OR_NO(replay))
                    printf(ERRORCOLOR "ERRORE: scelta non valida.\n" INRESETCOLOR);
            }while(IS_NOT_YES_OR_NO(replay));
        }
        else
        /*Se la sequenza inserita dal giocatore è EXIT, la variabile replay viene posta ad un valore diverso da 'y' o 'Y' (per facilità di
        lettura qui è stato scelto 'N') causando l'uscita dal ciclo do while e il ritorno immediato al menu iniziale.*/
            replay='N';
    }while(IS_YES(replay));
}


/*La funzione mostra le istruzioni del gioco.*/
bool printHowTo(void)
{
    CLEARSCR
    printf(INWHITE "ISTRUZIONI (pag.1/4)" INRESETCOLOR);
    printf("\n");
    printf("\nIl gioco consiste nel decifrare una sequenza di cerchi colorati determinata dal");
    printf("\ncomputer.");
    printf("\n");
    printf("\nLa sequenza può contenere cerchi dello stesso colore e, a seconda della");
    printf("\nmodalità di gioco, può essere composta da 4 (FACILE), 5 (MEDIO) o ");
    printf("\n6 (DIFFICILE) cerchi.");
    PROMPT
    ignoreInputUntil('\n');

    CLEARSCR
    printf(INWHITE "ISTRUZIONI (pag.2/4)" INRESETCOLOR);
    printf("\n");
    printf("\nIl giocatore interagisce digitando la sequenza di colori tramite i seguenti");
    printf("\ncomandi:");
    printf("\n");
    printf("\nR - rosso   " RBLOCK);
    printf("\nG - giallo  " YBLOCK);
    printf("\nV - verde   " GBLOCK);
    printf("\nB - blu     " BBLOCK);
    printf("\n");
    printf("\nSe, ad esempio, si vuole inserire la sequenza verde, verde, rosso, blu; si");
    printf("\ndevono digitare le lettere VVRB (oppure vvrb) seguite dal tasto invio, senza");
    printf("\nspazi tra di loro.");
    PROMPT
    ignoreInputUntil('\n');

    CLEARSCR
    printf(INWHITE "ISTRUZIONI (pag.3/4)" INRESETCOLOR);
    printf("\n");
    printf("\nOgni volta che il giocatore inserisce una sequenza, questa viene confrontata con");
    printf("\nquella da decifrare e vengono visualizzati i seguenti indizi:");
    printf("\n");
    printf("\n");
    printf(BLACKMATCH " indica un cerchio di colore giusto nella corretta posizione");
    printf("\n");
    printf(WHITEMATCH " indica un cerchio di colore giusto nella posizione sbagliata");
    printf("\n");
    printf("\nIl gioco termina quando il giocatore indovina la sequenza corretta.");
    printf("\n");
    printf("\nIn qualsiasi momento durante una partita, se il giocatore vuole interrompere il");
    printf("\ngioco e tornare al menu principale può digitare EXIT (o exit) seguito dal");
    printf("\ntasto invio.");
    PROMPT
    ignoreInputUntil('\n');

    CLEARSCR
    printf(INWHITE "ISTRUZIONI (pag.4/4)" INRESETCOLOR);
    printf("\n");
    printf("\nNB: in qualsiasi parte del programma, il simbolo > indica che il programma sta");
    printf("\naspettando un input da parte dell'utente.");
    PROMPT
    ignoreInputUntil('\n');

    return true;
}


/*La funzione visualizza la schermata dei crediti.*/
void printCredits(void)
{
    CLEARSCR

    printf(INWHITE "CREDITI" INRESETCOLOR);
    printf("\n\nMastermind è stato interamente sviluppato da Davide Dettori come progetto\nper l'esame di programmazione.\n(Docente: prof. Marco Anisetti, Università degli Studi di Milano)");
    printf("\n\nASCII art del titolo a cura di Patrick Gillespie.\nhttp://patorjk.com/software/taag/");

    PROMPT
    ignoreInputUntil('\n');
}