Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Forza 4 - main.c

main.c

Caricato da: Ale.gatti96
Scarica il programma completo

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <conio.h>
  4. #include <string.h>
  5. #include <time.h>
  6.  
  7. //Dimensioni campo da gioco
  8. #define R 9                                     //Numero di righe
  9. #define C 8                                     //Numero di colonne
  10.  
  11. //Caratteri stampati a video
  12. #define g1               'X'            //Carattere del giocatore 1
  13. #define g2               'O'            //Carattere del giocatore 2
  14. #define vuoto  '.'              //Carattere per uno spazio vuoto
  15. #define CVitt  'V'              //Carattere per segnare la combinazione vincente
  16.  
  17. //Valori nella matrice
  18. #define vuotoI 0                //Valore di uno spazio vuoto
  19. #define g1I 1                           //Valore del giocatore 1
  20. #define g2I 2                           //Valore del giocatore 2
  21. #define vI 3                            //Valore per segnare la combinazione vincente
  22.  
  23. //Valori che può assumere f in gioca
  24. #define FGioca 0                //Partita in corso
  25. #define FG1 1                           //Ha vinto il giocatore 1
  26. #define FG2 2                           //Ha vinto il giocatore 2
  27. #define FPareggio 3 //Pareggio
  28.  
  29. //Varie
  30. #define CN 15                                                   //Numero dei caratteri dei nomi dei giocatori
  31. #define NGV 4                                                   //Numero Gettoni per la Vittoria
  32. #define CLS system("cls")       //Funzione per pulire lo schermo su windows
  33.  
  34. //Tipologia di Gioco
  35. #define UvsU 1                  //User contro User
  36. #define UvsC 2                  //User contro Computer
  37. #define CvsC 3                  //Computer contro Computer
  38.  
  39. //Tipologia Giocatore
  40. #define User 1
  41. #define CPU  2
  42.  
  43.  
  44. //Prototipi funzioni
  45. void azzera(int m[R][C]);
  46. void stampa(int m[R][C]);
  47. char stampaCasella(int x);
  48. void stampaTitolo(void);
  49. void stampaRigaPiena(void);
  50. void gioca(char n1[CN], char n2[CN], int tg1, int tg2);
  51. int mossaPC(int m[R][C], int gp, int ga);
  52. int inserisci(int m[R][C], int c);
  53. int controllaF(int m[R][C], const int g, const int r, const int c, const int e);
  54. int giocatoreP(int g);
  55. int esiste(int r, int c);
  56.  
  57.  
  58. //Corpi delle funzioni
  59. int main(int argc, char *argv[]){
  60.   char n1[CN]="Giocatore A", n2[CN]="Giocatore B", r, k=0;
  61.   int m[R][C], tipoGioco=0, tg1, tg2;
  62.   srand(time(NULL));
  63.  
  64.   do{
  65.         CLS;
  66.         stampaTitolo();
  67.         printf("\n\t 1. User vs User");
  68.                 printf("\n\t 2. User contro Computer");
  69.                 printf("\n\t 3. Computer contro Computer");
  70.         printf("\n\n   Scegli la modalita' di gioco: ");
  71.         scanf("%d", &tipoGioco);
  72.         fflush(stdin);
  73.   }while(tipoGioco<1||tipoGioco>3);
  74.  
  75.   if(tipoGioco!=CvsC){
  76.         printf("Inserisci il nome del giocatore:\n   ");
  77.     scanf("%s", n1);
  78.     fflush(stdin);
  79.     if(tipoGioco==UvsU){
  80.         printf("Inserisci il nome del secondo giocatore:\n   ");
  81.       scanf("%15s", n2);
  82.       fflush(stdin);
  83.     }else
  84.         strcpy(n2, "CPU1");
  85.   }else{
  86.           strcpy(n1, "CPU1");
  87.     strcpy(n2, "CPU2");
  88.   }
  89.  
  90.   do{
  91.     if(tipoGioco==UvsU)
  92.       tg1=tg2=User;
  93.     else if(tipoGioco==UvsC){
  94.         tg1=User; tg2=CPU;
  95.     }else
  96.       tg1=tg2=CPU;
  97.    
  98.                 gioca(n1, n2, tg1, tg2);
  99.     printf("\n\nVuoi fare una nuova partita? (s/n)");
  100.     scanf("%c", &r);
  101.     fflush(stdin);
  102.   }while(r=='s' || r=='S');
  103.   return 0;
  104. }
  105.  
  106.  
  107. //###############################
  108. void gioca(char n1[CN], char n2[CN], int tg1, int tg2){
  109.   int m[R][C], t=1, f, nt=0, r, c, g=g2I;
  110.  
  111.   f=FGioca;
  112.   azzera(m);
  113.  
  114.   do{
  115.     CLS;
  116.     stampaTitolo();
  117.     g=giocatoreP(g);
  118. printf("g=%d   tg=%d\n",g, g==g1I?tg1:tg2);
  119.     printf("Mossa numero: %d\n",++nt);
  120.     if(t)
  121.       printf("E' il turno di %s (%c)\n\n", n1,g1);
  122.     else
  123.       printf("E' il turno di %s (%c)\n\n", n2,g2);
  124.     stampa(m);
  125.    
  126.     //Se gioca l'utente
  127.     if( (g==1 && tg1==User) || (g==2 && tg2==User)){
  128.       while(1){
  129.         printf("In che colonna vuoi mettere il gettone?  ");
  130.         scanf("%d", &c);
  131.                           fflush(stdin);
  132.                           c--;
  133.         if(c<0 || c>=C)
  134.           continue;
  135.         r=inserisci(m,c);
  136.         if(r!=-1)
  137.           break;
  138.       }
  139.     }else{ // Se gioca il computer
  140.             c=mossaPC(m, g, giocatoreP(g));
  141.             r=inserisci(m,c); //mossaPc ritorna una colonna valida e con spazio
  142.             m[r][c]=g;
  143.       printf("\nc = %d \n", c+1);
  144.       //getch();
  145.     }
  146.    
  147.     m[r][c]=g;
  148.     f=controllaF(m,g,r,c,1) ? g : f;
  149.     if(nt==R*C && f==0){
  150.       f=FPareggio;
  151.       break;
  152.     }
  153.   }while(!f);
  154.  
  155.   CLS;
  156.   stampaTitolo();
  157.   stampa(m);
  158.   switch(f){
  159.     case 1:
  160.       printf("\n\nHa vinto %s (%c)", n1, g1);
  161.       break;
  162.     case 2:
  163.       printf("\n\nHa vinto %s (%c)", n2, g2);
  164.       break;
  165.     case 3:
  166.       printf("\n\nPareggio");
  167.       break;
  168.   }
  169. }
  170.  
  171. //###############################
  172. int mossaPC(int m[R][C], int gp, int ga){
  173.         int r,c,m2[R][C],cas,g,i;
  174.        
  175.         //Riempio la matrice di supporto
  176.         for(r=0; r<R ;r++)
  177.           for(c=0; c<C; c++)
  178.             m2[r][c]=m[r][c];
  179.        
  180.         printf("mossaPC ( m, %d, %d )",gp,ga);
  181.        
  182.         // 1° ciclo Controlla se può vincere
  183.         // 2° ciclo controlla se l'avversario può vincere
  184.         for(i=0; i<2; i++){
  185.                 g=(i? ga : gp);
  186.           for(c=0;c<C;c++){
  187.                 r=inserisci(m2,c);
  188.                 m2[r][c]=g;
  189.                 printf("\n  c=%d  r=%d controllaF( m, %d, %d, %d, 0)=%d", c,r,g,r,c,controllaF(m2, g, r, c, 0));
  190.             if(r!=-1 && controllaF(m2, g, r, c, 0))
  191.               return c;
  192.       m2[r][c]=vuotoI;
  193.     }
  194.   }
  195.  
  196.   while(1)   //Controlla se nella colonna casuale c'è spazio
  197.     if(inserisci(m2,cas=rand()%C)!=-1)
  198.       return cas;
  199. }
  200.  
  201. //###############################
  202. int giocatoreP(int g){
  203.         return g==g1I ? g2I : g1I;
  204. }      
  205.  
  206.  
  207. //###############################
  208. int inserisci(int m[R][C], int c){
  209.   int i;
  210.   for(i=R-1; i>=0; i--)
  211.     if(m[i][c]==vuotoI)
  212.       return i;
  213.   return -1;
  214. }
  215.  
  216.  
  217. //###############################
  218. int controllaF(int m[R][C], const int g, const int r, const int c, const int e){
  219.         int r2, c2, x, ret=0, i, ok;
  220.        
  221.         //Controllo diagonale \ ___
  222.         if(esiste(r-1,c-1) && m[r-1][c-1]==g)
  223.           if(x=controllaF(m,g,r-1,c-1,e)!=0)
  224.             ret=ret||x;
  225.   if(r<R-(NGV-1) && c<C-(NGV-1)){
  226.         ok=1;
  227.     for(i=0; i<NGV && (ok*=(m[r][c]==m[r+i][c+i] || m[r+i][c+i]==vI)); i++) ;
  228.     if(ok){
  229.         if(e)
  230.         for(i=0; esiste(r+i, c+i) && m[r+i][c+i]==g; i++)
  231.           m[r+i][c+i]=vI;
  232.       ret=1;
  233.     }
  234.   }
  235.  
  236.   //Controllo diagonale /  ___
  237.         if(esiste(r+1,c-1) && m[r+1][c-1]==g)
  238.           if(x=controllaF(m,g,r+1,c-1,e)!=0)
  239.             ret=ret||x;
  240.   if(r>(NGV-2) && c<C-(NGV-2)){
  241.         ok=1;
  242.     for(i=0; i<NGV && (ok*=(m[r][c]==m[r-i][c+i]) || m[r-i][c+i]==vI); i++) ;
  243.     if(ok){
  244.         if(e)
  245.         for(i=0; esiste(r-i, c+i) && m[r-i][c+i]==g; i++)
  246.           m[r-i][c+i]=vI;
  247.       ret=1;
  248.     }
  249.   }
  250.  
  251.         //Controllo riga
  252.         if(esiste(r,c-1) && m[r][c-1]==g)
  253.           if(x=controllaF(m,g,r,c-1,e)!=0)
  254.             ret=ret||x;
  255.   if(c<C-(NGV-1)){
  256.         ok=1;
  257.     for(i=0; i<NGV && (ok*=(m[r][c]==m[r][c+i] || m[r][c+i]==vI)); i++) ;
  258.     if(ok){
  259.         if(e)
  260.         for(i=0; esiste(r, c+i) && m[r][c+i]==g; i++)
  261.           m[r][c+i]=vI;
  262.       ret=1;
  263.     }
  264.   }
  265.        
  266.         //Controllo colonna
  267.         if(r<R-(NGV-1)){
  268.           ok=1;
  269.                 for(i=0; i<NGV && (ok*=(m[r][c]==m[r+i][c] || m[r+i][c]==vI)); i++) ;
  270.                 if(ok){
  271.         if(e)
  272.                           for(i=0; i<NGV; i++) //Non serve controllare se sono più di 4
  273.           m[r+i][c]=vI;
  274.       ret=1;
  275.                 }
  276.         }
  277.        
  278.   return ret;
  279. }
  280.  
  281.  
  282. //###############################
  283. int esiste(int r, int c){
  284.         if(r>=0&&r<R && c>=0&&c<C)
  285.           return 1;
  286.         return 0;      
  287. }
  288.  
  289.  
  290. //###############################
  291. void azzera(int m[R][C]){
  292.   int i,j;
  293.   for(i=0; i<R; i++)
  294.     for(j=0; j<C; j++)
  295.       m[i][j]=0;
  296. }
  297.  
  298.  
  299. //###############################
  300. void stampa(int m[R][C]){
  301.   int i,j;
  302.   printf("\n");
  303.   stampaRigaPiena();  //Stampo prima riga |---|---|--...
  304.  
  305.   for(i=0; i<R; i++){ //Stampo le righe centrali
  306.     printf("   |");
  307.     for(j=0; j<C; j++)
  308.       printf(" %c |",stampaCasella(m[i][j]));
  309.     printf("\n");
  310.     stampaRigaPiena();
  311.   }
  312.   stampaRigaPiena();  //Stampo prima riga |---|---|--...
  313.   printf("   |");
  314.   for(j=1; j<=C; j++)
  315.     printf(" %d |", j);
  316.   printf("\n");
  317.   stampaRigaPiena();  //Stampo prima riga |---|---|--...
  318.   printf("\n");
  319. }
  320. void stampaRigaPiena(){
  321.   int i,j;
  322.   printf("   |");
  323.   for(j=1; j<=C; j++)
  324.     printf("---|");
  325.   printf("\n");
  326. }
  327. char stampaCasella(int x){
  328.         char c;
  329.         switch(x){
  330.                 case 0:
  331.             c=vuoto; break;
  332.     case 1:
  333.         c=g1; break;
  334.         case 2:
  335.         c=g2; break;
  336.         case 3:
  337.                 c=CVitt; break;
  338.         }
  339.         return c;
  340. }
  341. void stampaTitolo(void){
  342.   printf("\n\n\t ### Forza quattro ###\n\n");
  343. }