/* ------------------------------------------------
   conqter.c            v. 1.02         23/02/2017
   ------------------------------------------------
   Descrizione:         Conquista del territorio
   Autore:              Improta Nicola
   Matricola:           0124001479
   ------------------------------------------------ */


/* --------------------------------
   Definizione librerie
   -------------------------------- */


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


/* --------------------------------
   Definizione costanti
   -------------------------------- */


#define NUM_GIOCATORI   3
#define EXIT_SUCCESS    0                   /* Programma eseguito con successo */


/* --------------------------------
   Definizione strutture dati
   -------------------------------- */


struct giocatore                            /* Struttura dati dei giocatori */
{
    char            nome[20];
    char            cognome[20];
    char            colore[5];
    unsigned int    idGioc;
    unsigned int    punteggio;
};


/* --------------------------------
   Definizione varibili globali
   -------------------------------- */


struct giocatore vet[NUM_GIOCATORI];        /* Dati dei giocatori */
unsigned int mappa[4][4];                   /* Mappa */
unsigned int classif[NUM_GIOCATORI];        /* Punt Classifica */
unsigned int posiz[NUM_GIOCATORI];          /* Posizioni classifica */


/* --------------------------------------------------------
   Nome:                INITVAR
   Descrizione:         Inizializzazione variabili
   Var. di ingresso:    Nessuna
   Var. di uscita:      Nessuna
   Ritorno funzione:    Nessuno
   -------------------------------------------------------- */


void INITVAR ()
{
    unsigned int i, j;

    /* Inizializzazione mappa */
    for (i=1;i<=4;i++)
        mappa[i][j] = 0;

    /* Inizializzazione dati giocatori          */
    strcpy( vet[0].nome, "Nome 1");
    strcpy( vet[0].cognome, "Cognome 1");
    strcpy( vet[0].colore, "Rosso");
    vet[0].idGioc    =  1;
    vet[0].punteggio =  0;

    strcpy( vet[1].nome, "Nome 2");
    strcpy( vet[1].cognome, "Cognome 2");
    strcpy( vet[1].colore, "Blu");
    vet[1].idGioc    =  2;
    vet[1].punteggio =  0;

    strcpy( vet[2].nome, "Nome 3");
    strcpy( vet[2].cognome, "Cognome 3");
    strcpy( vet[2].colore, "Verde");
    vet[2].idGioc    =  3;
    vet[0].punteggio =  0;

	/* Inizializza generatore di numeri casuali */
	srand(time(NULL));
}


/* --------------------------------------------------------
   Nome:                INPUTGIOCATORE
   Descrizione:         Legge dati giocatori da console
   Var. di ingresso:    Nessuna
   Var. di uscita:      struct giocatore vet[NUM_GIOCATORI]
   Ritorno funzione:    Nessuno
   -------------------------------------------------------- */


void INPUTGIOCATORI ()
{
    unsigned int i;

    printf("Corso di Laurea in Informatica\n");
    printf("Anno Accademico 2016-2017\n");
    printf("Corso di Programmazione I e Laboratorio Programmazione I\n");
    printf("--------------------------------------------------------\n");
    printf("Progetto di Esame di Laboratorio\n");
    printf("Conquista del territorio\n");
    printf("--------------------------------------------------------\n");
    printf("Autore:    IMPROTA Nicola\n");
    printf("Matricola: 0124001479\n");
    printf("--------------------------------------------------------\n\n");

    printf("Inserire nome e cognome dei giocatori.\n\n");

    for(i=1;i<= NUM_GIOCATORI;i++)
    {
        printf("Giocatore %d - Colore %s\n",i, vet[i-1].colore);

        printf("Inserisci il Cognome: ");
        scanf("%s",vet[i-1].cognome);

        printf("Inserisci il Nome: ");
        scanf("%s",vet[i-1].nome);

        printf("\n");
    }
}


/* --------------------------------------------------------
   Nome:                CREAMAPPA
   Descrizione:         Crea campo di gioco come mappa 4x4
   Var. di ingresso:    Nessuna
   Var. di uscita:      unsigned int mappa[4][4];
   Ritorno funzione:    Nessuno
   -------------------------------------------------------- */


void CREAMAPPA ()
{
    /* per il momento una mappa fissa. Deve essere generata random */

    mappa[0][0] = 1;
    mappa[0][1] = 1;
    mappa[0][2] = 1;
    mappa[0][3] = 3;

    mappa[1][0] = 1;
    mappa[1][1] = 1;
    mappa[1][2] = 1;
    mappa[1][3] = 3;

    mappa[2][0] = 2;
    mappa[2][1] = 2;
    mappa[2][2] = 3;
    mappa[2][3] = 3;

    mappa[3][0] = 2;
    mappa[3][1] = 2;
    mappa[3][2] = 3;
    mappa[3][3] = 3;
}


/* ----------------------------------------------------------------------------
   Nome:                GIOCA
   Descrizione:         gioca partita singola, aggiorna la mappa
                        e incrementa punteggio vincitore
   Var. di ingresso:    Nessuna
   Var. di uscita:      struct giocatore vet[NUM_GIOCATORI];
                        unsigned int mappa[4][4];
   Ritorno funzione:    Nessuno
   ---------------------------------------------------------------------------- */


void GIOCA ()
{
    /* contatori cicli */
    unsigned int i, j;

    /* Indice Attaccante, Difensore, Vincitore, Perdente
       =1 per giocatore 1, =2 per giocatore 2, =3 per giocatore 3 */
    unsigned int indAtt, indDif, indVin, indPer;

    /* risultato lancio del dado Attaccante, Difensore */
    unsigned int dadoAtt, dadoDif;

    /* init variabili */
    indAtt = 0;
    indDif = 0;
    indVin = 0;
    indPer = 0;

    dadoAtt = 0;
    dadoDif = 0;

    /* Sceglie a caso il primo attaccante */
    indAtt = rand()%3+1;
	switch(indAtt){
		case 1:
			printf("l'attaccante e' il rosso\n");
			break;
		case 2:
			printf("l'attaccante e' il verde\n");
			break;
		case 3:
			printf("l'attaccante e' il blu\n");
			break;
	}
    /* Sceglie un difensore contiguo */
    i = 0;
    while ((i<4) && (indDif == 0))
    {
        j = 0;
        while ((j<4) && (indDif == 0))
        {
            if (mappa[i][j] == indAtt)
            /* trovato cella attaccante, cerco il difensore contiguo */
            {
				if ((j>0) && (mappa[i][j-1] != indAtt))
                {
                    indDif = mappa[i][j-1];
                }
 				else if ((j<3) && (mappa[i][j+1] != indAtt))
                {
                    indDif = mappa[i][j+1];
                }
                else if ((i>0) && (mappa[i-1][j] != indAtt))
                {
                    indDif = mappa[i-1][j];
                }
                else if ((i<3) && (mappa[i+1][j] != indAtt))
                {
                    indDif = mappa[i+1][j];
                }
            }
            j++;
        }
        i++;
    }

    /* Primo Lancio dadi */
    dadoAtt = rand()%6 + 1;
    dadoDif = rand()%6 + 1;

    if (dadoAtt > dadoDif)
    {
    	printf("ha vinto l'attaccante\n\n");
        /* ha vinto l attaccante */
        indVin = indAtt;
        indPer = indDif;
    }
    else
    {
    	printf("ha vinto il difensore\n\n");
        /* ha vinto il difensore */
        indVin = indDif;
        indPer = indAtt;
    }

    /* Il vincitore conquista i territori del perdente */
    for (i=0; i<4; i++)
    {
        for (j=0; j<4; j++)
        {
            if (mappa[i][j] == indPer)
            {
                mappa[i][j] = indVin;
            }
        }
    }

    /* Il primo vincitore é il secondo attaccante */
    indAtt = indVin;
    indDif = 6 - indVin - indPer;

    /* Secondo Lancio dadi */
    dadoAtt = rand()%6 + 1;
    dadoDif = rand()%6 + 1;

    if (dadoAtt > dadoDif)
    {
        /* ha vinto l attaccante */
        indVin = indAtt;
        indPer = indDif;
    }
    else
    {
        /* ha vinto il difensore */
        indVin = indDif;
        indPer = indAtt;
    }

    /* Il vincitore conquista i territori del perdente */
    for (i=0; i<4; i++)
    {
        for (j=0; j<4; j++)
        {
            if (mappa[i][j] == indPer)
            {
                mappa[i][j] = indVin;
            }
        }
    }

    /* Incrementa punteggio vincitore */
    vet[indVin-1].punteggio++;
}


/* --------------------------------------------------------
   Nome:                CLASSIFICA
   Descrizione:         Calcola classifica e la manda a video
   Var. di ingresso:    Nessuna
   Var. di uscita:      Nessuna
   Ritorno funzione:    Nessuno
   -------------------------------------------------------- */


void CLASSIFICA()
{
	unsigned int ii, jj;
    unsigned int max, temp;

    for (ii=0; ii<3; ii++)
    {
        classif[ii] = vet[ii].punteggio;
        posiz[ii] = ii;
    }

    for (ii=0; ii<2; ii++)
    {
        max = ii;

	    for (jj=ii+1; jj<3; jj++)
	    {
	        if (classif[jj] > classif[max])
	        {
                max = jj;
            }
        }

	    temp         = classif[max];
        classif[max] = classif[ii];
        classif[ii]  = temp;

        temp         = posiz[max];
        posiz[max]   = posiz[ii];
        posiz[ii]    = temp;

    }

	printf("1. Posto - Giocatore %d - Colore %s - Punti %d\n", posiz[0]+1, vet[posiz[0]].colore, vet[posiz[0]].punteggio);
	printf("2. Posto - Giocatore %d - Colore %s - Punti %d\n", posiz[1]+1, vet[posiz[1]].colore, vet[posiz[1]].punteggio);
	printf("3. Posto - Giocatore %d - Colore %s - Punti %d\n", posiz[2]+1, vet[posiz[2]].colore, vet[posiz[2]].punteggio);

}


/* --------------------------------------------------------
   Nome:                main
   Descrizione:         Main programma applicativo
   Var. di ingresso:    Nessuna
   Var. di uscita:      Nessuna
   Ritorno funzione:    EXIT_SUCCESS se esecuzione corretta
   -------------------------------------------------------- */


int main ()
{
    unsigned int kk;

    INITVAR();
    INPUTGIOCATORI();

    for (kk=1; kk<=100; kk++)
    {
        CREAMAPPA();
        GIOCA();
    }

    CLASSIFICA();

    kk = kk; /* per mettere breakpoint */

    return EXIT_SUCCESS;
}