Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - programmi per grafica
Forum - C/C++ - programmi per grafica

Pagine: [ 1 2 ] Precedente | Prossimo
Avatar
fedezane23 (Normal User)
Newbie


Messaggi: 6
Iscritto: 13/02/2013

Segnala al moderatore
Postato alle 9:59
Mercoledì, 13/02/2013
Ciao a tutti,
ho finito da poco un programma in C e ora vorrei migliorarne la grafica.
Ho provato ad utilizzare borland ma con scarso risultato perchè persiste l'errore "graphics .h error bgi graphics not supported under windows" nonostante le migliaia di pagine che ho visitato per trovare una soluzione.
Mi chiedevo se qualcuno di voi mi può aiutare o consigliare un altro programma.

Grazie in anticipo.

PM Quote
Avatar
Poggi Marco (Member)
Guru


Messaggi: 951
Iscritto: 05/01/2010

Segnala al moderatore
Postato alle 10:31
Mercoledì, 13/02/2013
Ciao!

Presumo che hai fatto delle prove sul vecchio Borland c++ version 3.1
In questo caso la risoluzione non è semplice, devi considerare questi punti:

- Devi accertarti di avere le librerie grafiche richieste
- Devi accertarti che Windows sia compatibile con il vecchio DOS
- Eventualmente installare una macchina virtuale

In alternativa, scarica un compilatore e idee moderno; ecco due esempi:
Visual C++ Redistributable per Visual Studio 2012 http://www.microsoft.com/it-it/download/details.aspx?id=30679
Code::Blocks 12.11 http://www.codeblocks.org/


Nulla va più veloce della luce, quindi rilassati.
PM Quote
Avatar
fedezane23 (Normal User)
Newbie


Messaggi: 6
Iscritto: 13/02/2013

Segnala al moderatore
Postato alle 12:41
Mercoledì, 13/02/2013
L'idea della macchina virtuale mi piace e proverò anche Visual Studio.
Grazie mille!
Speriamo funzioni tutto...

PM Quote
Avatar
fedezane23 (Normal User)
Newbie


Messaggi: 6
Iscritto: 13/02/2013

Segnala al moderatore
Postato alle 17:12
Mercoledì, 13/02/2013
Niente di niente...

Di seguito lascio il codice nel caso qualche buona anima gli dia un'occhiata...



#include <stdio.h>
#include <graphics.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <time.h>
#include <ctype.h>

/* dichiarazione funzioni */
char *controlloA(int i2, int j2, int vib2[99], int vjb2[99], int numbombe2);
char *riempimento(int i1, int j1, int vib1[99], int vjb1[99], int numbombe1);
void griglia(int agr, int bgr);
int giocata (int ag, int bg, int ig, int jg, int numbombeg, int vibg[99], int vjbg[99], char *scacchierag[25][40], char *scacchieragcopia[25][40],char *scacchierabcrg[25][40], int gocrg, int giogog);
void cursore(int acr, int bcr, int vibcr[99], int vjbcr[99], int numbombecr, char *scacchieracr[25][40], char *scacchieracrcopia[25][40], char *scacchierabcr[25][40], int gocr);
void espansione(int ige, int jge, char *scacchierae[25][40], char *scacchieraecopia[25][40]);


/* inizio main */
int main(void)
{
    int a=0, b=0;                                                                                          /* variabili per la visualizzazione della scacchiera */
    int numbombe=0;                                                                                     /* variabile assagnata al numero di bombe scelto dall'utente */
    int cb=0;                                                                                             /* contatore delle bombe */
    int i, j;                                                                                             /* indici riga e colonna della scacchiera */
    char *scacchiera[25][40];                                                                         /* vettore che definisce la scacchiera che è quella con i valori su tutte le caselle */
    char *scacchieracopia[25][40];                                                            /* copia della matrice scacchiera che memorizza tutte le giocate */
    char *scacchierab[25][40];                                                                     /* scacchiera dove saranno memorizzate tutte le bandierine */
    int vib[99] = {0};                                                                                 /* vettore per la coordinata x delle bombe */
    int vjb[99] = {0};                                                                                 /* vettore per la coordinata y delle bombe */
    int frequency[99][99]={{0},{0}};                                                             /* vettore per la frequenza delle coordinate delle bombe */
    int tasto, tas;                                                                                     /* variabili per la corrispondente numerica dei tasti */
    int xcr, ycr;                                                                             /* variabili per lo spostamento del cursore */
    int y, x;                                                                                 /* variabili per i pixel */
    int gdriver = DETECT, gmode, errorcode;                                                   /* variabili per la grafica */
    int poly[8];                                                                              /* vettore di otto posti per memorizzare le coordinate dei vertici di un poligono */
    int go=0;                                                                                 /* variabile gameover, che servirà per continuare o terminare le giocate */

    /* varibili per il controllo sulla larghezza */
    char numero1[10];                                                                          /* vettore dove memorizzare il valore inserito dall'utente */
    int numerogiusto1[2];                                                                     /* vettore dove memorizzare solo i valori numerici */
    int o1;                                                                                   /* variabile per scorrere il vettore "numero1" */
    int l1=0;                                                                                 /* variabile per scorrere il vettore "numerogiusto1" */
    int hold1;                                                                                /* locazione temporanea di memoria */
    /* varibili per il controllo sulla lunghezza */
    char numero2[10];
    int numerogiusto2[2];
    int o2;
    int l2=0;
    int hold2;
    /* varibili per il controllo sul numero di bombe */
    char numero3[10];
    int numerogiusto3[2];
    int o3;
    int l3=0;
    int hold3;

    /*inizio programma */

    initgraph (&gdriver, &gmode, " ");                                                         /* carica i driver grafici dal disco e inizializza la grafica */

    errorcode = graphresult();                                                                 /* assegna il codice di errore apertura grafica */

    if (errorcode !=grOk ){                                                                    /* se il codice è diverso da ok ... */
        printf("graphics error:%s\n",grapherrormsg(errorcode));                          /* visualizza messaggio di errore */
        printf("Press any key to halt");                                                        /* visualizza il messaggio di premere un tasto */
        getch();                                                                                /* attende che un tasto sia premuto */
        exit(1);                                                                                /* chiude la grafica */
    }                                                                                   /* chiusura de ciclo if */

    y=0;                                                                                          /* coordinate per settare le coordinate di inizio della funzione "do" */

    /* funzione do-while finchè non si preme INVIO */
    do{                                                                                       /* inizio di un ciclo condizionale do-while */
        setbkcolor(0);                                                                                  /* colora di azzurro lo sfondo */
        settextjustify(CENTER_TEXT,TOP_TEXT);                                                  /* giustifica il testo al centro e dall'alto */
        settextstyle(1,0,7);                                                                   /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
          setcolor(14);                                                                          /* seleziona il colore giallo */
        outtextxy(330,130,"CAMPO MINATO");                                                     /* coordinate di inserimento e testo relativo */
        settextjustify(CENTER_TEXT,TOP_TEXT);                                                  /* giustifica il testo al centro e dall'alto */
        settextstyle(1,0,1);                                                                   /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
        setcolor(3);                                                                           /* seleziona il colore ciano per le scritte successive */
        outtextxy(330,230,"Realized by - BATTISTELLA Isacco - GARDONIO Luca - GOBBO Giulio");    /* visualizza il testo indicato tra "" alle coordibate specificate */
        setcolor(15);                                                                          /* seleziona il colore bianco */
        settextstyle(0,0,1);                                                                   /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
        outtextxy(550, 440, "Premere INVIO");                                                  /* coordinate di inserimento e testo relativo */
        tas=getch();                                                                           /* rimane in attesa che venga premuto un tasto */
    }while(tas!=13);                                                                          /* condizione di continuità del ciclo do-while, finchè non si preme invio */

    /* fase di sovrascrittura delle istruzioni in nero */
    settextjustify(CENTER_TEXT,TOP_TEXT);                                                      /* giustifica il testo al centro e dall'alto */
    settextstyle(1,0,7);                                                                       /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
    setcolor(0);                                                                               /* seleziona il colore nero */
    outtextxy(330,130,"CAMPO MINATO");                                                          /* coordinate di inserimento e testo relativo */
    settextjustify(CENTER_TEXT,TOP_TEXT);                                                     /* giustifica il testo al centro e dall'alto */
    settextstyle(1,0,1);                                                                      /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
    setcolor(0);                                                                              /* seleziona il colore nero per sovrascrivere e coprire poi le scritte precedenti */
    outtextxy(330,230,"Realized by - BATTISTELLA Isacco - GARDONIO Luca - GOBBO Giulio"); /* coordinate di inserimento e testo relativo */
    setcolor(0);                                                                              /*seleziona il colore nero per sovrascrivere e coprire poi le scritte precedenti */
    settextstyle(0,0,1);                                                                      /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
    outtextxy(550, 440, "Premere INVIO");                                                     /* coordinate di inserimento e testo relativo */

schermatainiziale:                                                                                    /* etichetta per la funzione goto */
    do{                                                                                       /* inizio di un ciclo condizionale do-while */
        settextjustify(LEFT_TEXT,CENTER_TEXT);                                                 /* giustifica il testo a sinistra e al centro */
        setcolor(5);                                                                              /* seleziona il colore magenta */
        settextstyle(1,0,4.5);                                                                 /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
        outtextxy(120, 100, "MENU'");                                                          /* coordinate di inserimento e testo relativo */
        settextstyle(1,0,3);                                                                   /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
        
        /* scelta della modalità di gioco */
              /* se..seleziona colore verde..altrimenti bianco..posizione testo..messaggio da visualizzare */
        if(y == 0) setcolor(2); else setcolor(15); outtextxy(130,150,"- Inserire larghezza della scacchiera");
        if(y == 1) setcolor(2); else setcolor(15); outtextxy(130,190,"- Inserire lunghezza della scacchiera");
        if(y == 2) setcolor(2); else setcolor(15); outtextxy(130,230,"- Inserire numero di bombe");
        if(y == 3) setcolor(2); else setcolor(15); outtextxy(130,270,"- Play");
        if(y == 4) setcolor(2); else setcolor(15); outtextxy(130,330,"- Uscita");

        tasto = getch();                                                                       /* alla variabile "tasto" viene assegnato il valore del tasto che sarà premuto */
        switch(tasto)                                                                          /* operatore condizionale che analizza e regola l'utilizzo dei tasti direzionali */
           {
               case 80: y++; if(y > 4) y = 0; break;                                                 /* nel caso sia premuta la freccia in giù incrementa l'indice y */
                                                                                               /* se y è >4 azzera la variabile */
                 case 72: y--; if(y < 0) y = 4; break;                                                 /* nel caso sia premuta la freccia in sù decrementa l'indice y */
                                                                                               /* se y<0 setta la variabile a 4 */
           }                                                                                        /* chiusura dell'operatore condizionale switch */
       }while(tasto != 13);                                                                         /* esegue il ciclo do finchè non viene premuto invio */

       clrscr();                                                                                               /* pulisce lo schermo cancellando la schermata con tutte le scritte */

       /* cicli if per la visualizzazione dei dati inseriti in schermata DOS */
       if(y==0){                                                                                     /* se è stato premuto invio nella prima scelta.. */
              cleardevice();                                                             /* pulisce la schermata dalle scritte eseguite in precedenza */
           setbkcolor(0);                                                             /* setta il colore di sfondo a nero */
              printf("\n\n\n");                                                                        /* manda a capo tre volte */
           printf("Larghezza preimpostata = %d\n\n\n\n\n\n",b);                                 /* manda a capo tre volte */

    ticket1:                                                                         /* etichetta per la funzione "goto" */
              printf("- Inserire larghezza della scacchiera(max 30 colonne):\n\n\n\n "); /* visualizza il testo indicato */
              scanf("%s", numero1);                                                      /* assegna il valore inserito al vettore numero1 */

              /* ciclo for per scorrere il vettore numero1 e funzione if per il controllo dei valori inseriti */
           for (o1=0; o1<2; o1++){
               if ((numero1[o1]-48>=0)&&(numero1[o1]-48<=9)){                                    /* se il valore inserito è una cifra ... */
                      numerogiusto1[l1]=numero1[o1];                                       /* ... viene assegnato al valore numerogiusto */
                     l1++;                                                                /* incrementa la variabile l1 per le posizioni del vettore numerogiusto */
                  }                                                                       /* chiusura if */
           }                                                                          /* chiusura for */
    
        /* funzione if per l'esecuzione del calcolo della variabile b solo se sono state inserite cifre */
           if (l1!=0){
                  if(l1==1){                                                              /* se è stato contato un solo numero ... */
                     numerogiusto1[1]=0;                                                  /* assegna il valore 0 alla posizione 1 di numerogiusto che non contiene nessun valore */
                     hold1 = numerogiusto1[0];                                            /* la posizione 0 di numero giusto viene spostata nella locazione temporanea di memoria */
                    numerogiusto1[0] = numerogiusto1[1];                                 /* inversione delle due caselle di memoria */
                    numerogiusto1[1] = hold1;                                            /* quella che prima era la posizione 0 ora è la 1 */
                     b=(numerogiusto1[0]+numerogiusto1[1]-48);                            /* assegnamento del valore alla variabile b */
                        l1=0;                                                                /* riporta il valore di l1 a 0 */
                 }                                                                       /* chiusura if */
                 else{                                                                   /* altrimenti ... */
                      b=(((numerogiusto1[0]-48)*10)+(numerogiusto1[1])-48);                /* assegna il valore a b se sono stati inseriti valori con più di una cifra */
                        l1=0;                                                                /* riporta il valore di l1 a 0 */
                 }                                                                       /* chiusura else */
            }                                                                          /* chiusura primo if */
              else{                                                                      /* se non sono stati inseriti numeri ... */
                  goto ticket1;                                                           /* funzione goto che rimanda all'etichetta ticket1 */
              }                                                                          /* chiusura else */

        /* funzione if nel caso di inserimento errato di valori, 00, oppure di valori maggiori di quelli consentiti */
              if((b>30)||(b<=0)){
                  b=0;                                                                    /* azzera b */
                l1=0;                                                                   /* azzera l1 */
                  goto ticket1;                                                           /* rimanda a ticket1 */
              }                                                                          /* chiusura if */

        /* funzione if in caso di inserimento corretto dei valori */
        if((b!=0)&&(b<=30)){
                  y++;                                                                    /* incrementa y in modo tale che all'uscita venga evidenziata la voce sottostante */
            cleardevice();                                                                       /* pulitura dello schermo */
                  goto schermatainiziale;                                                              /* ritorna al menu principale */
           }                                                                          /* chiusura if */
       }                                                                             /* chiusura if (y==0) */

    /* funzioni if per le rimanenti 2 scelte di lunghezza e numero di bombe, istruzioni uguali alla precedente */
    if(y==1){                                                                                      /* se è stato premuto invio nella seconda scelta.. */
        cleardevice();
        setbkcolor(0);
        printf("\n\n\n");
        printf("Lunghezza preimpostata = %d\n\n\n\n\n\n",a);

ticket2:
           printf("- Inserire lunghezza della scacchiera(max 20 righe):\n\n\n\n ");
           scanf("%s", numero2);
    
        for (o2=0; o2<2; o2++){
               if ((numero2[o2]-48>=0)&&(numero2[o2]-48<=9)){
                      numerogiusto2[l2]=numero2[o2];
                     l2++;
                  }
           }
    
           if (l2!=0){
                  if(l2==1){
                     numerogiusto2[1]=0;
                     hold2 = numerogiusto2[0];
                    numerogiusto2[0] = numerogiusto2[1];
                    numerogiusto2[1] = hold2;
                     a=(numerogiusto2[0]+numerogiusto2[1])-48;
                l2=0;
                }
                else{
                      a=(((numerogiusto2[0]-48)*10)+(numerogiusto2[1]-48));
                    l2=0;
                }
            }
            else{
                  goto ticket2;
              }
    
        if((a>20)||(a<=0)){
                  a=0;
                  l2=0;
                  goto ticket2;
              }

              if((a!=0)&&(a<=20)){
                  y++;
            cleardevice();
                  goto schermatainiziale;
           }
    }                                                                             /* chiusura if (y==1) */


    if(y==2){                                                                                    /*se è stato premuto invio nella terza scelta..*/
              cleardevice();
              setbkcolor(0);
              printf("\n\n\n");
           printf("Numero di bombe preimpostato = %d\n\n\n\n\n\n",numbombe);

ticket3:
           printf("- Inserire numero di bombe (max 99 bombe):\n\n\n\n ");
           scanf("%s", numero3);

        for (o3=0; o3<2; o3++){
               if ((numero3[o3]-48>=0)&&(numero3[o3]-48<=9)){
                      numerogiusto3[l3]=numero3[o3];
                    l3++;
                  }
           }

           if (l3!=0){
                  if(l3==1){
                     numerogiusto3[1]=0;
                     hold3 = numerogiusto3[0];
                    numerogiusto3[0] = numerogiusto3[1];
                    numerogiusto3[1] = hold3;
                     numbombe=(numerogiusto3[0]+numerogiusto3[1])-48;
                    l3=0;
                }
                else{
                      numbombe=(((numerogiusto3[0]-48)*10)+(numerogiusto3[1]-48));
                    l3=0;
                 }
            }
              else{
                  goto ticket3;
              }

              if((numbombe>99)||(numbombe<=0)){
                  numbombe=0;
                l3=0;
                  goto ticket3;
              }

              if((numbombe!=0)&&(numbombe<=99)){
                  y++;
            cleardevice();
                  goto schermatainiziale;
           }
       }                                                                             /* chiusura if (y==2) */

    /* funzione if per la 4 scelta */
       if(y==3){                                                                                     /* se è stato premuto invio sulla quarta scelta ... */
           if((a!=0)&&(b!=0)){                                                                       /* funzione if se sono già state inserite la lunghezza e la larghezza della scacchiera */
                cleardevice();                                                                        /* pulitura dello schermo */
               goto newp;                                                                            /* demanda all'etichetta newp */
              }                                                                                                    /* end if */
              else{                                                                                        /* altrimenti ... */
                  goto schermatainiziale;                                                                   /* ritorna al menu principale */
              }                                                                                                    /* chiusura else */
       }                                                                                                        /* chiusura if */

  
    /* funzione if per la 5 scelta */
       if(y==4){                                                                                      /* se è stato premuto invio su uscita ... */
           goto uscita;                                                                             /* demanda all'etichetta uscita */
      }                                                                             /* chiusura if */

newp:                                                                                           /* etichetta per la funzione goto */

    cb=0;                                                                                       /*    setta il contatore bombe a zero */
    srand(time(NULL));                                                                                 /* seme per la generazione dei numeri casuali */

    while (cb<numbombe){                                                                         /*    finchè non si raggiunge il numero di bombe inserito dall'utente */
        vib[cb] = (rand() % (a));                                                   /* genera e memorizza la coordinata riga nel vettore vib */
        vjb[cb] = (rand() % (b));                                                                 /* genera e memorizza la coordinata colonna nel vettore vjb */
        ++frequency[vib[cb]][vjb[cb]];                                                            /* incrementa la frequenza del vettore bidimensinale frequency */

              /* funzione if per gestire la frequenza di uscita delle coppie di coordinate delle bombe */
              if(frequency[vib[cb]][vjb[cb]]==1){                                                     /* se la frequenza è 1 ... */
                  cb++;                                                                                  /* ... allora incrementa il contatore bomba */
              }                                                                                        /* ... altrimenti significa che quella coppia di coordinate era già stata generata e viene sostituita con una nuova */
       }                                                                             /* chiusura while */

       /* cicli for per la compilazione della matrice scacchiera */
       for (i=0; i<a; i++){                                                               /* ciclo for per scorrere le righe */
        for (j=0; j<b; j++){                                                            /* ciclo for per scorrere le colonne */
                  scacchiera[j] = riempimento(i, j, vib, vjb, numbombe);                    /* per ogni cella richiama la funzione riempimento */
        }                                                                          /* chiusura secondo for */
    }                                                                             /* chiusura primo for */

       /* cicli for per la compilazione della matrice scacchieracopia */
       for (i=0; i<a; i++){                                                                  /*    ciclo for per scorrere le righe */
          for (j=0; j<b; j++){                                                               /* ciclo for per scorrere le colonne */
                 scacchieracopia[j]="[/]";                                                 /* riempie ogni cella con quella stringa */
           }                                                                          /* chiusura secondo for */
       }                                                                             /* chiusura primo for */

       /* cicli for per la compilazione della matrice scacchierab */
       for (i=0; i<a; i++){                                                                  /* ciclo for per scorrere le righe */
          for (j=0; j<b; j++){                                                               /* ciclo for per scorrere le colonne */
                 scacchierab[j]="[/]";                                                        /* riempie ogni cella con quella stringa */
           }                                                                          /* chiusura secondo for */
       }                                                                             /* chiusura primo for */

       /* ciclo per la visualizzazione dei riquadri con numero di bandierine e di caselle scoperte */
       /* visualizzazione primo riquadro con le bandierine inserite */
       setcolor(9);                                                                  /* setta il colore a blu chiaro */
       settextstyle(0,0,1);                                                          /* settaggi per il testo */
       outtextxy(20, 90, "Bandierine");                                              /* visualizza la scritta indicata tra virgolette */
       poly[0]=40;                                                                                    /* coordinate primo vertice del poligono */
    poly[1]=100;

       poly[2]=85;                                                                                     /* coordinate secondo vertice del poligono */
    poly[3]=100;

    poly[4]=85;                                                                                     /* coordinate terzo vertice del poligono */
    poly[5]=115;

    poly[6]=40;                                                                                    /* coordinate quarto vertice del poligono */
    poly[7]=115;

       setfillstyle(1, 15);                                                                        /* seleziona lo stile di riempimento, pieno 2 di colore bianco */
       fillpoly(4, poly);                                                            /* riempie il poligono di 4 vertici con le coordinate del vettore poly */

       /* visualizzazione secondo riquadro con le caselle scoperte, istruzioni uguali alle precedenti */
       setcolor(9);
       settextstyle(0,0,1);
       outtextxy(20, 190, "Scoperte");

       poly[0]=40;
    poly[1]=200;

       poly[2]=85;
    poly[3]=200;

    poly[4]=85;
    poly[5]=215;

    poly[6]=40;
    poly[7]=215;

       setfillstyle(1, 15);
       fillpoly(4, poly);

       /*ciclo per la visualizzazione della scacchiera*/
    poly[0]=120;                                                                                /* coordinate primo vertice del poligono */
    poly[1]=80;

       poly[2]=(b*15)+120;                                                                         /* coordinate secondo vertice del poligono */
    poly[3]=80;

    poly[4]=(b*15)+120;                                                                         /* coordinate terzo vertice del poligono */
    poly[5]=(a*15)+80;

    poly[6]=120;                                                                                /* coordinate quarto vertice del poligono */
    poly[7]=(a*15)+80;

       setfillstyle(1, 2);                                                                         /* seleziona lo stile di riempimento, pieno 2 di colore verde */
       fillpoly(4, poly);                                                                          /* riempie il poligono di 4 vertici con le coordinate del vettore poly */


       setcolor(13);                                                                                /* seleziona il colore magenta chiaro */
       settextstyle(1,0,2);                                                                         /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
       outtextxy(90,430,"Premere 'N' per nuova partita o per uscire");                    /* coordinate di posizione e relativo testo indicato */
       setcolor(15);                                                                                 /* seleziona il colore bianco */
       settextstyle(0,0,1);                                                                       /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
       outtextxy(10,25,"'B' per bandierina");                                                         /* visualizza alle coordinate indicate il messaggio digitato */
       outtextxy(210,25,"'SPAZIO' per scoprire");                                                 /* visualizza alle coordinate indicate il messaggio digitato */
       outtextxy(430,25,"'CANC' per cancellare");                                                 /* visualizza alle coordinate indicate il messaggio digitato */


       griglia (a, b);                                                                                     /* richiama la funzione griglia per la composizione delle caselle */

       cursore(a, b, vib, vjb, numbombe, scacchiera, scacchieracopia, scacchierab, go);    /* richiama la funzione cursore */

       cleardevice();                                                                             /* pulitura dello schermo */
       goto schermatainiziale;                                                                    /* demanda all'etichetta schermatainiziale */

uscita:                                                                                       /* etichetta per la funzione goto */

       closegraph();                                                                                     /* chiude la grafica */
       exit(0);                                                                                                /* funzione per la pulizia totale dello schermo */
    return 0;                                                                                  /* indica le fine del programma con esito positivo */
}                                                                                             /* chiusura del main */


/* funzione griglia per la visualizzazione della griglia */
void griglia(int agr, int bgr)
{
    int xgr, ygr;                                                                               /* dichiarazione delle variabili coordinate dei pixel da accendere */

    setcolor(1);                                                                                          /* seleziona il colore blu di tracciatura delle righe ad ogni ciclo */

       /* cicli for per la creazione della griglia */
    for(ygr=80; ygr<=(agr*15)+80; ygr+=15){                                                    /* linee orizzontali */
        setlinestyle(0,0,THICK_WIDTH);                                                             /* indica il tipo di linea */
        line(120,ygr,(bgr*15)+120,ygr);                                                             /* indica l'inizio e la fine di ogni linea 2 coordinate per l'inizio e 2 per la fine */
    }                                                                                                        /* chiusura ciclo for */

    for(xgr=120; xgr<=(bgr*15)+120; xgr+=15){                                                    /* linee verticali */
        setlinestyle(0,0,THICK_WIDTH);                                                            /* indica il tipo di linea */
        line(xgr,80,xgr,(agr*15)+80);                                                              /* indica l'inizio e la fine di ogni linea 2 coordinate per l'inizio e due per la fine */
       }                                                                                                        /* chiusura ciclo for */
}                                                                                                            /* fine della funzione griglia */


/* funzione cursore per la visualizzazione dello stesso e per la gestione dei tasti per il gioco */
void cursore(int acr, int bcr, int vibcr[99], int vjbcr[99], int numbombecr, char *scacchieracr[25][40], char *scacchieracrcopia[25][40], char *scacchierabcr[25][40], int gocr)
{
       int tasto;                                                                                  /* variabile tasto per identificare il tasto premuto dal giocatore */
       int igr=0;                                                                                  /* variabile che identifica l'indice riga */
       int jgr=0;                                                                                   /* variabile che identifica l'indice colonna */
       int xcr=124;                                                                                /* variabile inizializzata che serve per collocare il cursore all'inizio partita */
       int ycr=88;                                                                                 /* variabile inizializzata che serve per collocare il cursore all'inizio partita */
       int key, kcr, txcr, tycr;                                                                   /* variabili varie per tasti e posizioni */
       int polycr[8];                                                                              /* vettore per memorizzare le coordinate dei vertici dei poligoni da disegnare */
      int igcr1=0;                                                                                /* variabili che identifica l'indice riga */
      int jgcr1=0;                                                                                /* variabili che identifica l'indice colonna */
       int giococr=0;                                                                              /* variabile che consente di giocare fino a che non sono state scoperte tutte le caselle o trovata una bomba */
       int m, n;                                                                     /* variabili varie */
       int polyb1[8];                                                                /* vettore poly per il tracciamento dei poligoni */
       int parteintera1b, parteintera2b, restob;                                     /* variabili per la visualizzazione delle bandierine o delle caselle scoperte */
       int flag=0;                                                                   /* variabile bandiera */

    while(gocr==0){                                                                               /* ciclo per dettare le condizioni di continuazione della schermata grafica */

        flag=0;                                                                     /* permette di porre flag=0 ad ogni ciclo */

           settextstyle(0,0,1);                                                                     /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
        setcolor(15);                                                                                  /* per selezionare il colore bianco del cursore */

           outtextxy(xcr, ycr, "_");                                                                /* colloca il cursore alle coordinate indicate, all' ingresso del ciclo while */

           tasto=getch();                                                                           /* assegna a tasto il valore del tasto premuto */

              /* funzione switch per regolare le mosse del giocatore */
           switch(tasto)                                                                            /* esamina il tasto premuto e demanda alla rispettiva istruzione */
           {

               case 80:                                                                               /* caso in cui sia stata premuta la freccia in giù ... */
                       if(strcmp(scacchieracrcopia[igr][jgr],"[/]")!=0)                             /* se la cella della scacchieracopia è aperta ... */
                           setcolor(7);                                                              /* seleziona il colore grigio chiaro */
                       else{                                                                        /* altrimenti ... */
                         setcolor(2);                                                              /* seleziona il colore verde */
                       }                                                                            /* chiusura dell'else */
                       outtextxy(xcr,ycr,"_");                                                      /* sovrascrive e quindi cancella il cursore */
                       ycr += 15;                                                                       /* incrementa l'indice delle ordinate dei pixel di 15 unità */
                       if(ycr > (acr*15)+73)                                                            /* se l'indice ordinata dei pixel è > di ... */
                           ycr = 88;                                                                 /* lo riporta al valore iniziale corrispondente alla prima riga */
                       igr++;                                                                       /* incrementa l'indice riga */
                       if(igr > acr-1)                                                              /* se l'indice riga è superiore alla dimensione massima ... */
                       igr = 0;                                                                  /* riazzera l'indice riga */
                 break;                                                                          /* fine del primo caso */

               case 72:                                                                        /* caso in cui sia stata premuta la freccia in sù ... */
                     if(strcmp(scacchieracrcopia[igr][jgr],"[/]")!=0)                             /* se la cella della scacchieracopia è aperta ... */
                           setcolor(7);                                                              /* seleziona il colore grigio chiaro */
                       else{                                                                        /* altrimenti ... */
                         setcolor(2);                                                              /* seleziona il colore verde */
                       }                                                                            /* chiusura dell'else */
                     outtextxy(xcr,ycr,"_");                                                      /* sovrascrive e quindi cancella il cursore */
                     ycr -= 15;                                                                   /* decrementa l'indice delle ordinate dei pixel di 15 unità */
                     if(ycr < 88)                                                                     /* se l'indice ordinata dei pixel è < di ... */
                           ycr = (acr*15)+73;                                                        /* lo riporta al valore corrispondente alla ull'ultima riga */
                        igr--;                                                                       /* decrementa l'indice riga */
                       if(igr < 0)                                                                  /* se l'indice riga è inferiore alla prima riga ... */
                            igr = acr-1;                                                             /* setta l'indice riga alla dimensione massima inserita */
                 break;                                                                          /* fine del secondo caso */

               case 77:                                                                        /* caso in cui sia stata premuta la freccia a destra ... */
                     if(strcmp(scacchieracrcopia[igr][jgr],"[/]")!=0)                             /* se la cella della scacchieracopia è aperta ... */
                           setcolor(7);                                                              /* seleziona il colore grigio chiaro */
                       else{                                                                        /* altrimenti ... */
                         setcolor(2);                                                                  /* seleziona il colore verde */
                       }                                                                            /* chiusura dell'else */
                     outtextxy(xcr,ycr,"_");                                                      /* sovrascrive e quindi cancella il cursore */
                       xcr += 15;                                                                   /* incrementa l'indice delle ascisse dei pixel di 15 unità */
                       if(xcr > (bcr*15)+109)                                                       /* se l'indice ascissa dei pixel è > di ... */
                           xcr = 124;                                                                /* lo riporta al valore iniziale corrispondente alla prima colonna */
                       jgr++;                                                                       /* incrementa l'indice colonna */
                       if(jgr > bcr-1)                                                              /* se l'indice colonna è superiore alla dimensione massima ... */
                           jgr = 0;                                                                  /* riazzera l'indice colonna */
                 break;                                                                          /* fine del terzo caso */

               case 75:                                                                        /* caso in cui sia stata premuta la freccia sinistra ... */
                     if(strcmp(scacchieracrcopia[igr][jgr],"[/]")!=0)                             /* se la cella della scacchieracopia è aperta ... */
                           setcolor(7);                                                             /* seleziona il colore grigio chiaro */
                       else{                                                                        /* altrimenti ... */
                         setcolor(2);                                                              /* seleziona il colore verde */
                       }                                                                            /* chiusura dell'else */
                     outtextxy(xcr,ycr,"_");                                                      /* sovrascrive e quindi cancella il cursore */
                     xcr -= 15;                                                                   /* decrementa l'indice delle ascisse dei pixel di 15 unità */
                       if(xcr < 124)                                                                /* se l'indice ascissa dei pixel è < di ... */
                           xcr = (bcr*15)+109;                                                       /* lo riporta al valore corrispondente alla ull'ultima colonna */
                       jgr--;                                                                       /* decrementa l'indice colonna */
                       if(jgr < 0)                                                                  /* se l'indice colonna è inferiore alla prima ... */
                           jgr = bcr-1;                                                              /* setta l'indice colonna alla dimensione massima inserita */
                 break;                                                                          /* fine del quarto caso */

                 case 98:                                                                            /* caso in cui sia stata premuta la lettera B ... */
                       if(strcmp(scacchieracrcopia[igr][jgr],"[/]")!=0)                             /* se la cella della scacchieracopia è aperta ... */
                           setcolor(7);                                                              /* seleziona il colore grigio chiaro */
                       else{                                                                        /* altrimenti ... */
                         setcolor(4);                                                              /* seleziona il colore rosso */
                       }                                                                            /* chiusura dell'else */
                       outtextxy(xcr,ycr,"B");                                                      /* visualizza alle coordinate indicate la lettera B */
                       scacchierabcr[igr][jgr]="[B]";                                               /* assegna quella stringa alla corrispondente cella in questione delle scacchierab */
                       if(strcmp(scacchieracrcopia[igr][jgr],"[/]")!=0){                             /* se la cella della scacchieracopia è aperta ... */
                           scacchierabcr[igr][jgr]="[/]";                                            /* assegna quella stringa alla corrispondente cella in questione delle scacchierab */
                        }                                                                     /* chiusura if */

                        /* ciclo for per scorrere scacchierabcr, confrontarla con [B] e contare quante ne sono state immesse */
                        for (m=0; m<acr; m++){                                                  /* indice per scorrere le righe */
                       for (n=0; n<bcr; n++){                                               /* indice per scorrere le colonne */
                              if(strcmp(scacchierabcr[m][n],"[B]")==0){                       /* compara scacchierabcr con [B] */
                                 flag++;                                                      /* in caso di esito positivo aumenta la variabile flag */
                             }                                                               /* chiusura if */
                          }                                                                  /* chiusura secondo for */
                   }                                                                     /* chiusura primo for */

                        /* operazioni per l'assegnamento dei valori da far apparire negli appositi riquadri */
                   parteintera1b=(flag/100);
                   parteintera2b=(flag/10)%10;
                   restob=(flag%10);

                   polyb1[0]=40;                                                                    /* coordinate primo vertice del poligono */
                polyb1[1]=100;
    
                   polyb1[2]=85;                                                                         /* coordinate secondo vertice del poligono */
                polyb1[3]=100;
    
                polyb1[4]=85;                                                                     /* coordinate terzo vertice del poligono */
                polyb1[5]=115;
    
                polyb1[6]=40;                                                                    /* coordinate quarto vertice del poligono */
                polyb1[7]=115;
    
                   setfillstyle(1, 15);                                                             /* seleziona lo stile di riempimento, pieno 2 di colore bianco */
                   fillpoly(4, polyb1);                                                  /* riempie il poligono di 4 vertici con le coordinate del vettore poly */

                   setcolor(4);                                                          /* setta il colore rosso */
                   settextstyle(0,0,1);                                                  /* setta lo stile e gli estremi per la scrittura */

                    /* funzione switch per visualizzare il numero giusto in base al valore calcolato */
                   switch(parteintera1b){
    
                    case 0:                                                            /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                        outtextxy(47, 108, "0");
                    break;                                                             /* chiusura case */

                    case 1:                                                            /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                        outtextxy(47, 108, "1");
                    break;                                                             /* chiusura case */

                    case 2:                                                            /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                        outtextxy(47, 108, "2");
                    break;                                                             /* chiusura case */

                    case 3:                                                            /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                        outtextxy(47, 108, "3");
                    break;                                                             /* chiusura case */

                    case 4:                                                            /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                        outtextxy(47, 108, "4");
                    break;                                                             /* chiusura case */

                    case 5:                                                            /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                        outtextxy(47, 108, "5");
                    break;                                                             /* chiusura case */
    
                    case 6:                                                            /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                        outtextxy(47, 108, "6");
                    break;                                                             /* chiusura case */

                    case 7:                                                              /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                                   outtextxy(47, 108, "7");
                    break;                                                               /* chiusura case */

                          case 8:                                                            /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                        outtextxy(47, 108, "8");
                    break;                                                             /* chiusura case */

                    case 9:                                                            /* nel caso in cui sai 0 visualizza 0 alle coordinate indicate */
                        outtextxy(47, 108, "9");
                          break;                                                             /* chiusura case */
    
                        }                                                                     /* chiusura switch */

                        /* cicli switch uguali a quello precedente con le stesse istruzioni */
                   switch(parteintera2b){                                                   /* switch sulla variabile parteintera2b */
    
                    case 0:
                        outtextxy(62, 108, "0");
                    break;
    
                               case 1:
                                 outtextxy(62, 108, "1");
                    break;

                    case 2:
                        outtextxy(62, 108, "2");
                    break;
    
                    case 3:
                                 outtextxy(62, 108, "3");
                    break;

                    case 4:
                        outtextxy(62, 108, "4");
                    break;

                    case 5:
                        outtextxy(62, 108, "5");
                    break;

                    case 6:
                        outtextxy(62, 108, "6");
                    break;

                    case 7:
                        outtextxy(62, 108, "7");
                    break;
    
                    case 8:
                        outtextxy(62, 108, "8");
                    break;

                        case 9:
                        outtextxy(62, 108, "9");
                          break;

                }                                                                     /* chiusura switch */
    
                   switch(restob){                                                       /* switch sulla variabile restob */

                    case 0:
                        outtextxy(77, 108, "0");
                    break;

                    case 1:
                        outtextxy(77, 108, "1");
                    break;
    
                    case 2:
                        outtextxy(77, 108, "2");
                    break;

                    case 3:
                        outtextxy(77, 108, "3");
                    break;

                    case 4:
                        outtextxy(77, 108, "4");
                    break;

                    case 5:
                        outtextxy(77, 108, "5");
                    break;

                    case 6:
                        outtextxy(77, 108, "6");
                    break;

                    case 7:
                        outtextxy(77, 108, "7");
                    break;

                    case 8:
                        outtextxy(77, 108, "8");
                    break;

                         case 9:
                        outtextxy(77, 108, "9");
                    break;

                }                                                                     /* chiusura switch */

            break;                                                                          /* fine quinto caso tasto B */
    
            case 83:                                                                           /* caso in cui sia stato premuto il tasto CANC */
                        if((strcmp(scacchieracrcopia[igr][jgr],"[/]")!=0)&&(strcmp(scacchieracrcopia[igr][jgr],"[B]")!=0)) /* se la cella della scacchieracopia è aperta ... */
                            goto salta;                                                               /* seleziona il colore grigio chiaro */
                        else{                                                                        /* altrimenti ... */
                         setcolor(2);                                                              /* seleziona il colore verde */
                         outtextxy(xcr,ycr,"B");                                                   /* sovrascrive e quindi cancella la lettera B */
                           scacchierabcr[igr][jgr]="[/]";                                            /* assegna quella stringa alla corrispondente cella in questione di scacchierab e scacchieracopia */
                               scacchieracrcopia[igr][jgr]="[/]";
                               setcolor(2);                                                       /* setta il colore verde */
                               outtextxy(xcr,ycr,"_");                                            /* visualizza un testo alle coordinate indicate */
                        }                                                                            /* chiusura else */

                        /* cicli for per scorrere e comparare scacchierabcr con [B] */
                        for (m=0; m<acr; m++){                                                  /* indice per scorrere le righe */
                       for (n=0; n<bcr; n++){                                               /* indice per scorrere le colonne */
                              if(strcmp(scacchierabcr[m][n],"[B]")==0){                          /* compara scacchierabcr con [B] */
                                 flag++;                                                      /* incrementa la variabile flag */
                             }                                                               /* chiusura if */
                          }                                                                  /* chiusura secondo for */
                   }                                                                     /* chiusura primo for */

                        /* operazioni per visualizzare il numero delle bandierine inserite dopo aver premuto il tasto CANC */
                        /* si seguano le medesime istruzioni viste nel caso del tasto B */
                   parteintera1b=(flag/100);
                   parteintera2b=(flag/10)%10;
                   restob=(flag%10);

                   polyb1[0]=40;
                polyb1[1]=100;

                   polyb1[2]=85;
                polyb1[3]=100;

                polyb1[4]=85;
                polyb1[5]=115;

                polyb1[6]=40;
                polyb1[7]=115;
    
                   setfillstyle(1, 15);
                   fillpoly(4, polyb1);

                   setcolor(4);
                   settextstyle(0,0,1);

                   switch(parteintera1b){
    
                    case 0:
                        outtextxy(47, 108, "0");
                    break;
    
                    case 1:
                        outtextxy(47, 108, "1");
                    break;
    
                    case 2:
                        outtextxy(47, 108, "2");
                    break;
    
                    case 3:
                        outtextxy(47, 108, "3");
                    break;
    
                    case 4:
                        outtextxy(47, 108, "4");
                    break;
    
                    case 5:
                        outtextxy(47, 108, "5");
                    break;
    
                    case 6:
                        outtextxy(47, 108, "6");
                    break;
    
                    case 7:
                                 outtextxy(47, 108, "7");
                    break;
    
                    case 8:
                        outtextxy(47, 108, "8");
                    break;
    
                          case 9:
                        outtextxy(47, 108, "9");
                          break;
    
                }
    
                   switch(parteintera2b){
    
                    case 0:
                        outtextxy(62, 108, "0");
                    break;
    
                    case 1:
                                 outtextxy(62, 108, "1");
                    break;
    
                    case 2:
                        outtextxy(62, 108, "2");
                    break;
    
                    case 3:
                        outtextxy(62, 108, "3");
                    break;
    
                    case 4:
                        outtextxy(62, 108, "4");
                    break;
    
                    case 5:
                        outtextxy(62, 108, "5");
                    break;
    
                    case 6:
                        outtextxy(62, 108, "6");
                    break;
    
                    case 7:
                        outtextxy(62, 108, "7");
                    break;
    
                    case 8:
                        outtextxy(62, 108, "8");
                    break;
    
                          case 9:
                        outtextxy(62, 108, "9");
                          break;
    
                        }
    
                   switch(restob){
    
                    case 0:
                        outtextxy(77, 108, "0");
                    break;
    
                    case 1:
                        outtextxy(77, 108, "1");
                    break;
    
                    case 2:
                        outtextxy(77, 108, "2");
                    break;
    
                    case 3:
                        outtextxy(77, 108, "3");
                    break;
    
                    case 4:
                        outtextxy(77, 108, "4");
                    break;
    
                    case 5:
                        outtextxy(77, 108, "5");
                    break;
    
                    case 6:
                        outtextxy(77, 108, "6");
                    break;
    
                    case 7:
                        outtextxy(77, 108, "7");
                    break;
    
                    case 8:
                        outtextxy(77, 108, "8");
                    break;
    
                    case 9:
                        outtextxy(77, 108, "9");
                          break;
    
                }
    
salta:                                                                            /* etichetta per la funzione goto */
            break;                                                                          /* fine sesto caso */
    
                 case 110:                                                                       /*caso in cui sia stata premuta la lettera n */
                     gocr=1; /*n*/                                                                /* setta a 1 il valore della variabile gameover della fuzione cursore */
                 break;                                                                              /* fine settimo caso */
    
                 case 32:                                                                           /* caso in cui venga premuto SPAZIO */
                       if(strcmp(scacchierabcr[igr][jgr],"[B]")!=0){                         /* solo se non siamo su una casella con bandierina */
                           if(strcmp(scacchieracr[igr][jgr], "[*]")==0){                            /* se la cella della scacchiera è uguale a una bomba ... */
                                 gocr=1;                                                               /* setta a 1 il valore della variabile gameover della fuzione cursore */
                               while(key!=110){                                                      /* inizio di un ciclo while da effettuare finchè non si preme la lettera n */
                                   setcolor(0);                                                            /* seleziona il colore nero */
                               settextstyle(0,0,1);                                               /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
                               outtextxy(10,25,"'B' per bandierina");                                /* visualizza alle coordinate indicate il messaggio digitato */
                               outtextxy(210,25,"'SPAZIO' per scoprire");                         /* visualizza alle coordinate indicate il messaggio digitato */
                               outtextxy(430,25,"'CANC' per cancellare");                         /* visualizza alle coordinate indicate il messaggio digitato */
    
                                   setcolor(0);                                                       /* setta il colore nero */
                                settextstyle(1,0,2);                                               /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
                                outtextxy(90,430,"Premere 'N' per nuova partita o per uscire");    /* sovrascrive e cancella il messaggio digitato */

                                   setcolor(14);                                                      /* setta il colore giallo */
                                settextstyle(1,0,3);                                               /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
                                outtextxy(150,430,"Premere 'N' per nuova partita ");            /* visualizza alle coordinate indicate il messaggio digitato */

                                   settextstyle(0,0,2.5);                                             /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
                                   setcolor(4);                                                       /* seleziona il colore rosso */
                               outtextxy(165,15,".....HAI PERSO!!!.....");                        /* visualizza alle coordinate indicate il messaggio digitato */
                                  outtextxy(160,35,".....Gioco Finito.....");                        /* visualizza alle coordinate indicate il messaggio digitato */

                                         /* cicli per la visualizzazione delle caselle aperte in profondità */
                                   for(igcr1=0; igcr1<acr; igcr1++){                                  /* ciclo for per lo scorrimento delle righe */
                                       for(jgcr1=0; jgcr1<bcr; jgcr1++){                               /* ciclo for per lo scorrimento delle colonne */
                                     for(kcr=0; kcr<numbombecr; kcr++){                           /* ciclo for per lo scorrimento dei vettor delle coordinate delle bombe */
                                                 if((igcr1==vibcr[kcr])&&(jgcr1==vjbcr[kcr])){         /* se l'indice riga e colonna corrispondono ad una bomba ... */
                                                          setlinestyle(0,0,NORM_WIDTH);                          /* seleziona il tipo di linea con spessore normale */
                                                        setcolor(0);                                           /* seleziona il colore nero*/
    
                                                        polycr[0]=(jgcr1*15)+120;                              /* coordinata x per il primo vertice del poligono */
                                                    polycr[1]=(igcr1*15)+80;                               /* coordinata y per il primo vertice del poligono */
    
                                                               polycr[2]=(jgcr1*15)+135;                              /* coordinata x per il secondo vertice del poligono */
                                                  polycr[3]=(igcr1*15)+80;                               /* coordinata y per il secondo vertice del poligono */
    
                                                  polycr[4]=(jgcr1*15)+135;                              /* coordinata x per il terzo vertice del poligono */
                                                  polycr[5]=(igcr1*15)+95;                               /* coordinata y per il terzo vertice del poligono */
    
                                                           polycr[6]=(jgcr1*15)+120;                              /* coordinata x per il quarto vertice del poligono */
                                                polycr[7]=(igcr1*15)+95;                               /* coordinata y per il quarto vertice del poligono */
    
                                                    setfillstyle(1,7);                                        /* seleziona lo stile di riempimento, pieno 2 di colore grigio */
                                                fillpoly(4, polycr);                                   /* riempie il poligono di 4 vertici con le coordinate del vettore poly */
    
                                                           txcr=(jgcr1*15)+124;                                   /* assegnamento valore alla variabile tx (posizione x del testo) */
                                                  tycr=(igcr1*15)+88;                                    /* assegnamento valore alla variabile ty (posizione y del testo) */
                                                            settextstyle(0,0,1);                                      /* seleziona la fonte, la direzione e la grandezza del testo */
                                             outtextxy(txcr,tycr,"*");                              /* visualizza alle coordinate indicate l'asterisco per indicare la bomba */
                                                        }                                                                    /* chiusura ciclo if */
                                               }                                                                           /* chiusura ciclo for per l'indice vettori bomba */
                                          }                                                                              /* chiusura ciclo for per l'indice colonna */
                                   }                                                                  /* chiusura ciclo for per l'indice riga */
                                    key=getch();                                                       /* assegna alla variabile key il valore del tasto premuto */
                            }                                                                                      /* chiusura ciclo while */
                            }                                                                                            /* chiusura ciclo if per la bomba */
                               else{                                                                    /* altrimenti se la casella non è uguale a una bomba */
                                giococr=giocata(acr, bcr, igr, jgr, numbombecr, vibcr, vjbcr, scacchieracr, scacchieracrcopia, scacchierabcr, gocr, giococr);
                           }                                                                        /* chiusura dell'else */

                               /* funzione if nel caso in cui la funzione giocata restituisca valore 1 (fine gioco) */
                               if(giococr==1){
                               while(key!=110){                                                      /* inizio di un ciclo while da effettuare finchè non si preme la lettera n */
                                     setcolor(0);                                                             /* seleziona il colore bianco */
                                          settextstyle(0,0,1);                                               /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
                                outtextxy(10,25,"'B' per bandierina");                                 /* visualizza alle coordinate indicate il messaggio digitato */
                                outtextxy(210,25,"'SPAZIO' per scoprire");                         /* visualizza alle coordinate indicate il messaggio digitato */
                                outtextxy(430,25,"'CANC' per cancellare");                         /* visualizza alle coordinate indicate il messaggio digitato */

                                         settextstyle(0,0,3);                                                 /* seleziona la fonte del testo, la direzione orizzontale e la grandezza */
                                setcolor(14);                                                       /* seleziona il colore rosso */
                               outtextxy(100,15,"...COMPLIMENTI!!!..");                            /*    visualizza alle coordinate indicate il messaggio digitato */
                                  outtextxy(100,40,".....Hai vinto.....");                            /*    visualizza alle coordinate indicate il messaggio digitato */
                                
                            gocr=1;                                                      /* assegna il valore 1 alla variabile gocr */
                                         key=getch();                                                    /* assegna alla variabile key il valore del tsto assegnato */
                                 }                                                               /* chiusura while */
                        }                                                                   /* chiusura if */
                      }                                                                            /* chiusura dell'if se è diverso da B */
                break;                                                                           /* chiusura ottavo caso */
           }                                                          /* chiusura dell' operatore condizionale switch */
      }                                                          /* chiusura del ciclo while */
}                                                             /* fine della funzione cursore */


/* funzione controlloA per la gestione dei dati da inserire nelle caselle di scacchiera */
char *controlloA(int i2, int j2, int vib2[99], int vjb2[99], int numbombe2)
{
    int contamine = 0;                                                                                 /* contatore delle mine */
       int i3, j3;                                                                                          /* contatore per scorrere le 8 caselle attorno ad una desiderata */
       int k2;                                                                                                 /* contatore per scorrere i vettori con le coordinate delle bombe */

       /* ciclo for per lo scorrimento della matrice 3x3 attorno alla casella scelta */
      for (i3=(i2-1); i3<=(i2+1); i3++){                                                    /* ciclo for per scorrere le righe */
           for (j3=(j2-1); j3<=(j2+1); j3++){                                                 /* ciclo for per scorrere le colonne */
                 for (k2=0; k2<numbombe2; k2++){                                                 /* ciclo for per scorrere le coordinate dei vettore delle bombe */
                       if ((i3==vib2[k2])&&(j3==vjb2[k2])){                                         /* se indice corrente della casella corrisponde ad una bomba ... */
                         contamine++;                                                              /* incrementa di uno il valore del contatore delle mine */
                     }                                                                            /* chiusura dell'if */
            }                                                                               /* chiuusra del for per l'indice delle bonmbe */
        }                                                                                  /* chiuusra del for per l'indice delle colonne */
    }                                                                                     /* chiuusra del for per l'indice delle righe */

       switch(contamine){                                                                    /* esamina il valore di contamine e demanda alla rispettiva istruzione */

        case 0:
            return "[-]";                                                           /* caso di casella senza bombe confinanti */
        break;

        case 1:
            return "[1]";                                                           /* caso di casella con una casella bomba confinante */
        break;

        case 2:
            return "[2]";                                                           /* caso di casella con due caselle bomba confinanti */
        break;

        case 3:
            return "[3]";                                                           /* caso di casella con tre caselle bomba confinanti */
        break;

        case 4:
            return "[4]";                                                           /* caso di casella con quattro caselle bomba confinanti */
        break;

        case 5:
            return "[5]";                                                           /* caso di casella con cinque caselle bomba confinanti */
        break;

        case 6:
            return "[6]";                                                           /* caso di casella con sei caselle bomba confinanti */
        break;

        case 7:
            return "[7]";                                                           /* caso di casella con sette caselle bomba confinanti */
        break;

        case 8:
            return "[8]";                                                           /* caso di casella con otto caselle bomba confinanti */
        break;

    }                                                                             /* chiusura switch */
}                                                                                /* chiusura funzione */


/* funzione riempimento per l'assegnamento dei valori alle caselle di scacchiera */
char *riempimento(int i1, int j1, int vib1[99], int vjb1[99], int numbombe1)
{
    int z=0;                                                                                             /* valore par la determinazione di una condizione */
       int k1;                                                                                                 /* contatore per scorrere i vettori con le coordinate delle bombe */

       /* ciclo for per l'assegnamento del valore 1 alla variabile z se la casella in questione contiene una bomba */
    for (k1=0; k1<numbombe1; k1++){                                               /* ciclo for con variabile k */
        if ((i1==vib1[k1])&&(j1==vjb1[k1])){                                       /* confronta le coordinate in cui ci si trova con quelle delle bombe */
            z=1;                                                                    /* assegna 1 alla variabile z */
             }                                                                          /* chiusura if */
       }                                                                             /* chiusura for */

       /* funzione if-else per la gestione dei valori della variabile z */
       if(z==1){                                                                     /* se z=1 ... */
        return "[*]";                                                              /* ritorna la stringa rappresentante la bomba */
       }                                                                             /* chiusura if */
       else{                                                                         /* altrimenti ... */
           return controlloA(i1, j1, vib1, vjb1, numbombe1);                          /* richiama la funzione controlloA */
       }                                                                             /* chiusura else */
}                                                                                /* fine funzione riempimento */


/* funzione espansione per aprire tutte le caselle bianche possibili */
void espansione(int ige, int jge, char *scacchierae[25][40], char *scacchieraecopia[25][40])
{
    int ie, je;                                                                   /* variabili per scorrere le scacchiere */

       scacchierae[ige][jge]= "[$]";                                                 /* inizializzazione stringa per la funzione scacchiera */

       /* cicli for per scorrere scacchieracopia e assegnare il valore di scacchiera alla casella con le coordinate indicate */
       for(ie=ige-1; ie<=ige+1; ie++){
           for(je=jge-1; je<=jge+1; je++){
                  scacchieraecopia[ie][je]=scacchierae[ie][je];                        /* assegna il valore di scacchiera a scacchiera copia nelle stesse coordinate */
              }                                                                          /* chiusura secondo for */
       }                                                                             /* chiusura primo for */
}                                                                                /* fine funzione espansione */


/* funzione giocata per la gestione del gioco */
int giocata (int ag, int bg, int ig, int jg, int numbombeg, int vibg[99], int vjbg[99], char *scacchierag[25][40], char *scacchieragcopia[25][40],char *scacchierabcrg[25][40], int gocrg, int giocog)
{
    int q=0;                                                                                             /* variabile per la ricerca delle coordinate */
    int puntog;                                                                                         /* contatore per scorrere i vettori giocate */
    int kg=0;                                                                                             /* contatore per scorrere il vettore delle coordinate delle bombe */
    int ke=0;
       int z=0;                                                                      /* variabile per la condizione di esistenza del primo while */
       int count=0;                                                                  /* variabile per il richiamo della funzione espansione */
       int polyg[8];                                                                 /* vettore per i riquadri da disegnare */
       int tx, ty;                                                                   /* variabile per le coordinate delle caselle da scoprire */
       int igc, jgc;                                                                 /* varibili per scorrere le scacchiere */
       int ri, co;
       int caselleaperte=0;                                                          /* variabile per il conteggio delle caselle aperte */
       int parteintera1, parteintera2, resto;                                        /* variabili per il conteggio delle bandierine inserite */
       int polyb2[8];                                                                /* vettore per i riquadri da disegnare */

    /* funzione if per controllare se è stata inserita una bandierina */
        if(strcmp(scacchierabcrg[ig][jg], "[B]")==0){                           /* se la casella contiene una bandierina ... */
               goto bandierina;                                                     /* rimanda all'etichetta bandierina */
        }                                                                       /* chiusura if */

        /* operazioni per gestire le caselle scoperte */
        setlinestyle(0,0,NORM_WIDTH);                                           /* setta lo stile delle linee */
        setcolor(0);                                                            /* setta il colore a nero */
    polyg[0]=(jg*15)+120;                                                   /* coordinate delle caselle per il vettore polyg */
        polyg[1]=(ig*15)+80;
        polyg[2]=(jg*15)+135;
        polyg[3]=(ig*15)+80;
        polyg[4]=(jg*15)+135;
        polyg[5]=(ig*15)+95;
        polyg[6]=(jg*15)+120;
        polyg[7]=(ig*15)+95;

        setfillstyle(1,7);                                                                     /* seleziona lo stile di riempimento, pieno 2 di colore grigio */
        fillpoly(4, polyg);                                                                    /* riempie il poligono di 4 vertici con le coordinate del vettore polyg */

        tx=(jg*15)+124;                                                         /* assegna un valore alle variabili tx e ty */
        ty=(ig*15)+88;
        settextstyle(0,0,1);                                                    /* setta lo stile di scrittura */

               scacchieragcopia[ig][jg]=scacchierag[ig][jg];                           /* assegna in valora di scacchierag[][] a scacchieragcopia[][] */

    if(strcmp(scacchieragcopia[ig][jg], "[-]")==0){                                /* se la casella di scacchieracopia è vuota ... */
              espansione(ig, jg, scacchierag, scacchieragcopia);                          /* su scacchieragcopia esegue la copia delle otto circostanti */

            while(z==0){                                                         /* funzione while con condizione d'esistenza di z=0 */

                 count=0;                                                          /* assegna un valore alla variabile count */

                       /* ciclo for per scorrere scacchieragcopia */
                   for (igc=0; igc<ag; igc++){
                        for (jgc=0; jgc<bg; jgc++){
                             if(strcmp(scacchieragcopia[igc][jgc],"[-]")==0){            /* se scacchieragcopia è aperta ... */
                                    count++;                                                 /* incrementa count */
                                       ig=igc;                                                  /* assegna alle nuove coordinate quelle delle caselle bianche trovate */
                                       jg=jgc;

                                       espansione(ig, jg, scacchierag, scacchieragcopia);       /* richiama la funzione espansione con le nuove coordinate */

                                }                                                                                /* chiusura if */
                          }                                                                                    /* chiusura for per le colonne */
                      }                                                                                        /* chiusura for per le righe */

                      if(count==0){                                                     /* se non sono state trovate caselle vuote ... */
                          z++;                                                           /* incrementa z per uscire dal ciclo while */
                      }                                                                                        /* chiusura if */
        }                                                                                              /* chiusura ciclo while */

               z=0;                                                                 /* reimposta z a 0 */
        }                                                                                                  /* chiusura dell'if se la casella di scacchieracopia è vuota */

        /* cicli for per assegnare valori a scacchieragcopia[][] */
        for (igc=0; igc<ag; igc++){                                                  /* indice per scorrere le righe */
               for (jgc=0; jgc<bg; jgc++){                                              /* indice per scorrere le colonne */
                      if(strcmp(scacchierabcrg[igc][jgc], "[B]")==0){                        /* le caselle di scacchierab che hanno la bandierina */
                         scacchieragcopia[igc][jgc]=scacchierabcrg[igc][jgc];                /* le copia in scacchieracopia */
                       }                                                                      /* chiusura dell'if */
             }                                                                         /* chiusura del for per le colonne */
        }                                                                            /* chiusura del for per le righe */

        /* cicli for per la gestione dei valori all'interno delle caselle */
    for (igc=0; igc<ag; igc++){                                                   /* indice per scorrere le righe */
            for (jgc=0; jgc<bg; jgc++){                                                /* indice per scorrere le colonne */
                   if(strcmp(scacchieragcopia[igc][jgc], "[/]")!=0){                         /* se la casella di scacchieragcopia è aperta */

                        /* operazioni per la gestione grafica delle caselle scoperte */
                        setlinestyle(0,0,NORM_WIDTH);                                  /* setta lo stile delle linee */
                         setcolor(0);                                                   /* setta il colore a nero */
                polyg[0]=(jgc*15)+120;                                               /* coordinate primo vertice */
                     polyg[1]=(igc*15)+80;
                     polyg[2]=(jgc*15)+135;                                               /* coordinate secondo vertice */
                        polyg[3]=(igc*15)+80;
                    polyg[4]=(jgc*15)+135;                                               /* coordinate terzo vertice */
                     polyg[5]=(igc*15)+95;
                     polyg[6]=(jgc*15)+120;                                               /* coordinate quarto vertice */
                     polyg[7]=(igc*15)+95;

                setfillstyle(1,7);                                                         /* seleziona lo stile di riempimento, pieno 2 di colore grigio */
                fillpoly(4, polyg);                                                        /* riempie il poligono di 4 vertici con le coordinate del vettore poly */

                         tx=(jgc*15)+124;                                               /* assegna valori alle variabili tx e ty */
                     ty=(igc*15)+88;
                     settextstyle(0,0,1);                                           /* setta lo stile di scrittura */

                /* funzioni if per far apparire il valore rilevato */
                     if(strcmp(scacchieragcopia[igc][jgc], "[1]")==0){              /* se il valore da visualizzare è 1 setta il colore a blu chiaro e lo visualizza */
                         setcolor(9);
                         outtextxy(tx,ty,"1");
                     }

                if(strcmp(scacchieragcopia[igc][jgc], "[2]")==0){              /* se il valore da visualizzare è 2 setta il colore a verde chiaro e lo visualizza */
                    setcolor(10);
                           outtextxy(tx,ty,"2");
                }

                if(strcmp(scacchieragcopia[igc][jgc], "[3]")==0){              /* se il valore da visualizzare è 3 setta il colore a rosso e lo visualizza */
                         setcolor(4);
                         outtextxy(tx,ty,"3");
                     }

                if(strcmp(scacchieragcopia[igc][jgc], "[4]")==0){              /* se il valore da visualizzare è 4 setta il colore a blu e lo visualizza */
                    setcolor(1);
                    outtextxy(tx,ty,"4");
                }

                if(strcmp(scacchieragcopia[igc][jgc], "[5]")==0){              /* se il valore da visualizzare è 5 setta il colore a magenta e lo visualizza */
                    setcolor(5);
                    outtextxy(tx,ty,"5");
                }

                     if(strcmp(scacchieragcopia[igc][jgc], "[6]")==0){              /* se il valore da visualizzare è 6 setta il colore a ciano e lo visualizza */
                         setcolor(3);
                         outtextxy(tx,ty,"6");
                     }

                if(strcmp(scacchieragcopia[igc][jgc], "[7]")==0){              /* se il valore da visualizzare è 7 setta il colore a marrone e lo visualizza */
                         setcolor(6);
                         outtextxy(tx,ty,"7");
                     }

                if(strcmp(scacchieragcopia[igc][jgc], "[8]")==0){              /* se il valore da visualizzare è 8 setta il colore a giallo e lo visualizza */
                    setcolor(14);
                    outtextxy(tx,ty,"8");
                }

                     if(strcmp(scacchieragcopia[igc][jgc], "[$]")==0){              /* se il valore da visualizzare è "spazio" setta il colore a grigio chiaro e lo visualizza */
                         setcolor(7);
                         outtextxy(tx,ty," ");
                     }

                          if(strcmp(scacchieragcopia[igc][jgc], "[B]")==0){              /* se il valore da visualizzare è "B" setta il colore a rosso e lo visualizza */
                              setlinestyle(0,0,THICK_WIDTH);                              /* ricostruendo i bordi della casella con lo stile impostato, nelle coordinate previste */
                                setcolor(1);
                    polyg[0]=(jgc*15)+120;
                        polyg[1]=(igc*15)+80;
                         polyg[2]=(jgc*15)+135;
                                polyg[3]=(igc*15)+80;
                         polyg[4]=(jgc*15)+135;
                         polyg[5]=(igc*15)+95;
                         polyg[6]=(jgc*15)+120;
                         polyg[7]=(igc*15)+95;

                    setfillstyle(1,2);                                                     /* seleziona lo stile di riempimento, pieno 2 di colore verde */
                    fillpoly(4, polyg);                                                    /* riempie il poligono di 4 vertici con le coordinate del vettore polyg */

                         setcolor(4);
                         outtextxy(tx,ty,"B");
                     }
                      }                                                                                       /* chiusura dell'if se la casella di scacchieracopia è aperta */
                      else{                                                                                      /* altrimenti se la casella di scacchieracopia è chiusa */
                          setlinestyle(0,0,THICK_WIDTH);                                 /* setta lo stile di scrittura della linea */
                          setcolor(1);                                                   /* setta il colore blu */
                        polyg[0]=(jgc*15)+120;                                         /* coordinate della casella in cui compiere le operazioni */
                         polyg[1]=(igc*15)+80;
                         polyg[2]=(jgc*15)+135;
                         polyg[3]=(igc*15)+80;
                         polyg[4]=(jgc*15)+135;
                         polyg[5]=(igc*15)+95;
                         polyg[6]=(jgc*15)+120;
                         polyg[7]=(igc*15)+95;

                        setfillstyle(1,2);                                                         /* seleziona lo stile di riempimento, pieno 2 di colore verde */
                         fillpoly(4, polyg);                                                        /* riempie il poligono di 4 vertici con le coordinate del vettore polyg */
                      }                                                                             /* chiusura dell'else */
               }                                                                                              /* chiusura ciclo for per le colonne */
        }                                                                                                  /* chiusura ciclo for per le righe */
bandierina:                                                                   /* etichetta per la funzione goto */

       /* cicli per contare le caselle aperte */
       for (ig=0; ig<ag; ig++){                                                              /* indice per scorrere le righe */
           for (jg=0; jg<bg; jg++){                                                           /* indice per scorrere le colonne */
               if((strcmp(scacchierabcrg[ig][jg],"[B]")!=0)&&(strcmp(scacchieragcopia[ig][jg],"[/]")!=0)){    /* se le caselle non hanno la B e non sono chiuse ... */
                     caselleaperte++;                                                     /* incrementa la variabile caselleaperte */
                 }                                                                       /* chiusura if */
              }                                                                          /* chiusura secondo for */
       }                                                                             /* chiusura primo for */

       if(caselleaperte==((ag*bg)-numbombeg)){                                       /* se la caselle scoperte sono tutte quelle possibili ... */
           giocog=1;                                                                  /* giocog diventa 1 e interrompe il gioco */
    }                                                                             /* chiusura if */

       /* operazioni per visualizzare le caselle scoperte */                         /* le istruzioni sono le stesse viste per il caso delle bandierine viste nella funzione cursore */
       parteintera1=(caselleaperte/100);
       parteintera2=(caselleaperte/10)%10;
       resto=(caselleaperte%10);
       setcolor(4);
       polyb2[0]=40;
    polyb2[1]=200;

       polyb2[2]=85;
    polyb2[3]=200;

    polyb2[4]=85;
    polyb2[5]=215;

    polyb2[6]=40;
    polyb2[7]=215;

       setfillstyle(1, 15);
       fillpoly(4, polyb2);

       setcolor(4);
       settextstyle(0,0,1);
       switch(parteintera1){

        case 0:
            outtextxy(47, 208, "0");
        break;

        case 1:
            outtextxy(47, 208, "1");
        break;

        case 2:
            outtextxy(47, 208, "2");
        break;

        case 3:
            outtextxy(47, 208, "3");
        break;

        case 4:
            outtextxy(47, 208, "4");
        break;

        case 5:
            outtextxy(47, 208, "5");
        break;

        case 6:
            outtextxy(47, 208, "6");
        break;

        case 7:
            outtextxy(47, 208, "7");
        break;

        case 8:
            outtextxy(47, 208, "8");
        break;

              case 9:
            outtextxy(47, 208, "9");
              break;

    }

       switch(parteintera2){

        case 0:
            outtextxy(62, 208, "0");
        break;

        case 1:
            outtextxy(62, 208, "1");
        break;

        case 2:
            outtextxy(62, 208, "2");
        break;

        case 3:
            outtextxy(62, 208, "3");
        break;

        case 4:
            outtextxy(62, 208, "4");
        break;

        case 5:
            outtextxy(62, 208, "5");
        break;

        case 6:
            outtextxy(62, 208, "6");
        break;

        case 7:
            outtextxy(62, 208, "7");
        break;

        case 8:
            outtextxy(62, 208, "8");
        break;

        case 9:
            outtextxy(62, 208, "9");
              break;

    }

       switch(resto){

        case 0:
            outtextxy(77, 208, "0");
        break;

        case 1:
            outtextxy(77, 208, "1");
        break;

        case 2:
            outtextxy(77, 208, "2");
        break;

        case 3:
            outtextxy(77, 208, "3");
        break;

        case 4:
            outtextxy(77, 208, "4");
        break;

        case 5:
            outtextxy(77, 208, "5");
        break;

        case 6:
            outtextxy(77, 208, "6");
        break;

        case 7:
            outtextxy(77, 208, "7");
        break;

        case 8:
            outtextxy(77, 208, "8");
        break;

        case 9:
            outtextxy(77, 208, "9");
              break;

    }                                                                             /* chiusura switch */
    return giocog;                                                                /* indica la conclusione del programma con il valore da restituire dopo la chiamata */
}                                                                                                            /* chiusura della funzione giocata */

PM Quote
Avatar
Poggi Marco (Member)
Guru


Messaggi: 951
Iscritto: 05/01/2010

Segnala al moderatore
Postato alle 18:47
Mercoledì, 13/02/2013
Hai sempre gli stessi errori?

Prova con un programma più semplice.


Nulla va più veloce della luce, quindi rilassati.
PM Quote
Avatar
fedezane23 (Normal User)
Newbie


Messaggi: 6
Iscritto: 13/02/2013

Segnala al moderatore
Postato alle 19:12
Mercoledì, 13/02/2013
Il mio professore mi ha consigliato Quincy dato che nemmeno lui sapeva aiutarmi.
Ora sto vedendo in questo sito Sorgenti->Delphi  qualche programma già fatto per orientarmi e sto combattendo per riuscire a scaricare delphi 7

PM Quote
Avatar
Poggi Marco (Member)
Guru


Messaggi: 951
Iscritto: 05/01/2010

Segnala al moderatore
Postato alle 19:28
Mercoledì, 13/02/2013
Scusa la mia ignoranza, cosa è Quincy?

Delphi 7, lo puoi truvare quì: http://delphi.developpez.com/telecharger-gratuit/delphi7-p ...
Ad ogni modo ti consiglio Lazarus http://sourceforge.net/projects/lazarus/files/.
(Se vuoi qualcosa di simile ai comandi del Borland c++, vedi direttamente free pascal.)


Nulla va più veloce della luce, quindi rilassati.
PM Quote
Avatar
fedezane23 (Normal User)
Newbie


Messaggi: 6
Iscritto: 13/02/2013

Segnala al moderatore
Postato alle 21:49
Mercoledì, 13/02/2013
Gentilissimo!

Sarò sincero, ne so poco anch'io, per quello che ho capito Quincy 2005 c++ sarebbe un compilatore che utilizza librerie grafiche compatibile con il sistema operativo che utilizzo (windows 7 64 bit).
Giustamente potrei utilizzare tantissimi altri compilatori ma chissà perchè mi è stato consigliato proprio questo.
Inizialmente ero partito con Borland 5 e piuttosto di passare ad una versione più aggiornata o qualcosa di più conosciuto mi hanno dato questo benedetto Quincy.
Ora mi sto arrampicando agli specchi e vorrei provare a risolvere il mio problema con Delphi.

PM Quote
Avatar
arack95 (Member)
Pro


Messaggi: 144
Iscritto: 15/11/2010

Segnala al moderatore
Postato alle 19:15
Giovedì, 14/02/2013
"graphics .h error bgi graphics not supported under windows", primo risultato google:
http://www.cplusplus.com/forum/beginner/4924/

Testo quotato

File ==> New ==> Project
Platform: DOS (Standard), Libraries: BGI
If it don't work so type: initgraph(&dr,&m,"C:\\BC5\\BGI");



Vorrei fare invece qualche osservazione sul codice, guardandolo rapidamente ho notato che usi un numero spropositato di variabili con nomi piuttosto vaghi e che usi il goto, cose che dovresti cercare di evitare, sotto ti metterò il link di qualche pagina da leggere(ne vale la pena).
Non so se sei obbligato dal tuo professore ad usare C & BGI o meno, ma potresti provare un linguaggio più attuale(ad esempio C++ o Java) con delle librerie grafiche recenti, sicuramente incapperai nella programmazione ad oggetti, ma non è molto difficile da capire, e una volta fatto non ne potrai fare a meno :k:

http://www.fermi.mn.it/linux/stile/index.htm#c (scendi un po' e leggi da "Ogni sorgente dovrà contenere nell'ordine[...]")
http://hopfrog.it/sites/default/files/c_style.pdf (è sul C++ ma son le stesse regole del C e degli altri linguaggi, puoi saltare dove parla delle classi)
http://it.wikipedia.org/wiki/Notazione_ungara

N.B. il secondo link cita nella Bibliografia "Code complete", è un libro stupendo che spiega come scrivere codice buono, purtroppo la traduzione in italiano è fuori produzione, se riesci a trovarlo in biblioteca o da qualche parte ti consiglio di darci un occhiata.

Ultima modifica effettuata da arack95 il 14/02/2013 alle 19:23


Take life less seriously!
PM Quote
Pagine: [ 1 2 ] Precedente | Prossimo