Cani e Gatti V.2

#include <stdio.h>
#include <stdlib.h>
#include <time.h> //time.h lo utilizzo per generare un seme di numeri casuali sempre diverso per ogni esecuzione del programma
#include <math.h> //utilizzata per le funzioni potenza e radice quadrata
#include <windows.h>//la utilizzo per rallentare l'esecuzione del gioco

/*In questo primo progetto viene implementato il gioco dei cani e dei gatti
Due cani e due gatti si muovono sopra una scacchiera di dimensioni inserite dall'utente
Il gioco prevede una posizione casuale dei cani e dei gatti quando viene inizializzata la scacchiera.
Sia cani che gatti possono muoversi orizzontalmente o verticalmente di un singolo passo.
I cani si muovono per primi nella direzione del gatto più vicino a loro, mentre i gatti si muovono casualmente
in una delle direzioni possibili.
Il gioco termina quando i cani raggiungono i gatti, oppure quando termina un numero finito di passi, decisi a priori
dall'utente che esegue il programma*/

typedef enum{destra,sinistra,su,giu} Direzione; //con una enumerazione affido alle direzioni possibili un numero univoco

void dimscacchiera(int *righe, int *colonne); //procedura che chiede all'utente la dimensione di righe e colonne della scacchiera
void passidaeffettuare(int *passi); //procedura che chiede all'utente il numero di passi massimo da effettuare
void inizializzazionescacchiera(char scacchiera[][100], int righe, int colonne); //procedura che crea e inizializza la scacchiera
void cani_gatti(char scacchiera[][100],int righe, int colonne, int* rigagatto1, int *colonnagatto1,
                int* rigagatto2, int *colonnagatto2, int* rigacane1, int* colonnacane1,
                int* rigacane2, int* colonnacane2);
                //procedura che inserisce i cani ed i gatti nella scacchiera e ne salva le posizioni
void visualizzascacchiera(char scacchiera[][100], int righe, int colonne);//procedura che consente di visualizzare la scacchiera
void movimentogatto(char scacchiera[][100], int righe, int colonne, int *rigagatto, int *colonnagatto,
                    double *sopra, double *sotto, double *dx, double *sx);
//procedura che consente al gatto un movimento di un passo verso una delle direzioni possibili, laddove non sia occupata
void movimentocane1(char scacchiera[][100],int *rigagatto, int *colonnagatto,
                   int *rigacane, int *colonnacane, int* numgatti, double *su, double *giu, double *destra, double *sinistra);
//procedura che consente al cane1 il movimento di un passo verso il gatto più vicino
void movimentocane2(char scacchiera[][100],int *rigagatto, int *colonnagatto,
                   int *rigacane, int *colonnacane, int* numgatti, double *su, double *giu, double *destra, double *sinistra);
//procedura che consente al cane2 il movimento di un passo verso il gatto più vicino
double distanza(int rigacane, int colonnacane, int rigagatto, int colonnagatto);/*procedura che ritorna un valore con
la virgola utilizzata per calcolare la distanza tra un cane ed un gatto*/

int main()
{   char scacchiera[100][100]; //dichiarazione della scacchiera di char di dimensioni MASSIME 100x100
    int righe, colonne, passi, numgatti = 2;
    /*dichiarazione delle variabili intere righe, colonne, passi, che inserirà l'utente da tastiera.
    Le prime due generano la scacchiera, passi invece decreta la fine dell'esecuzione laddove i gatti non sono
    stati presi
    Utilizzo una variabile per tenere conto di quanti gatti restano, inizialmente settata a 2 perchè ci sono sempre
    2 e 2 soli gatti alla generazione della scacchiera*/
    int rigagatto1, colonnagatto1, rigagatto2, colonnagatto2; /*4 variabili intere che utilizzerò per non perdere
    gli indici dei due gatti su righe e colonne*/
    int rigacane1, colonnacane1, rigacane2, colonnacane2;/*4 variabili intere che utilizzerò per non perdere
    gli indici dei due cani su righe e colonne*/
    double distanza1, distanza2; /*due variabili di tipo double che utilizzerò per controllare quale distanza
    è minore da un cane ad uno dei due gatti*/
    double cane1su = 0,cane1giu = 0,cane1destra = 0,cane1sinistra = 0; //contamovimenti per il cane1
    double pcane1su = 0,pcane1giu = 0,pcane1destra = 0,pcane1sinistra = 0; //percentuali di movimento del cane1
    double cane2su = 0,cane2giu = 0,cane2destra = 0,cane2sinistra = 0; //contamovimenti per il cane2
    double pcane2su = 0,pcane2giu = 0,pcane2destra = 0,pcane2sinistra = 0; //percentuali di movimento del cane2

    double gatto1su = 0,gatto1giu = 0,gatto1destra = 0,gatto1sinistra = 0; //contamovimenti per il gatto1
    double pgatto1su = 0,pgatto1giu = 0,pgatto1destra = 0,pgatto1sinistra = 0; //percentuali di movimento del gatto1
    double gatto2su = 0,gatto2giu = 0,gatto2destra = 0,gatto2sinistra = 0; //contamovimenti per il gatto2
    double pgatto2su = 0,pgatto2giu = 0,pgatto2destra = 0,pgatto2sinistra = 0; //percentuali di movimento del gatto2

    printf("Benvenuto nel programma: Cani e Gatti\n");
    srand(time(NULL)); //genero un seme per i numeri pseudocasuali in base all'orario di esecuzione
    dimscacchiera(&righe,&colonne);//richiamo la procedura dimscacchiera per passare gli indirizzi di righe e colonne
    passidaeffettuare(&passi);//richiamo la procedura passidaeffettuare passando l'indirizzo della variabile passi
    inizializzazionescacchiera(scacchiera,righe,colonne);//richiamo la procedura per creare la scacchiera
    cani_gatti(scacchiera,righe,colonne, &rigagatto1, &colonnagatto1, &rigagatto2, &colonnagatto2,
               &rigacane1, &colonnacane1, &rigacane2, &colonnacane2);/*richiamo la procedura per inserire i cani e gatti
               nella scacchiera,in maniera CASUALE*/
    visualizzascacchiera(scacchiera,righe,colonne);//visualizzo la scacchiera chiamando la procedura apposita

    /*il seguente ciclo while è così strutturato:
    fin quando il numero dei passi è maggiore di 0 E il numero dei gatti è maggiore di 0
    esegui le istruzioni*/

    while((numgatti > 0)&&(passi > 0)){
        if(numgatti == 2){ //se il numero dei gatti è 2
                /*calcolo le distanze prima del cane 1 verso i due gatti scegliendo la minore tra le due
                In input vengono prese le posizioni del cane1 e di gatto1 per distanza1 e gatto2 per distanza2*/
            distanza1 = distanza(rigacane1,colonnacane1,rigagatto1,colonnagatto1);
            distanza2 = distanza(rigacane1,colonnacane1,rigagatto2,colonnagatto2);

        /*Se la distanza1 è minore o uguale della distanza2 allora vuol dire che il gatto1 è più vicino (o distante uguale,
        ma per convenienza do precedenza al primo cane) al cane1
        Dunque richiamo movimentocane passandogli la posizione di cane1 e gatto1
        Nel caso opposto (cioè che la distanza minore è quella verso il secondo gatto, allora richiamo la stessa procedura
                          ma passando l'indice del gatto2*/
            if(distanza1<=distanza2){
                movimentocane1(scacchiera,&rigagatto1,&colonnagatto1,&rigacane1,&colonnacane1,&numgatti,&cane1su,&cane1giu,
                              &cane1destra,&cane1sinistra);
            }
            else{
                movimentocane1(scacchiera,&rigagatto2,&colonnagatto2,&rigacane1,&colonnacane1,&numgatti,
                              &cane1su,&cane1giu,&cane1destra,&cane1sinistra);
            }
            //faccio lo stesso procedimento per quanto riguarda il secondo cane
            distanza1 = distanza(rigacane2,colonnacane2,rigagatto1,colonnagatto1);
            distanza2 = distanza(rigacane2,colonnacane2,rigagatto2,colonnagatto2);
            if(distanza1<=distanza2){
                movimentocane2(scacchiera,&rigagatto1,&colonnagatto1,&rigacane2,&colonnacane2,&numgatti,
                              &cane2su,&cane2giu,&cane2destra,&cane2sinistra);
                if(numgatti == 2){
                    /*dopo i cani faccio muovere i gatti tenendo conto della variabile numgatti
                    Se è ancora uguale a 2 allora significa che nessun gatto è stato preso e posso richiamare
                    movimentogatto per entrambi i gatti*/
                    movimentogatto(scacchiera,righe,colonne, &rigagatto1,&colonnagatto1,&gatto1su,&gatto1giu,
                                   &gatto1destra,&gatto1sinistra);
                    movimentogatto(scacchiera,righe,colonne, &rigagatto2,&colonnagatto2, &gatto2su, &gatto2giu,
                                   &gatto2destra,&gatto2sinistra);
                }
                else{
                    /*Nel caso in cui numgatti è diventato 1 significa che un gatto è stato preso
                    Nota: per distinguere i due cani ed i due gatti
                    'G' indica il gatto1 e 'g' indica il gatto2
                    'C' indica il cane1 e 'c' indica il cane2

                    Quindi se numgatti è 1 E la matrice scacchiera con la posizione del gatto1 è 'G'
                    vuol dire che non è gatto1 ad esser stato preso e posso dunque procedere a chiamare la procedura
                    per muovere il gatto1

                    Qualora numgatti è 1, ma è la matrice scacchiera con l'indice del gatto2 ad essere 'g'
                    Allora è il gatto1 ad essere stato preso, mentre procedo a far muovere gatto2*/

                    if((numgatti == 1)&&(scacchiera[rigagatto1][colonnagatto1]== 'G'))
                    movimentogatto(scacchiera,righe,colonne, &rigagatto1,&colonnagatto1,&gatto1su,&gatto1giu,
                                   &gatto1destra,&gatto1sinistra);
                    if((numgatti == 1)&&(scacchiera[rigagatto2][colonnagatto2]== 'g'))
                    movimentogatto(scacchiera,righe,colonne, &rigagatto2,&colonnagatto2, &gatto2su, &gatto2giu,
                                   &gatto2destra,&gatto2sinistra);
                }
            }else{//nel caso in cui la distanza2 è minore di distanza1 si muoverà per primo il secondo cane
                movimentocane2(scacchiera,&rigagatto2,&colonnagatto2,&rigacane2,&colonnacane2,&numgatti,
                              &cane2su,&cane2giu,&cane2destra,&cane2sinistra);
                if(numgatti == 2){//stesso procedimento di riga 85-109
                    movimentogatto(scacchiera,righe,colonne, &rigagatto1,&colonnagatto1,&gatto1su,&gatto1giu,
                                   &gatto1destra,&gatto1sinistra);
                    movimentogatto(scacchiera,righe,colonne, &rigagatto2,&colonnagatto2, &gatto2su, &gatto2giu,
                                   &gatto2destra,&gatto2sinistra);
                }
                else{
                    if((numgatti == 1)&&(scacchiera[rigagatto1][colonnagatto1]== 'G'))
                    movimentogatto(scacchiera,righe,colonne, &rigagatto1,&colonnagatto1,&gatto1su,&gatto1giu,
                                   &gatto1destra,&gatto1sinistra);
                    if((numgatti == 1)&&(scacchiera[rigagatto2][colonnagatto2]== 'g'))
                    movimentogatto(scacchiera,righe,colonne, &rigagatto2,&colonnagatto2, &gatto2su, &gatto2giu,
                                   &gatto2destra,&gatto2sinistra);
                }
            }
        }else{/*nel caso in cui numgatti non è più uguale a 2 controllo quale gatto è stato preso
            I cani si muoveranno verso quello che non è stato preso (la distanza non è più necessaria
                                                                      siccome resta un solo gatto
                                                                      Per convenienza faccio sempre muovere il primo cane*/
            if(scacchiera[rigagatto1][colonnagatto1] == 'G'){
            movimentocane1(scacchiera,&rigagatto1,&colonnagatto1,&rigacane1,&colonnacane1, &numgatti,&cane1su,&cane1giu,
                          &cane1destra,&cane1sinistra);
            }
            else{
            movimentocane1(scacchiera,&rigagatto2,&colonnagatto2,&rigacane1,&colonnacane1, &numgatti,&cane1giu,&cane1su,
                          &cane1destra,&cane1sinistra);
            }
            if(scacchiera[rigagatto1][colonnagatto1] == 'G'){
            movimentocane2(scacchiera,&rigagatto1,&colonnagatto1,&rigacane2,&colonnacane2, &numgatti,
                          &cane2su,&cane2giu,&cane2destra,&cane2sinistra);
            if(numgatti == 1)
                movimentogatto(scacchiera,righe,colonne, &rigagatto1,&colonnagatto1,&gatto1su,&gatto1giu,
                                   &gatto1destra,&gatto1sinistra);/*
                faccio muovere il primo gatto se numgatti è uguale ad 1 e se la matrice scacchiera con l'indice del primo gatto
                ha come valore 'G', altrimenti vuol dire che è il gatto2 che non è stato ancora preso*/
            }
            else{
            movimentocane2(scacchiera,&rigagatto2,&colonnagatto2,&rigacane2,&colonnacane2, &numgatti,
                          &cane2su,&cane2giu,&cane2destra,&cane2sinistra);
            if(numgatti == 1)/*se dopo che i cani si sono mossi, numgatti è ancora 1, vuol dire che posso far muovere il gatto2*/
                movimentogatto(scacchiera,righe,colonne, &rigagatto2,&colonnagatto2, &gatto2su, &gatto2giu,
                                   &gatto2destra,&gatto2sinistra);
            }
        }
        Sleep(2000); /*la procedura sleep (della libreria windows.h) la utilizzo per rallentare l'esecuzione del programma
        di 2000 millisecondi (2 secondi)*/
        visualizzascacchiera(scacchiera,righe,colonne); //al termine di ogni movimento di tutti gli animali, stampo la scacchiera
        passi--;//decremento ogni volta i passi di 1
    };
    if(numgatti == 0){//altermine se numgatti è 0 significa che i gatti sono stati presi e l'utente ha vinto
        printf("I cani hanno preso i gatti! Hai vinto!\n");
    }else{
        printf("I passi massimi sono stati effettuati, ma i gatti non sono stati presi, hai perso!\n");/*altrimenti significa
        che i passi sono terminati e l'utente ha perso*/
    }

    //calcolo e stampo a video la percentuale dei movimenti di cani e gatti
    if(cane1su != 0)
        pcane1su = (cane1su*100)/(cane1su + cane1giu + cane1destra + cane1sinistra);
    if(cane1giu != 0)
        pcane1giu = (cane1giu*100)/(cane1su + cane1giu + cane1destra + cane1sinistra);
    if(cane1destra != 0)
        pcane1destra = (cane1destra*100)/(cane1su + cane1giu + cane1destra + cane1sinistra);
    if(cane1sinistra != 0)
        pcane1sinistra = (cane1sinistra*100)/(cane1su + cane1giu + cane1destra + cane1sinistra);

    printf("Il cane C si e' mosso:\nPer il %-.lf%% verso l'alto\nPer il %-.lf%% verso il basso\nPer il %-.lf%% verso destra\nPer il %-.lf%% verso sinistra\n\n",
           pcane1su,pcane1giu,pcane1destra,pcane1sinistra);

    if(cane2su != 0)
        pcane2su = (cane2su*100)/(cane2su + cane2giu + cane2destra + cane2sinistra);
    if(cane2giu != 0)
        pcane2giu = (cane2giu*100)/(cane2su + cane2giu + cane2destra + cane2sinistra);
    if(cane2destra != 0)
        pcane2destra = (cane2destra*100)/(cane2su + cane2giu + cane2destra + cane2sinistra);
    if(cane2sinistra != 0)
        pcane2sinistra = (cane2sinistra*100)/(cane2su + cane2giu + cane2destra + cane2sinistra);
    printf("Il cane c si e' mosso:\nPer il %-.lf%% verso l'alto\nPer il %-.lf%% verso il basso\nPer il %-.lf%% verso destra\nPer il %-.lf%% verso sinistra\n\n",
           pcane2su,pcane2giu,pcane2destra,pcane2sinistra);

    if(gatto1su != 0)
        pgatto1su =(gatto1su*100)/(gatto1su + gatto1giu + gatto1destra + gatto1sinistra);
    if(gatto1giu != 0)
        pgatto1giu =(gatto1giu*100)/(gatto1su + gatto1giu + gatto1destra + gatto1sinistra);
    if(gatto1destra != 0)
        pgatto1destra =(gatto1destra*100)/(gatto1su + gatto1giu + gatto1destra + gatto1sinistra);
    if(gatto1sinistra != 0)
        pgatto1sinistra =(gatto1sinistra*100)/(gatto1su + gatto1giu + gatto1destra + gatto1sinistra);

    printf("Il gatto G si e' mosso:\nPer il %-.lf%% verso l'alto\nPer il %-.lf%% verso il basso\nPer il %-.lf%% verso destra\nPer il %-.lf%% verso sinistra\n\n",
           pgatto1su,pgatto1giu,pgatto1destra,pgatto1sinistra);

    if(gatto2su != 0)
        pgatto2su = (gatto2su*100)/(gatto2su + gatto2giu + gatto2destra + gatto2sinistra);
    if(gatto2giu != 0)
        pgatto2giu = (gatto2giu*100)/(gatto2su + gatto2giu + gatto2destra + gatto2sinistra);
    if(gatto2destra != 0)
        pgatto2destra = (gatto2destra*100)/(gatto2su + gatto2giu + gatto2destra + gatto2sinistra);
    if(gatto2sinistra != 0)
        pgatto2sinistra = (gatto2sinistra*100)/(gatto2su + gatto2giu + gatto2destra + gatto2sinistra);

    printf("Il gatto g si e' mosso:\nPer il %-.lf%% verso l'alto\nPer il %-.lf%% verso il basso\nPer il %-.lf%% verso destra\nPer il %-.lf%% verso sinistra\n",
           pgatto2su,pgatto2giu,pgatto2destra,pgatto2sinistra);
}
/* La procedura dimscacchiera prende in ingresso i puntatori di righe e colonne per consentire all'utente di
inserire le dimensioni della scacchiera (utilizzo un do-while per evitare che l'utente inserisca numeri negativi
                                         o superiori al 100, dato che la dimensione massima della mia matrice é 100x100 */
void dimscacchiera(int *righe, int *colonne){
    printf("Inserisci il numero di righe della scacchiera per iniziare a giocare (compreso tra 2 e 100)\n");
    do{
        scanf("%d",righe);
    }while((*righe < 2) || (*righe > 100));
    printf("Inserisci il numero di colonne della scacchiera per iniziare a giocare (compreso tra 2 e 100)\n");
    do{
        scanf("%d",colonne);
    }while((*colonne < 2) || (*colonne > 100));
    printf("Hai creato una scacchiera con %d righe e %d colonne\n",*righe,*colonne);
}

/* Nella procedura passidaeffettuare chiedo all'utente il numero di passi massimo da effettuare prima di terminare il gioco*/
void passidaeffettuare(int *passi){
    printf("Inserisci quanti passi vuoi effettuare al massimo all'interno della scacchiera\n");
    scanf("%d",passi);
    printf("Hai deciso di effettuare %d passi\n", *passi);
}

/* Nella procedura inizializzazionescacchiera prendo in ingresso la scacchiera (array di char) e le sue dimensioni
Inizializzo tutto con un trattino(-) per comodità, prima di andare ad inserire i cani ed i gatti*/
void inizializzazionescacchiera(char scacchiera[][100], int righe, int colonne){
    int i,j;
    for(i = 0; i< righe; i++){
        for(j = 0; j < colonne; j++){
            scacchiera[i][j] = '-';
        }
    }
}
 /*Nella procedura cani_gatti, prendo la scacchiera inizializzata e, mediante due contatori, uno per i cani ed uno per i gatti,
 vado ad inserire in maniera casuale nella scacchiera prima i gatti e poi i cani.
 Utilizzo un IF innestato in un do-while
 Laddove nella posizione x vi è '-', allora inserisco 'G' per il gatto1 e 'g' per il gatto2 e 'C' per il cane1, 'c' per il cane2
 Il gioco utilizza 2 cani e 2 gatti, pertanto il contatore di cani e gatti è inizializzato a zero (0)
 e giunge fino a <1, cioè quando vengono fatte le quattro assegnazioni*/

/* la procedura prende in ingresso la matrice scacchiera con il numero di righe e colonne.
Inoltre prende gli indirizzi di memoria di righe e colonne dei 2 gatti e dei 2 cani e li metto nei rispettivi puntatori*/
void cani_gatti(char scacchiera[][100], int righe, int colonne, int* rigagatto1, int *colonnagatto1,
                int* rigagatto2, int *colonnagatto2, int* rigacane1, int* colonnacane1,
                int* rigacane2, int* colonnacane2){
    //int cgatto1 = 0;
    int cgatto2 = 0; //contatore gatto2
    int ccane1 = 0; //contatore cane1
    int ccane2 = 0; //contatore cane2
    int indiceriga, indicecolonna;//con queste due variabili locali genero man mano gli indici di riga e colonna per gatti e cani
    //do{
    indiceriga = rand()%righe;//genero un numero che va da 0 a righe-1
    indicecolonna = rand()%colonne;//genero un numero che va da 0 a colonne-1
    scacchiera[indiceriga][indicecolonna] = 'G';
    *rigagatto1 = indiceriga;//salvo nel puntatore gli indici di riga e colonna
    *colonnagatto1 = indicecolonna;

    /*per i 3 animali restanti ho bisogno di un do-while per ciascuno.
    Siccome necessito di controllare che l'elemento della matrice con gli indici generati random
    non sia occupata da un altro animale già, quindi sia uguale a '-'.
    Per questo rifaccio la generazione di righe e colonne causali fin quando
    scacchiera[indiceriga][indicecolonna] non è uguale a '-'*/

    do{
        indiceriga = rand()%righe;
        indicecolonna = rand()%colonne;
        if(scacchiera[indiceriga][indicecolonna] == '-'){
            scacchiera[indiceriga][indicecolonna] = 'g';
            cgatto2++;//incremento il contatore per uscire dal do-while
            *rigagatto2 = indiceriga;//salvo nel puntatore gli indici di riga e colonna
            *colonnagatto2 = indicecolonna;
        }
    }while(cgatto2 < 1);
    do{
        indiceriga = rand()%righe;
        indicecolonna = rand()%colonne;
        if(scacchiera[indiceriga][indicecolonna] == '-'){
            scacchiera[indiceriga][indicecolonna] = 'C';
            ccane1++;//incremento il contatore per uscire dal do-while
            *rigacane1 = indiceriga;//salvo nel puntatore gli indici di riga e colonna
            *colonnacane1 = indicecolonna;
        }
    }while(ccane1 < 1);
    do{
        indiceriga = rand()%righe;
        indicecolonna = rand()%colonne;
        if(scacchiera[indiceriga][indicecolonna] == '-'){
            scacchiera[indiceriga][indicecolonna] = 'c';
            *rigacane2 = indiceriga;//salvo nel puntatore gli indici di riga e colonna
            *colonnacane2 = indicecolonna;
            ccane2++;//incremento il contatore per uscire dal do-while
        }
    }while(ccane2 < 1);
}
/*In questa procedura che prende in input la matrice di char, le righe e le colonne,stampo a video la scacchiera*/
void visualizzascacchiera(char scacchiera[][100], int righe, int colonne){
    int i,j;
    for(i=0;i<righe;i++){
        for(j=0;j<colonne;j++){
            printf("%c", scacchiera[i][j]);//stampo a video il contenuto della matrice all'indice [i][j]
        }
        printf("\n");// con questo \n vado a capo ogni volta che termina una riga
    }
}

/*Questa procedura che prende input la matrice con il rispettivo indice e due puntatori agli indici di riga e colonna del gatto,
serve a far muovere in una delle 4 direzioni l'animale.
La scelta della direzione è random mediante il tipo enumerato: Direzione
Tiene però conto di alcune criticità riscontrate durante la programmazione:
1. Un gatto non può muoversi prima dell'indice 0 di riga e colonna (andrebbe fuori dalla matrice)
2. Un gatto non può muoversi dopo l'indice-1 di riga e colonna (andrebbe fuori dalla matrice)
3.Nel momento in cui un gatto si trova senza movimenti possibili (ovvero che tutte le possibili direzioni sono bloccate,
da indici della matrice o da cani e/o gatti, allora mi vedo costretto a non far muovere il gatto in questione ed ad uscire*/

void movimentogatto(char scacchiera[][100], int righe, int colonne, int *rigagatto, int *colonnagatto,
                    double *sopra, double *sotto, double *dx, double *sx){
    Direzione muovi;//variabile muovi del tipo enumerato Direzione
    int contamovimento = 0;//la utilizzo per il do-while, per tener conto di quando il gatto ha effettuato il movimento
    char appoggio; //con questa variabile scambierò gli indici quando viene effettuato un movimento del gatto
    int verificablocco[] = {0,0,0,0}; /* Utilizzo questo vettore per gestire il caso in cui un gatto non possa muoversi in nessuna
                                            delle 4 direzioni*/
    int interrompi = 0; //questa variabile la utilizzo nel momento in cui ogni direzione è bloccata, per uscire dal do-while
    do{
        muovi = rand()%4;//genero un numero random da 0 a 3
        if(muovi == su){//su è uguale a 2 nel tipo enumerato Direzione

            /*Se la riga-1 del gatto è maggiore di -1 e
            l'array scacchiera con l'indice della riga-1 e della colonna è uguale all'elemento '-'
            Allora procedo a scambiare 'G' o 'g' con '-' mediante la variabile appoggio*/
            if(((*rigagatto-1)> -1)&&(scacchiera[*rigagatto-1][*colonnagatto] == '-')){
                printf("Il gatto %c si sta muovendo verso su\n",scacchiera[*rigagatto][*colonnagatto]);
                appoggio = scacchiera[*rigagatto][*colonnagatto];
                scacchiera[*rigagatto][*colonnagatto] = scacchiera[*rigagatto-1][*colonnagatto];
                scacchiera[*rigagatto-1][*colonnagatto] = appoggio;
                *rigagatto = *rigagatto - 1;//il nuovo valore del puntatore alla riga del gatto diventa *rigagatto-1
                *sopra = *sopra +1;
                contamovimento++;//procedo ad incrementare il movimento per uscire dal do-while
            }
            else{//nel caso in cui entro nell'else vuol dire che la direzione SU è bloccata per il gatto in questione
                verificablocco[0] = -1;//il primo elemento del vettore che verifica il blocco viene messo uguale a -1
            }
        }
        if(muovi == giu){//giu è uguale a 3 nel tipo enumerato Direzione

            /*Se la riga+1 del gatto è minore delle righe della matrice e
            l'array scacchiera con l'indice della riga+1 e della colonna è uguale all'elemento '-'
            Allora procedo a scambiare 'G' o 'g' con '-' mediante la variabile appoggio*/
            if(((*rigagatto+1) < righe)&&(scacchiera[*rigagatto+1][*colonnagatto] == '-')){
                printf("Il gatto %c si sta muovendo verso giu\n",scacchiera[*rigagatto][*colonnagatto]);
                appoggio = scacchiera[*rigagatto][*colonnagatto];
                scacchiera[*rigagatto][*colonnagatto] = scacchiera[*rigagatto+1][*colonnagatto];
                scacchiera[*rigagatto+1][*colonnagatto] = appoggio;
                *rigagatto = *rigagatto + 1;//il nuovo valore del puntatore alla riga del gatto diventa *rigagatto+1
                *sotto = *sotto +1;
                contamovimento++;//procedo ad incrementare il movimento per uscire dal do-while
            }
            else{//nel caso in cui entro nell'else vuol dire che la direzione GIU è bloccata per il gatto in questione
                verificablocco[1] = -1;//il secondo elemento del vettore che verifica il blocco viene messo uguale a -1
            }
        }
        if(muovi == destra){//destra è uguale a 0 nel tipo enumerato Direzione

            /*Se la colonna+1 del gatto è maggiore delle colonne della matrice e
            l'array scacchiera con l'indice della riga e della colonna+1 è uguale all'elemento '-'
            Allora procedo a scambiare 'G' o 'g' con '-' mediante la variabile appoggio*/
            if(((*colonnagatto+1) < colonne)&&(scacchiera[*rigagatto][*colonnagatto+1] == '-')){
                printf("Il gatto %c si sta muovendo verso destra\n",scacchiera[*rigagatto][*colonnagatto]);
                appoggio = scacchiera[*rigagatto][*colonnagatto];
                scacchiera[*rigagatto][*colonnagatto] = scacchiera[*rigagatto][*colonnagatto+1];
                scacchiera[*rigagatto][*colonnagatto+1] = appoggio;
                *colonnagatto = *colonnagatto + 1;//il nuovo valore del puntatore alla colonna del gatto diventa *colonnagatto+1
                *dx = *dx +1;
                contamovimento++;//procedo ad incrementare il movimento per uscire dal do-while
            }
            else{//nel caso in cui entro nell'else vuol dire che la direzione DESTRA è bloccata per il gatto in questione
                verificablocco[2] = -1;//il terzo elemento del vettore che verifica il blocco viene messo uguale a -1
            }
        }
        if(muovi == sinistra){//sinistra è uguale a 1 nel tipo enumerato Direzione

            /*Se la colonna-1 del gatto è maggiore di -1 e
            l'array scacchiera con l'indice della riga e della colonna-1 è uguale all'elemento '-'
            Allora procedo a scambiare 'G' o 'g' con '-' mediante la variabile appoggio*/
            if(((*colonnagatto-1)>-1)&&(scacchiera[*rigagatto][*colonnagatto-1] == '-')){
                printf("Il gatto %c si sta muovendo verso sinistra\n",scacchiera[*rigagatto][*colonnagatto]);
                appoggio = scacchiera[*rigagatto][*colonnagatto];
                scacchiera[*rigagatto][*colonnagatto] = scacchiera[*rigagatto][*colonnagatto-1];
                scacchiera[*rigagatto][*colonnagatto-1] = appoggio;
                *colonnagatto = *colonnagatto -1;//il nuovo valore del puntatore alla colonna del gatto diventa *colonnagatto-1
                *sx = *sx+1;
                contamovimento++;//procedo ad incrementare il movimento per uscire dal do-while
            }
            else{//nel caso in cui entro nell'else vuol dire che la direzione SINISTRA è bloccata per il gatto in questione
                verificablocco[3] = -1;//il quarto elemento del vettore che verifica il blocco viene messo uguale a -1
            }
        }//qualora il gatto non si fosse mosso (contamovimento == 0) inizio a contare in quante direzioni ha provato a muoversi
        if(contamovimento == 0){
            /*se tutti i valori nel vettore verificablocco sono -1, incremento interrompi perchè vuol dire che non ci sono
            movimenti disponibili che il gatto in quel momento può effettuare.
            Al primo valore che non è -1 (==0) breakko il ciclo for per evitare di ciclare inutilmente su altri elementi*/
            for(int i=0;i<4;i++){
                if(verificablocco[i] == 0){
                    break;
                }
                else
                    interrompi++;
            }
            if(interrompi == 4){//se interrompi è 4 allora il gatto non può muoversi. Incremento contamovimento ed esco
                printf("Il gatto non puo' muoversi in nessuna delle 4 direzioni possibili\n");
                contamovimento = 1;
            }
            else
                interrompi = 0;//altrimenti vuol dire che vi sono ancora direzioni da controllare e setto interrompi a 0
        }
    }while(contamovimento < 1);
}
/*la procedura movimentocane prende in input la matrice con i rispettivi indici ed i puntatori alle righe e colonne di
un gatto e del cane1, oltre al puntatore di numgatti (variabile che verifica quanti gatti sono rimasti*/
void movimentocane1(char scacchiera[][100],int *rigagatto, int *colonnagatto,
                   int *rigacane, int *colonnacane, int* numgatti, double *su, double *giu, double *destra, double *sinistra){
    char appoggio;//utilizzo appoggio per scambiare qualora vi è un movimento, come nella procedura movimentogatti
    int contamovimento = 0;//anche qui utilizzo contamovimento per avviare il do-while
    /*Funzionamento
    Quando un cane prende un gatto, il cane prende il posto del gatto nella scacchiera.
    Il gatto invece sparisce.
    Nel momento in cui si muove verso il gatto, invece, dò priorità, per scelta personale, alle righe prima che alle colonne
    per quanto riguarda il cane1
    (Mi avvalgo dei break per interrompere il do-while appena un primo passo viene compiuto, impedendo al cane di
     compiere più movimenti in un solo ciclo)
    PER PRENDERE UN GATTO SOSTANZIALMENTE C'E' BISOGNO CHE, DOPO IL MOVIMENTO, GLI INDICI DI RIGHE DEL CANE E DEL GATTO
    DIVENTINO ESATTAMENTE UGUALI, STESSO DISCORSO PER LE COLONNE.
    Quindi:
    1. nel momento in cui la riga del cane è minore a quella del gatto, significa che il cane si muoverà verso il basso
    2. nel momento in cui la riga del cane è minore a quella del gatto, significa che il cane si muoverà verso sopra
    3. nel momento in cui la riga del cane è UGUALE a quella del gatto il cane:
    Si muoverà a destra se la colonna è minore di quella del gatto, a sinistra se maggiore di quella del gatto
    */
    do{
        //righe
        /*Se la riga del cane è minore di quella del gatto, ma lo stesso gatto ancora non è stato preso dopo il passo
        (cioè scacchiera[*rigacane+1][*colonnacane] è uguale a '-'
         Allora il cane si sta avvicinando verso il basso
         Con la variabile appoggio scambio i due elementi di scacchiera
         Aggiorno il puntatore di riga del cane
         Incremento il movimento per uscire dal do-while*/
        if((*rigacane < *rigagatto) && (scacchiera[*rigacane+1][*colonnacane] == '-')){
            printf("Il cane %c si muove verso il basso per avvicinarsi al gatto\n",scacchiera[*rigacane][*colonnacane]);
            appoggio = scacchiera[*rigacane][*colonnacane];
            scacchiera[*rigacane][*colonnacane] = scacchiera[*rigacane+1][*colonnacane];
            scacchiera[*rigacane+1][*colonnacane] = appoggio;
            *rigacane = *rigacane + 1;
            contamovimento++;
            *giu = *giu +1;
            break;
        }

        /*Se la riga del cane è minore di quella del gatto, e dopo il passo il gatto è stato preso
        (cioè scacchiera[*rigacane+1][*colonnacane] è uguale a 'G' o 'g'
         Allora il cane ha preso il gatto
         scacchiera[*rigacane+1][colonnacane] diventa il nuovo indice del cane, mentre il precedente diventa '-'
         Aggiorno il puntatore di riga del cane
         Decremento di uno il puntatore di numgatti
         Incremento il movimento per uscire dal do-while*/
        if((*rigacane < *rigagatto)&& ((scacchiera[*rigacane+1][*colonnacane] == 'G')||(scacchiera[*rigacane+1][*colonnacane] == 'g'))){
           printf("Il cane %c si e' mosso verso il basso ed ha preso il gatto %c!\n",
                  scacchiera[*rigacane][*colonnacane],scacchiera[*rigacane+1][*colonnacane]);
           scacchiera[*rigacane+1][*colonnacane] = scacchiera[*rigacane][*colonnacane];
           scacchiera[*rigacane][*colonnacane] = '-';
           *rigacane = *rigacane + 1;
           *numgatti = *numgatti -1;
           contamovimento++;
           *giu = *giu + 1;
           break;
        }

        /*Se la riga del cane è maggiore di quella del gatto, ma lo stesso gatto ancora non è stato preso dopo il passo
        (cioè scacchiera[*rigacane-1][*colonnacane] è uguale a '-'
         Allora il cane si sta avvicinando verso l'alto
         Con la variabile appoggio scambio i due elementi di scacchiera
         Aggiorno il puntatore di riga del cane
         Incremento il movimento per uscire dal do-while*/
        if((*rigacane > *rigagatto) && (scacchiera[*rigacane-1][*colonnacane] == '-')){
            printf("Il cane %c si muove verso l'alto per avvicinarsi al gatto\n",scacchiera[*rigacane][*colonnacane]);
            appoggio = scacchiera[*rigacane][*colonnacane];
            scacchiera[*rigacane][*colonnacane] = scacchiera[*rigacane-1][*colonnacane];
            scacchiera[*rigacane-1][*colonnacane] = appoggio;
            *rigacane = *rigacane - 1;
            contamovimento++;
            *su = *su +1;
            break;
        }

        /*Se la riga del cane è maggiore di quella del gatto, e dopo il passo il gatto è stato preso
        (cioè scacchiera[*rigacane-1][*colonnacane] è uguale a 'G' o 'g'
         Allora il cane ha preso il gatto
         scacchiera[*rigacane-1][colonnacane] diventa il nuovo indice del cane, mentre il precedente diventa '-'
         Aggiorno il puntatore di riga del cane
         Decremento di uno il puntatore di numgatti
         Incremento il movimento per uscire dal do-while*/
        if((*rigacane > *rigagatto)&& ((scacchiera[*rigacane-1][*colonnacane] == 'G')||(scacchiera[*rigacane-1][*colonnacane] == 'g'))){
           printf("Il cane %c si e' mosso verso l'alto ed ha preso il gatto %c!\n"
                  ,scacchiera[*rigacane][*colonnacane],scacchiera[*rigacane-1][*colonnacane]);
           scacchiera[*rigacane-1][*colonnacane] = scacchiera[*rigacane][*colonnacane];
           scacchiera[*rigacane][*colonnacane] = '-';
           *rigacane = *rigacane - 1;
           *numgatti = *numgatti -1;
           contamovimento++;
           *su = *su +1;
           break;
        }
        //colonne

        /*Se la colonna del cane è minore di quella del gatto, ma lo stesso gatto ancora non è stato preso dopo il passo
        (cioè scacchiera[*rigacane][*colonnacane+1] è uguale a '-'
         Allora il cane si sta avvicinando verso destra
         Con la variabile appoggio scambio i due elementi di scacchiera
         Aggiorno il puntatore di colonna del cane
         Incremento il movimento per uscire dal do-while*/
         if((*colonnacane < *colonnagatto) && (scacchiera[*rigacane][*colonnacane+1] == '-')){
            printf("Il cane %c si muove verso destra per avvicinarsi al gatto\n",scacchiera[*rigacane][*colonnacane]);
            appoggio = scacchiera[*rigacane][*colonnacane];
            scacchiera[*rigacane][*colonnacane] = scacchiera[*rigacane][*colonnacane+1];
            scacchiera[*rigacane][*colonnacane+1] = appoggio;
            *colonnacane = *colonnacane + 1;
            contamovimento++;
            *destra = *destra +1;
            break;
        }

        /*Se la colonna del cane è minore di quella del gatto, e dopo il passo il gatto è stato preso
        (cioè scacchiera[*rigacane][*colonnacane+1] è uguale a 'G' o 'g'
         Allora il cane ha preso il gatto
         scacchiera[*rigacane][colonnacane+1] diventa il nuovo indice del cane, mentre il precedente diventa '-'
         Aggiorno il puntatore di colonna del cane
         Decremento di uno il puntatore di numgatti
         Incremento il movimento per uscire dal do-while*/
        if((*colonnacane < *colonnagatto)&& ((scacchiera[*rigacane][*colonnacane+1] == 'G')||(scacchiera[*rigacane][*colonnacane+1] == 'g'))){
           printf("Il cane %c si e' mosso verso destra ed ha preso il gatto %c!\n",
                  scacchiera[*rigacane][*colonnacane],scacchiera[*rigacane][*colonnacane+1]);
           scacchiera[*rigacane][*colonnacane+1] = scacchiera[*rigacane][*colonnacane];
           scacchiera[*rigacane][*colonnacane] = '-';
           *colonnacane = *colonnacane + 1;
           *numgatti = *numgatti -1;
           contamovimento++;
           *destra = *destra+1;
           break;
        }

        /*Se la colonna del cane è maggiore di quella del gatto, ma lo stesso gatto ancora non è stato preso dopo il passo
        (cioè scacchiera[*rigacane][*colonnacane-1] è uguale a '-'
         Allora il cane si sta avvicinando verso sinistra
         Con la variabile appoggio scambio i due elementi di scacchiera
         Aggiorno il puntatore di colonna del cane
         Incremento il movimento per uscire dal do-while*/
        if((*colonnacane > *colonnagatto) && (scacchiera[*rigacane][*colonnacane-1]== '-')){
            printf("Il cane %c si muove verso sinistra per avvicinarsi al gatto\n",scacchiera[*rigacane][*colonnacane]);
            appoggio = scacchiera[*rigacane][*colonnacane];
            scacchiera[*rigacane][*colonnacane] = scacchiera[*rigacane][*colonnacane-1];
            scacchiera[*rigacane][*colonnacane-1] = appoggio;
            *colonnacane = *colonnacane - 1;
            contamovimento++;
            *sinistra = *sinistra +1;
            break;
        }

         /*Se la colonna del cane è maggiore di quella del gatto, e dopo il passo il gatto è stato preso
        (cioè scacchiera[*rigacane][*colonnacane-1] è uguale a 'G' o 'g'
         Allora il cane ha preso il gatto
         scacchiera[*rigacane][colonnacane-1] diventa il nuovo indice del cane, mentre il precedente diventa '-'
         Aggiorno il puntatore di colonna del cane
         Decremento di uno il puntatore di numgatti
         Incremento il movimento per uscire dal do-while*/
        if((*colonnacane > *colonnagatto)&& ((scacchiera[*rigacane][*colonnacane-1] == 'G')||(scacchiera[*rigacane][*colonnacane-1] == 'g'))){
           printf("Il cane %c si e' mosso verso sinistra ed ha preso il gatto %c!\n",
                scacchiera[*rigacane][*colonnacane],scacchiera[*rigacane][*colonnacane-1]);
           scacchiera[*rigacane][*colonnacane-1] = scacchiera[*rigacane][*colonnacane];
           scacchiera[*rigacane][*colonnacane] = '-';
           *colonnacane = *colonnacane - 1;
           *numgatti = *numgatti-1;
           contamovimento++;
           *sinistra = *sinistra +1;
           break;
        }
        break;
    }while(contamovimento<1);
}

/*la procedura movimentocane prende in input la matrice con i rispettivi indici ed i puntatori alle righe e colonne di
un gatto e del cane2, oltre al puntatore di numgatti (variabile che verifica quanti gatti sono rimasti*/
void movimentocane2(char scacchiera[][100],int *rigagatto, int *colonnagatto,
                   int *rigacane, int *colonnacane, int* numgatti, double *su, double *giu, double *destra, double *sinistra){
    char appoggio;//utilizzo appoggio per scambiare qualora vi è un movimento, come nella procedura movimentogatti
    int contamovimento = 0;//anche qui utilizzo contamovimento per avviare il do-while
    /*Funzionamento
    Quando un cane prende un gatto, il cane prende il posto del gatto nella scacchiera.
    Il gatto invece sparisce.
    Nel momento in cui si muove verso il gatto, invece, dò priorità, per scelta personale, alle colonne prima che alle righe
    per quanto riguarda il cane2
    (Mi avvalgo dell'utilizzo dei break per interrompere il do-while appena un primo passo viene compiuto, impedendo al cane2 di
     compiere più movimenti in un solo ciclo)
    PER PRENDERE UN GATTO SOSTANZIALMENTE C'E' BISOGNO CHE, DOPO IL MOVIMENTO, GLI INDICI DI RIGHE DEL CANE E DEL GATTO
    DIVENTINO ESATTAMENTE UGUALI, STESSO DISCORSO PER LE COLONNE.
    Quindi:
    1. nel momento in cui la riga del cane è minore a quella del gatto, significa che il cane si muoverà verso il basso
    2. nel momento in cui la riga del cane è minore a quella del gatto, significa che il cane si muoverà verso sopra
    3. nel momento in cui la riga del cane è UGUALE a quella del gatto il cane:
    Si muoverà a destra se la colonna è minore di quella del gatto, a sinistra se maggiore di quella del gatto
    */
    do{
        //colonne

        /*Se la colonna del cane è minore di quella del gatto, ma lo stesso gatto ancora non è stato preso dopo il passo
        (cioè scacchiera[*rigacane][*colonnacane+1] è uguale a '-'
         Allora il cane si sta avvicinando verso destra
         Con la variabile appoggio scambio i due elementi di scacchiera
         Aggiorno il puntatore di colonna del cane
         Incremento il movimento per uscire dal do-while*/
         if((*colonnacane < *colonnagatto) && (scacchiera[*rigacane][*colonnacane+1] == '-')){
            printf("Il cane %c si muove verso destra per avvicinarsi al gatto\n",scacchiera[*rigacane][*colonnacane]);
            appoggio = scacchiera[*rigacane][*colonnacane];
            scacchiera[*rigacane][*colonnacane] = scacchiera[*rigacane][*colonnacane+1];
            scacchiera[*rigacane][*colonnacane+1] = appoggio;
            *colonnacane = *colonnacane + 1;
            contamovimento++;
            *destra = *destra +1;
            break;
        }

        /*Se la colonna del cane è minore di quella del gatto, e dopo il passo il gatto è stato preso
        (cioè scacchiera[*rigacane][*colonnacane+1] è uguale a 'G' o 'g'
         Allora il cane ha preso il gatto
         scacchiera[*rigacane][colonnacane+1] diventa il nuovo indice del cane, mentre il precedente diventa '-'
         Aggiorno il puntatore di colonna del cane
         Decremento di uno il puntatore di numgatti
         Incremento il movimento per uscire dal do-while*/
        if((*colonnacane < *colonnagatto)&& ((scacchiera[*rigacane][*colonnacane+1] == 'G')||(scacchiera[*rigacane][*colonnacane+1] == 'g'))){
           printf("Il cane %c si e' mosso verso destra ed ha preso il gatto %c!\n",
                  scacchiera[*rigacane][*colonnacane],scacchiera[*rigacane][*colonnacane+1]);
           scacchiera[*rigacane][*colonnacane+1] = scacchiera[*rigacane][*colonnacane];
           scacchiera[*rigacane][*colonnacane] = '-';
           *colonnacane = *colonnacane + 1;
           *numgatti = *numgatti -1;
           contamovimento++;
           *destra = *destra+1;
           break;
        }

        /*Se la colonna del cane è maggiore di quella del gatto, ma lo stesso gatto ancora non è stato preso dopo il passo
        (cioè scacchiera[*rigacane][*colonnacane-1] è uguale a '-'
         Allora il cane si sta avvicinando verso sinistra
         Con la variabile appoggio scambio i due elementi di scacchiera
         Aggiorno il puntatore di colonna del cane
         Incremento il movimento per uscire dal do-while*/
        if((*colonnacane > *colonnagatto) && (scacchiera[*rigacane][*colonnacane-1]== '-')){
            printf("Il cane %c si muove verso sinistra per avvicinarsi al gatto\n",scacchiera[*rigacane][*colonnacane]);
            appoggio = scacchiera[*rigacane][*colonnacane];
            scacchiera[*rigacane][*colonnacane] = scacchiera[*rigacane][*colonnacane-1];
            scacchiera[*rigacane][*colonnacane-1] = appoggio;
            *colonnacane = *colonnacane - 1;
            contamovimento++;
            *sinistra = *sinistra +1;
            break;
        }

         /*Se la colonna del cane è maggiore di quella del gatto, e dopo il passo il gatto è stato preso
        (cioè scacchiera[*rigacane][*colonnacane-1] è uguale a 'G' o 'g'
         Allora il cane ha preso il gatto
         scacchiera[*rigacane][colonnacane-1] diventa il nuovo indice del cane, mentre il precedente diventa '-'
         Aggiorno il puntatore di colonna del cane
         Decremento di uno il puntatore di numgatti
         Incremento il movimento per uscire dal do-while*/
        if((*colonnacane > *colonnagatto)&& ((scacchiera[*rigacane][*colonnacane-1] == 'G')||(scacchiera[*rigacane][*colonnacane-1] == 'g'))){
           printf("Il cane %c si e' mosso verso sinistra ed ha preso il gatto %c!\n",
                scacchiera[*rigacane][*colonnacane],scacchiera[*rigacane][*colonnacane-1]);
           scacchiera[*rigacane][*colonnacane-1] = scacchiera[*rigacane][*colonnacane];
           scacchiera[*rigacane][*colonnacane] = '-';
           *colonnacane = *colonnacane - 1;
           *numgatti = *numgatti-1;
           contamovimento++;
           *sinistra = *sinistra +1;
           break;
        }

        //righe
        /*Se la riga del cane è minore di quella del gatto, ma lo stesso gatto ancora non è stato preso dopo il passo
        (cioè scacchiera[*rigacane+1][*colonnacane] è uguale a '-'
         Allora il cane si sta avvicinando verso il basso
         Con la variabile appoggio scambio i due elementi di scacchiera
         Aggiorno il puntatore di riga del cane
         Incremento il movimento per uscire dal do-while*/
        if((*rigacane < *rigagatto) && (scacchiera[*rigacane+1][*colonnacane] == '-')){
            printf("Il cane %c si muove verso il basso per avvicinarsi al gatto\n",scacchiera[*rigacane][*colonnacane]);
            appoggio = scacchiera[*rigacane][*colonnacane];
            scacchiera[*rigacane][*colonnacane] = scacchiera[*rigacane+1][*colonnacane];
            scacchiera[*rigacane+1][*colonnacane] = appoggio;
            *rigacane = *rigacane + 1;
            contamovimento++;
            *giu = *giu +1;
            break;
        }

        /*Se la riga del cane è minore di quella del gatto, e dopo il passo il gatto è stato preso
        (cioè scacchiera[*rigacane+1][*colonnacane] è uguale a 'G' o 'g'
         Allora il cane ha preso il gatto
         scacchiera[*rigacane+1][colonnacane] diventa il nuovo indice del cane, mentre il precedente diventa '-'
         Aggiorno il puntatore di riga del cane
         Decremento di uno il puntatore di numgatti
         Incremento il movimento per uscire dal do-while*/
        if((*rigacane < *rigagatto)&& ((scacchiera[*rigacane+1][*colonnacane] == 'G')||(scacchiera[*rigacane+1][*colonnacane] == 'g'))){
           printf("Il cane %c si e' mosso verso il basso ed ha preso il gatto %c!\n",
                  scacchiera[*rigacane][*colonnacane],scacchiera[*rigacane+1][*colonnacane]);
           scacchiera[*rigacane+1][*colonnacane] = scacchiera[*rigacane][*colonnacane];
           scacchiera[*rigacane][*colonnacane] = '-';
           *rigacane = *rigacane + 1;
           *numgatti = *numgatti -1;
           contamovimento++;
           *giu = *giu + 1;
           break;
        }

        /*Se la riga del cane è maggiore di quella del gatto, ma lo stesso gatto ancora non è stato preso dopo il passo
        (cioè scacchiera[*rigacane-1][*colonnacane] è uguale a '-'
         Allora il cane si sta avvicinando verso l'alto
         Con la variabile appoggio scambio i due elementi di scacchiera
         Aggiorno il puntatore di riga del cane
         Incremento il movimento per uscire dal do-while*/
        if((*rigacane > *rigagatto) && (scacchiera[*rigacane-1][*colonnacane] == '-')){
            printf("Il cane %c si muove verso l'alto per avvicinarsi al gatto\n",scacchiera[*rigacane][*colonnacane]);
            appoggio = scacchiera[*rigacane][*colonnacane];
            scacchiera[*rigacane][*colonnacane] = scacchiera[*rigacane-1][*colonnacane];
            scacchiera[*rigacane-1][*colonnacane] = appoggio;
            *rigacane = *rigacane - 1;
            contamovimento++;
            *su = *su +1;
            break;
        }

        /*Se la riga del cane è maggiore di quella del gatto, e dopo il passo il gatto è stato preso
        (cioè scacchiera[*rigacane-1][*colonnacane] è uguale a 'G' o 'g'
         Allora il cane ha preso il gatto
         scacchiera[*rigacane-1][colonnacane] diventa il nuovo indice del cane, mentre il precedente diventa '-'
         Aggiorno il puntatore di riga del cane
         Decremento di uno il puntatore di numgatti
         Incremento il movimento per uscire dal do-while*/
        if((*rigacane > *rigagatto)&& ((scacchiera[*rigacane-1][*colonnacane] == 'G')||(scacchiera[*rigacane-1][*colonnacane] == 'g'))){
           printf("Il cane %c si e' mosso verso l'alto ed ha preso il gatto %c!\n"
                  ,scacchiera[*rigacane][*colonnacane],scacchiera[*rigacane-1][*colonnacane]);
           scacchiera[*rigacane-1][*colonnacane] = scacchiera[*rigacane][*colonnacane];
           scacchiera[*rigacane][*colonnacane] = '-';
           *rigacane = *rigacane - 1;
           *numgatti = *numgatti -1;
           contamovimento++;
           *su = *su +1;
           break;
        }
        break;
    }while(contamovimento<1);
}

/*questa function prende in input l'indice di riga e colonna del cane e del gatto per restituire alla chiamante un double
Utilizzando le funzioni sqrt e pow di math.h vado a calcolare la distanza tra un cane ed un gatto in forma matematica
(x2-x1)^2 + (y2-y1)^2 tutto sotto radice*/
double distanza(int rigacane, int colonnacane, int rigagatto, int colonnagatto){
    double dis;
    dis = pow((rigacane+1) - (rigagatto+1),2.0) + pow((colonnacane+1) - (colonnagatto+1), 2.0);
    dis = sqrt(dis);
    return dis;
}