#include <stdio.

h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include "face.h"
//**********inizio funzioni dichiarate da me
void checkCapelli(Identity[],char *,Identity,int );
void checkMento(Identity[],char *,Identity,int );
void checkNaso(Identity[],char *,Identity,int );
void checkOcchi(Identity[],char *,Identity,int );
bool presentePersonaggio(Identity );
int computerDifficile(Identity [],int ,Identity );
int computerFacile(Identity [],int ,Identity);
Identity aggiornaTabella(Identity ,Identity );
//**********fine funzioni dichiarate da me
int main(int argc, char *argv[])
{
//-----dichiarazione variabili utilizzate
Identity utente,computer,tabellone[15],tabellone_computer[15];
int
vittorie_cpu=0,vittorie_utente=0,numero_partite=0,decisione=2,casuale=0,difficolta=
0,identita_giocatore=0,identita_computer=0,contatore=0,domanda=0;
int
numero_domanda=0,scelta=0,i=0,j=0,numero_personaggi=0,posizione=0,numero_turni_parz
iali=0,numero_turni_totali=0,provare=0;
char nome_utente[20],nome_computer[20],tentativo[4];
bool inizio=true,continuare=false,esito=false;
//----fine dichiarazione variabili
//----inizio programma
printf("*********** BENVENUTO NEL GIOCO INDOVINA CHI *********** \n\n\n");
printf("inserisci il tuo nome : ");
scanf("%s",nome_utente); //riceve il nome del giocatore

//------INIZIO SCELTA CHI INIZIA PRIMA E DIFFICOLTA'----

//------INIZIO PARTITA----
do
{
srand(time(NULL)); //inizializzo il generatore di numeri pseudo-casuali
casuale=rand()%17; //genera casualmente un numero da 0 a 16 che permette
di avere un nome casuale dalla lista
strcpy(nome_computer, names[casuale]);//copio il contenuto della stringa
names in posizione "casuale" in nome_computer
printf("\nLe carte dei personaggi stanno per essere consegnate.... \n");
//assegno all'identit� del computer la posizione del nome assegnato
precedentemente
do
{
identita_giocatore=rand()%16;
}while(identita_giocatore==casuale);//ciclo per evitare che il giocatore e il
computer abbiano carte uguali
utente=getID(identita_giocatore); //salvo l'identit� casuale del giocatore
nella variabile utente
computer=getID(casuale); //salvo l'identit� del computer nella variabile
computer
//------FINE ASSEGNAZIONE PERSONAGGI CON CONTROLLI----
printf("\nScegli la difficolta del gioco (0:Facile 1:Difficile): ");
scanf("%i",&difficolta); //riceve la difficolt�
if(difficolta==1) //if di controllo difficolt�
 printf("\nModalita' difficile avviata....\n"); //1=difficile
else
printf("\nModalita' facile avviata....\n"); //0=facile
numero_turni_parziali=0; //conteggio turni di ogni partita
printf("\nVuoi iniziare per primo oppure far iniziare il computer ?
(1:computer 0:utente): ");
scanf("%d",&decisione); //riceve l'ordine di chi gioca per primo
if(decisione==0) //controllo per chi inizia per primo:utente
printf("\nIniziera' per primo: %s \n",nome_utente); //0=inizio utente
else
printf("\nIniziera' per primo il computer: \n"); //1=inizio computer
for(i=0;i<16;i++) //ciclo che si ripete per il numero di figure presenti (16) e
riempie i due tabelloni utente e computer
{
tabellone_computer[i]=getID(i); //carico tutto il tabellone del computer
tabellone[i]=getID(i); //carico tutto il tabellone dell utente
}
do
{
numero_turni_parziali++; //aumento di 1 i turni parziali
if(decisione==0) //turno giocatore
{
decisione=1; //imposto subito la variabile a 1 per permettere al
prossimo turno di far giocare il computer
printf("\n********TABELLONE*********** \n");
for(i=0;i<16;i++) //stampa tutte le figure sul tabellone dell'utente
printId(tabellone[i]);
//********MENU
printf("\nCategoria di domande :\n");
printf("1) Capelli\n");
printf("2) Occhi\n");
printf("3) Naso\n");
printf("4) Mento\n");
printf("5) Provare a indovinare il nome\n");
scanf("%i",&domanda);
switch (domanda)
{
case 1: //************ CASO CAPELLI*******************
printf("\nCosa vuoi chiedere? :\n");
printf("1) Ha i capelli corti (/''')? \n");
printf("2) Ha i capelli ricci (@@@@)?\n");
printf("3) Ha i capelli lunghi (///\\)?\n");
printf("4) Ha i capelli mossi (/\'\'\')?\n");
scanf("\n %i",&domanda);
switch (domanda)
{
case 1:
checkCapelli( tabellone,"/'''",computer,0);
//chiamata funzione per capelli corti
break;
case 2:
checkCapelli( tabellone,"@@@@",computer,0);
//chiamata funzione per capelli ricci
break;
case 3:

checkCapelli( tabellone,"///\\",computer,0); //chiamata funzione per capelli lunghi

break;
case 4:
 checkCapelli( tabellone,"/\'\'\'",computer,0);
//chiamata funzione per capelli mossi
break;
}
break;
case 2: //************CASO OCCHI****************
printf("\nCosa vuoi chiedere? :\n");
printf("1) Ha gli occhi piccoli (oo) ? \n");
printf("2) Ha gli occhi grandi (OO)?\n");
printf("3) Ha gli occhi a mandorla (++)?\n");
printf("4) Ha gli occhiali (-)?\n");
scanf("\n %i",&domanda);
switch (domanda)
{
case 1:

checkOcchi(tabellone,"\0\0oo",computer,0); //chiamata funzione per occhi piccoli

break;
case 2:
checkOcchi(tabellone,"\0\0OO",computer,0);
//chiamata funzione per occhi grandi
break;
case 3:
checkOcchi(tabellone,"\0\0++",computer,0);
//chiamata funzione per occhi a mandorla
break;
case 4:
checkOcchi(tabellone,"\0-\0\0",computer,0);
//chiamata funzione per occhiali
break;
}
break;
case 3: //*************CASO NASO**********
printf("\nCosa vuoi chiedere? :\n");
printf("1) Ha il naso grosso (>) ? \n");
printf("2) Ha il naso all'insu' (^)?\n");
printf("3) Ha il naso piccolo? (`)?\n");
printf("4) Ha il naso acquilino? (7)?\n");
scanf("\n %i",&domanda);
switch (domanda)
{
case 1:
checkNaso(tabellone,"\0\0\0>",computer,0); //chiamata
funzione per naso grosso
break;
case 2:
checkNaso(tabellone,"\0\0\0^",computer,0);
//chiamata funzione per naso all'ins�
break;
case 3:
checkNaso(tabellone,"\0\0\0`",computer,0);
//chiamata funzione per naso piccolo
break;
case 4:
checkNaso(tabellone,"\0\0\0z",computer,0); //chiamata funzione per naso acquilino
break;
}
break;
case 4: //***********CASO MENTO***************
 printf("\nCosa vuoi chiedere? :\n");
printf("1) Ha il mento piatto (_=) ? \n");
printf("2) Ha il mento rotondo (_u)?\n");
printf("3) Ha il mento strano? (-)?\n");
printf("4) Ha il mento a spigolo? (_v)?\n");
scanf("\n %i",&domanda);
switch (domanda)
{
case 1:
checkMento(tabellone,"\0\0_=",computer,0);
//chiamata funzione per mento piatto
break;
case 2:

checkMento(tabellone,"\0\0_u",computer,0); //chiamata funzione per mento rotondo

break;
case 3:

checkMento(tabellone,"\0\0-\0",computer,0); //chiamata funzione per mento strano

break;
case 4:

checkMento(tabellone,"\0\0_v",computer,0); //chiamata funzione per mento a spigolo

break;
}
break;
case 5://*************CASO DI INDOVINARE*********************
printf("\nInserisci il nome del personaggio del computer\n");
scanf("%s",tentativo);//ricevo la stringa inserita dall'utente
if(strcmp(tentativo,computer->name)==0) //confronta le due
stringhe
{ //se ha indovinato cio� =0
printf("\n\n*********RISPOSTA ESATTA HAI
VINTO************\n\n");
numero_partite++; //incremento il numero di partite giocate
vittorie_utente++; //incremento il numero di vittorie
dell'utente
decisione=2; //imposto a 2 per poterlo portare alla richiesta
di rigiocare o abbandonare
}
else //se ha sbagliato !=0
{
printf("\n\n*********RISPOSTA ERRATA HAI
PERSO************\n\n");
numero_partite++; //incremento il numero di partite
giocate
vittorie_cpu++; //incremento il numero di partite vinte dal
computer
decisione=2;
}
break;
}

if(decisione!=2)
{
printf("\n********TABELLONE AGGIORNATO**********\n");
for(i=0;i<16;i++) //ristampa il tabellone del giocatore dopo averlo
aggiornato
 printId(tabellone[i]);
printf("\n Vuoi provare a dire un nome?\n(0=no 1=si)");
scanf("%d",&provare); //ricevo in ingresso la decisione se vuole
indovinare o passare il turno
if(provare==1)
{
printf("\nInserisci il nome del personaggio del computer\n");
scanf("%s",tentativo); //ricevo il nome inserito dal giocatore
if(strcmp(tentativo,computer->name)==0) //confronta le due
stringhe
{
printf("\n\n*********RISPOSTA ESATTA HAI
VINTO************\n\n");
numero_partite++;
vittorie_utente++;
decisione=2;
}
else
{
printf("\n\n*********RISPOSTA ERRATA HAI
PERSO************\n\n");
numero_partite++;
vittorie_cpu++;
decisione=2;
}
}
}

}
//**************TURNO COMPUTER**********************
if (decisione==1)
{
decisione=0;
printf("\nE ' il turno del computer ....\n");
printf("\nLa mia carta e' : \n");
printId(utente); //stampo a schermo la mia figura
if(difficolta==1) //difficolt� difficile
{
numero_personaggi=0; //imposto a 0 il conteggio delle figure sul
tabellone a ogni inzio turno del computer
for(i=0;i<16;i++) //ripeto per il numero massimo delle figure
{
if(presentePersonaggio(tabellone_computer[i])==true) //chiamata
di funzione che restituisce un bool
{
numero_personaggi++; //conto quante persone ci sono nel tabellone
posizione=i;//mi salvo la posizione perch� in caso ce ne fosse uno
solo conosco gi� il nome
}
}
if(numero_personaggi>1) //se presente pi� di una

numero_domanda=computerDifficile(tabellone_computer,numero_domanda,utente);
//chiamata di funzione che fa la domanda in ordine difficile
else
{ //strcmp confronta le due stringhe 0 se sono uguali !=0 se sono
diverse
if(strcmp(tabellone_computer[posizione]->name,utente->name)==0)
//altrimenti rispondo
{
printf("\n\n*********IL COMPUTER HA VINTO************\n\n");
printf("\n\nHa indovinato il nome della tua carta:
%s\n\n",tabellone_computer[posizione]->name); //stampa il nome che ha indovinato
per confermare all'utente
numero_partite++;
vittorie_cpu++;
decisione=2;
}
else
{
printf("\n\nTI HO SCOPERTO...HAI BARATO...HAI PERSO NON SI
BARA\n\n");
numero_partite++;
vittorie_cpu++;
decisione=2;
}
}
} //******FINE MODALITA DIFFICILe
else //***********MODALITA FACILE
{
numero_personaggi=0; //resetto il numero di personaggi presenti
for(i=0;i<16;i++) //scorro tutto il tabellone
{
if(presentePersonaggio(tabellone_computer[i])==true)
{
numero_personaggi++;
posizione=i;//in caso ci sia solo uno presente ho direttamente la
sua posizione
}
}
if(numero_personaggi>1) //in caso di pi� personaggi fa un' altra
domanda

numero_domanda=computerFacile(tabellone_computer,numero_domanda,utente);
//chiamata funzione per domande in ordine facile
else
{
if(strcmp(tabellone_computer[posizione]->name,utente->name)==0)
{
printf("\n\n*********IL COMPUTER HA VINTO************\n\n");
printf("\n\nHa indovinato il nome della tua carta:
%s\n\n",tabellone_computer[posizione]->name); //mostra il nome della figura
numero_partite++;
vittorie_cpu++;
decisione=2;
}
else
{
printf("\n\nTI HO SCOPERTO...HAI BARATO...HAI PERSO NON SI
BARA\n\n");
numero_partite++;
vittorie_cpu++;
decisione=2;
}
}
}
}
 //turno dedicato all'utente dopo aver vinto/perso la partita
if(decisione==2)
{
printf("\n\nPuoi iniziare un altra partita , digita 1 se vuoi inziziare
oppure 0 se vuoi abbandonare..\n\n");
scanf("%d",&scelta);
decisione=3;
}
}while(decisione!=3);
numero_turni_totali=numero_turni_totali+numero_turni_parziali; //sommo ai numeri
di turni totali quelli della partita appena giocata
}while(scelta!=0); //se digita 0 esce dal ciclo
printf("*********STATISTICHE PARTITE*********\n\n");
printf("Il numero di partite giocare e' : %d \n",numero_partite); //mostra
partite toali
printf("Il numero di partite vinte da %s e' : %d
\n",nome_utente,vittorie_utente); //mostra vittorie utente
printf("Il numero di partite vinte dal computer e' : %d \n",vittorie_cpu);
//mostra vittorie cpu
printf("Il numero di turni giocati nell'ultima partita e' : %d
\n",numero_turni_parziali); //mostra i turni dell'ultima partita
printf("Il numero di turni totali giocati e' : %d \n",numero_turni_totali);
//mostra turni totali giocati
return 0;
}

//FUNZIONI CREATE DA ME
void checkCapelli(Identity tabellone[],char *hair,Identity computer,int turno)
//definizione di funzione che controllla i capelli
{
int risposta=0,i=0;
if(turno==0) //se � il turno dell'utente
{
int i=0;
if(hasHair(computer,hair)==true) //chiamata funzione di controllo dei
capelli fatta dal docente
{
for(i=0;i<16;i++) //ripete per tutte le figure
if(hasHair(getID(i),hair)==false)
tabellone[i]=aggiornaTabella(tabellone[i], computer); //chiamata
funzione per modificare il tabellone
}
else
{
for(i=0;i<16;i++)
if(hasHair(getID(i),hair)==true)
tabellone[i]=aggiornaTabella(tabellone[i], computer); //chiamata
funzione per modificare il tabellone
}
}
else //turno del computer
{
printf("\nLa tua carta ha i capelli %s ? (1=si 0=no)\n",hair);
scanf("%d",&risposta);//ricevo la risposta del giocatore
if(risposta==0) //se rispondo di no controlla tutto il tabellone e elimina
quelli che non corrispondono
for(i=0;i<16;i++)
if(hasHair(getID(i),hair)==true)
tabellone[i]=aggiornaTabella(tabellone[i], computer);
 if(risposta==1) //se rispondo di si controlla e elimina tutti quelli che
corrispondono a quei capelli
for(i=0;i<16;i++)
if(hasHair(getID(i),hair)==false)
tabellone[i]=aggiornaTabella(tabellone[i], computer);
}
return ;
}
//******************************
Identity aggiornaTabella(Identity tabellone,Identity computer) //definzione
funzione che mi permette di annullare le figure del tabellone che non corrispondono
{
int j=0;
tabellone->name=0; //imposto il nome a 0
for(j=0;j<4;j++)
tabellone->face[j][0]='\0'; //impongo tutte le posizioni della faccia uguali al
terminatore di stringa
return tabellone; //restituisco il tabellone
}
//*********************************
void checkMento(Identity tabellone[],char *chin,Identity computer,int turno)
{
char appoggio[4];
int risposta=0,i=0,posizione=0;
if(turno==0)//turno giocatore
{
if(hasChin(computer,chin)==true) //chiamata funzione di controllo del mento fatta
dal docente
{
for(i=0;i<16;i++)
if(hasChin(getID(i),chin)==false)
tabellone[i]=aggiornaTabella(tabellone[i],computer);
}
else
{
for(i=0;i<16;i++)
if(hasChin(getID(i),chin)==true)
tabellone[i]=aggiornaTabella(tabellone[i],computer);
}
}
else//turno computer
{
printf("\nLa tua carta ha questo mento ");
//*************STAMPARE CON IL TERMINATORE
for(i=0;i<4;i++) //visto che non mi stampa la stringa, poich� presenta terminatori
di stringa, uso un vettore di appoggio
if(chin[i]!='\0')
{
appoggio[posizione]=chin[i];
posizione++; //incremento la posizione
}
for(i=0;i<posizione;i++)
printf("%c",appoggio[i]);
printf("?(1=si 0=no)\n");
scanf("%d",&risposta); //ricevo la risposta dell'utente
//*******************************
if(risposta==0) //se rispondo di no controlla tutto il tabellone e elimina quelli
che non corrispondono
for(i=0;i<16;i++)
 if(hasChin(getID(i),chin)==true)
tabellone[i]=aggiornaTabella(tabellone[i], computer);
if(risposta==1) //se rispondo di si controlla e elimina tutti quelli che
corrispondono a quel mento
for(i=0;i<16;i++)
if(hasChin(getID(i),chin)==false)
tabellone[i]=aggiornaTabella(tabellone[i], computer);
}
return;
}
//**********************************
void checkOcchi(Identity tabellone[],char *eyes,Identity computer,int turno)
//funzione che controlla gli occhi
{
char appoggio[4];
int risposta=0,i=0,posizione=0;
if(turno==0) //turno del giocatore
{
if(hasEyes(computer,eyes)==true) //chiamata di funzione per controllo occhi fatta
dal docente
{
for(i=0;i<16;i++)
if(hasEyes(getID(i),eyes)==false)
tabellone[i]=aggiornaTabella(tabellone[i], computer);
}
else
{
for(i=0;i<16;i++)
if(hasEyes(getID(i),eyes)==true)
tabellone[i]=aggiornaTabella(tabellone[i],computer);
}
}
else //turno del computer
{
printf("\nLa tua carta ha questi occhi ");
//*************STAMPARE CON IL TERMINATORE
for(i=0;i<4;i++)
if(eyes[i]!='\0')
{
appoggio[posizione]=eyes[i];
posizione++;
}
for(i=0;i<posizione;i++)
printf("%c",appoggio[i]);
printf("?(1=si 0=no)\n");
scanf("%d",&risposta);
//*******************************
if(risposta==0) //se rispondo di no controlla tutto il tabellone e elimina quelli
che non corrispondono
for(i=0;i<16;i++)
if(hasEyes(getID(i),eyes)==true)
tabellone[i]=aggiornaTabella(tabellone[i], computer);
if(risposta==1) //se rispondo di si controlla e elimina tutti quelli che
corrispondono a quegli occhi
for(i=0;i<16;i++)
if(hasEyes(getID(i),eyes)==false)
tabellone[i]=aggiornaTabella(tabellone[i], computer);
}
return ;
}
//****************************
void checkNaso(Identity tabellone[],char *nose,Identity computer,int
turno)//definizione funzione per controllo del naso
{
char appoggio[4];
int risposta=0,i=0,posizione=0;
if(turno==0) //turno del giocatore
{
int i=0;
if(hasNose(computer,nose)==true)
{
for(i=0;i<16;i++)
if(hasNose(getID(i),nose)==false)
tabellone[i]=aggiornaTabella(tabellone[i],computer);
}
else
{
for(i=0;i<16;i++)
if(hasNose(getID(i),nose)==true)
tabellone[i]=aggiornaTabella(tabellone[i],computer);
}
}
else //turno del computer
{
printf("\nLa tua carta ha questo naso ");
for(i=0;i<4;i++)
if(nose[i]!='\0')
{
appoggio[posizione]=nose[i];
posizione++;
}
for(i=0;i<posizione;i++)
printf("%c",appoggio[i]);
printf("?(1=si 0=no)\n");
scanf("%d",&risposta);
//*******************************
if(risposta==0) //se rispondo di no controlla tutto il tabellone e elimina quelli
che non corrispondono
for(i=0;i<16;i++)
if(hasNose(getID(i),nose)==true)
tabellone[i]=aggiornaTabella(tabellone[i], computer);
if(risposta==1) //se rispondo di si controlla e elimina tutti quelli che
corrispondono a quel naso
for(i=0;i<16;i++)
if(hasNose(getID(i),nose)==false)
tabellone[i]=aggiornaTabella(tabellone[i], computer);
}
return;
}
//********************************
int computerDifficile(Identity tabellone_computer[],int numero_domanda,Identity
utente) //definizione di funzione che ha domande preimpostate difficolt� DIFFICILE
{
if(numero_domanda==0)
checkCapelli( tabellone_computer,"///\\",utente,1);
if(numero_domanda==1)
checkNaso(tabellone_computer,"\0\0\0>",utente,1);
if(numero_domanda==2)
 checkOcchi(tabellone_computer,"\0-\0\0",utente,1);
if(numero_domanda==3)
checkMento(tabellone_computer,"\0\0_u",utente,1);
if(numero_domanda==4)
checkCapelli(tabellone_computer,"@@@@",utente,1);
if(numero_domanda==5)
checkNaso(tabellone_computer,"\0\0\0^",utente,1);
if(numero_domanda==6)
checkOcchi(tabellone_computer,"\0\0OO",utente,1);
if(numero_domanda==7)
checkMento(tabellone_computer,"\0\0_=",utente,1);
if(numero_domanda==8)
checkCapelli( tabellone_computer,"/'''",utente,1);
if(numero_domanda==9)
checkNaso(tabellone_computer,"\0\0\0`",utente,1);
if(numero_domanda==10)
checkOcchi(tabellone_computer,"\0\0oo",utente,1);
if(numero_domanda==11)
checkMento(tabellone_computer,"\0\0_v",utente,1);
if(numero_domanda==12)
checkCapelli(tabellone_computer,"/\'\'\'",utente,1);
if(numero_domanda==13)
checkNaso(tabellone_computer,"\0\0\0z",utente,1);
if(numero_domanda==14)
checkOcchi(tabellone_computer,"\0\0++",utente,1);
if(numero_domanda==15)
checkMento(tabellone_computer,"\0\0-\0",utente,1);
return numero_domanda+1;
}
//************************************
bool presentePersonaggio(Identity tabellone_cpu) //funzione che controlla se �
presente una figura in quella posizione
{
if(tabellone_cpu->name!=0)
return true;
else
return false;
}
//***********************************
int computerFacile(Identity tabellone_computer[],int numero_domanda,Identity
utente) //definizione di funzione che ha domande preimpostate difficolt� FACILE
{
if(numero_domanda==15)
checkCapelli( tabellone_computer,"///\\",utente,1);
if(numero_domanda==14)
checkNaso(tabellone_computer,"\0\0\0>",utente,1);
if(numero_domanda==13)
checkOcchi(tabellone_computer,"\0-\0\0",utente,1);
if(numero_domanda==12)
checkMento(tabellone_computer,"\0\0_u",utente,1);
if(numero_domanda==11)
checkCapelli(tabellone_computer,"@@@@",utente,1);
if(numero_domanda==10)
checkNaso(tabellone_computer,"\0\0\0^",utente,1);
if(numero_domanda==9)
checkOcchi(tabellone_computer,"\0\0OO",utente,1);
if(numero_domanda==8)
checkMento(tabellone_computer,"\0\0_=",utente,1);
if(numero_domanda==7)
 checkCapelli( tabellone_computer,"/'''",utente,1);
if(numero_domanda==6)
checkNaso(tabellone_computer,"\0\0\0`",utente,1);
if(numero_domanda==5)
checkOcchi(tabellone_computer,"\0\0oo",utente,1);
if(numero_domanda==4)
checkMento(tabellone_computer,"\0\0_v",utente,1);
if(numero_domanda==3)
checkCapelli(tabellone_computer,"/\'\'\'",utente,1);
if(numero_domanda==2)
checkNaso(tabellone_computer,"\0\0\0z",utente,1);
if(numero_domanda==1)
checkOcchi(tabellone_computer,"\0\0++",utente,1);
if(numero_domanda==0)
checkMento(tabellone_computer,"\0\0-\0",utente,1);
return numero_domanda+1;
return numero_domanda+1;
}