Joc Domino

/*##############################################################################
# Alumne: Octavi Allué Fonoll (1224997)                                        #
# Data: 09/05/09 14:02                                                         #
# Descripció: El joc del dominó, projecte final de MTP1                        #
##############################################################################*/

/* Llibrerires utilitzades                                                    */

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

/* Constants definides                                                        */

#define MAX_JUGADORS 4

/* Estructures de dades                                                       */

typedef enum {
    FITXA_VERTICAL = 0,
    FITXA_DRETA = 1,
    FITXA_ESQUERRA = 2
} ePosicio;

typedef enum {
    ESQUERRA = 0,
    DRETA = 1
} eCostat;

typedef struct {
    int superior, inferior;
    ePosicio pos;
} tFitxa;

typedef struct stNode {
    tFitxa info;
    struct stNode *seg;
} tNode;

typedef struct {
    tNode *cap;
} tPila;

typedef struct {
    tNode *esquerra, *dreta;
} tPartida;

typedef struct {
    tNode *primer;
} tLlista;

typedef struct {
    char nom[50];
    int actiu;
    tNode *fitxes;
} tJugador;

/* Altres funcions                                                            */

void intercanvia (char *a, char *b, int length) {
    char *aux;
    int i;
    aux = (char*) malloc (length);
    for (i = 0; i < length; ++i) {
        aux[i] = a[i];
        a[i] = b[i];
        b[i] = aux[i];
    }
    free(aux);
}

/* Procediments i funcions per el tractament d'estructures de dades           */

void iniciarPila (tPila *p) {
    /* Inicia la pila */
    p->cap = NULL;
}

int esBuidaPila (tPila *p) {
    return(p->cap == NULL);
}

int push (tPila *p, tNode x) {
    /* Insereix un node a la pila */
    tNode *q;
    q = (tNode*) malloc (sizeof(tNode));
    if (q != NULL) {
        q->info.superior = x.info.superior;
        q->info.inferior = x.info.inferior;
        q->info.pos = x.info.pos;
        q->seg = p->cap;
        p->cap = q;
    }
    return(q != NULL);
}

tNode pop (tPila *p) {
    /* Retorna el node superior de la pila i lliberar memòria */
    tNode *q;
    tNode x;
    q = p->cap;
    x.info.superior = q->info.superior;
    x.info.inferior = q->info.inferior;
    x.info.pos = q->info.pos;
    p->cap = p->cap->seg;
    free(q);
    return(x);
}

void iniciarLlista (tNode **llista) {
    /* Inicia la llista */
    (*llista) = NULL;
}

void primerLlista (tNode **iterador, tNode *llista) {
    /* Col·loca l'iterador de la llista en primera posició de la llista */
    (*iterador) = llista;
}

void seguentLlista (tNode *llista, tNode **iterador) {
    /* Avança l'iterador de la llista una posició */
    if ((*iterador) != NULL) {
        (*iterador) = (*iterador)->seg;
    }
}

int inserirLlista (tNode **llista, tNode *iterador, tNode x) {
    /* Insereix a la llista el node x */
    tNode *q;
    q = (tNode*) malloc (sizeof(tNode));
    if (q != NULL) {
        q->info.superior = x.info.superior;
        q->info.inferior = x.info.inferior;
        q->info.pos = x.info.pos;
        if (iterador == NULL) { /* Insereix en primera posició */
            q->seg = (*llista);
            (*llista) = q;
        }
        else { /* Insereix en la posició següent a l'iterador */
            q->seg = iterador->seg;
            iterador->seg = q;
        }
    }
    return(q != NULL);
}

void eliminarLlista (tNode **llista, tNode *iterador, tNode *x) {
    /* Treu de la llista el node següent a l'apuntat per l'iterador */
    tNode *q;
    if (iterador == NULL) { /* Elimina el primer node de la llista */
        q = (*llista);
        (*llista) = (*llista)->seg;
    }
    else {
        q = iterador->seg;
        iterador->seg = q->seg;
    }
    *x = *q;
    free(q);
}

tNode elementLlista (tNode *iterador) {
    /* Selecciona un element de la llista */
    tNode x;
    x.info.superior = iterador->info.superior;
    x.info.inferior = iterador->info.inferior;
    x.info.pos = iterador->info.pos;
    return(x);
}

int esBuidaLlista (tNode *llista) {
    return(llista == NULL);
}

/* Funcions pròpies del joc                                                   */

void introduir_jugadors (tJugador *jugador) {
    int nJugadors;
    int i;
    char n[50];
    printf("Introdueix el nombre de jugadors que juga la partida: ");
    scanf("%d", &nJugadors); printf("\n");
    while (nJugadors > MAX_JUGADORS || nJugadors <= 1) {
        printf("El nombre de jugadors permesos es d'entre 2 i 4.\n");
        printf("Introdueix el nombre de jugadors que juga la partida: ");
        scanf("%d", &nJugadors); printf("\n");
    }
    i = 0;
    while (i < nJugadors) {
        printf("Escriu el nom del jugador %d: ", i+1);
        scanf("%s", n);
        strcpy(jugador[i].nom, n);
        jugador[i].actiu = 1;
        iniciarLlista(&jugador[i].fitxes);
        i++;
    }
    printf("\n");
    while (i < MAX_JUGADORS-1) {
        strcpy(jugador[i].nom, "");
        jugador[i].actiu = 0;
        iniciarLlista(&jugador[i].fitxes);
        i++;
    }
}

tPila obtenir_fitxes_barrejades () {
    tPila fitxesDisponibles;
    FILE *z;
    char fitxer[50], c;
    tNode x;
    int sup, inf;
    printf("Introdueix el nom del fitxer que conte les fitxes: ");
    scanf("%s", fitxer); printf("\n");
    while ((z = fopen(fitxer, "r")) == NULL) {
        printf("El fitxer no existeix, introdueix el nom d'un fitxer valid: ");
        scanf("%s", fitxer); printf("\n");
    }
    iniciarPila(&fitxesDisponibles);
    while (!feof(z)) {
        fscanf(z, "%d", &sup);
        fscanf(z, "%c", &c);
        fscanf(z, "%d", &inf);
        fscanf(z, "%c", &c);
        x.info.superior = sup;
        x.info.inferior = inf;
        push(&fitxesDisponibles, x);
    }
    fclose(z);
    x = pop(&fitxesDisponibles);
    return(fitxesDisponibles);
}

void obtenir_index_seguent_jugador (tJugador jugador[], int *i) {
    if (jugador[*i+1].actiu == 1 && *i < 3) {
        *i = *i+1;
    }
    else {
        *i = 0;
    }
}

void agafar_fitxa_pila (tPila *fitxesDisponibles, tJugador *jugador, int i) {
    tNode fitxa;
    fitxa = pop(fitxesDisponibles);
    inserirLlista(&jugador[i].fitxes, NULL, fitxa);
}

void repartir (tPila *fitxesDisponibles, tJugador *jugador) {
    int i = 0;
    int j = 7;
    tNode fitxa;
    while (j > 0) {
        fitxa = pop(fitxesDisponibles);
        fitxa.info.pos = FITXA_ESQUERRA;
        inserirLlista(&jugador[i].fitxes, NULL, fitxa);
        obtenir_index_seguent_jugador(jugador, &i);
        if (i == 0) {
            j = j-1;
        }
    }
}

int pot_tirar (tPartida partida, tJugador jugador[], int i) {
    int trobat;
    int esq, dre;
    tNode *iteradorLlista;
    if (partida.esquerra->info.pos == FITXA_ESQUERRA) {
        esq = partida.esquerra->info.superior;
    }
    else {
        esq = partida.esquerra->info.inferior;
    }
    if (partida.dreta->info.pos == FITXA_ESQUERRA) {
        dre = partida.dreta->info.inferior;
    }
    else {
        dre = partida.dreta->info.superior;
    }
    primerLlista(&iteradorLlista, jugador[i].fitxes);
    trobat = 0;
    while (iteradorLlista != NULL && !trobat) {
        if (iteradorLlista->info.superior == esq || iteradorLlista->info.inferior == esq ||
            iteradorLlista->info.superior == dre || iteradorLlista->info.inferior == dre) {
                trobat = 1;
        }
        seguentLlista(jugador[i].fitxes, &iteradorLlista);
    }
    return(trobat);
}

int demanar_tirar_fitxa (tPartida *partida, tJugador *jugador, int i) {
    int resultat;
    tNode *iteradorLlista, *fitxaSeleccionada; /* Cal un doble iterador per fer les eliminacions */
    tNode fitxa;
    int nFitxa, nDisponibles, j, n;
    char opc; /* Indicarà el costat de la partida on inserir la fitxa */
    primerLlista(&iteradorLlista, partida->esquerra);
    printf("Es torn de %s, l'estat actual de la partida es:\n", jugador[i].nom);
    while (iteradorLlista != NULL) { /* Recorrem la llista de la partida per imprimir-la */
        if (iteradorLlista->info.pos == FITXA_VERTICAL) {
            printf("[[%d]]", iteradorLlista->info.superior);
        }
        else if (iteradorLlista->info.pos == FITXA_DRETA) {
            printf("[%d|%d]", iteradorLlista->info.inferior, iteradorLlista->info.superior);
        }
        else {
            printf("[%d|%d]", iteradorLlista->info.superior, iteradorLlista->info.inferior);
        }
        seguentLlista(partida->esquerra, &iteradorLlista);
    }
    primerLlista(&iteradorLlista, jugador[i].fitxes);
    nDisponibles = 0;
    printf("\nLes fitxes disponibles son:\n");
    while (iteradorLlista != NULL) { /* Recorrem la llista de fitxes del jugador per imprimir-la */
        printf(" [%d|%d] ", iteradorLlista->info.superior, iteradorLlista->info.inferior);
        seguentLlista(jugador[i].fitxes, &iteradorLlista);
        nDisponibles = nDisponibles+1;
    }
    printf("\nTens un total de %d fitxes disponibles.", nDisponibles);
    printf("\nIntrodueix el nombre de fitxa que desitges inserir al domino: ");
    scanf("%d", &nFitxa); printf("\n");
    while (nFitxa > nDisponibles || nFitxa <= 0) {
        printf("Nomes queden %d fitxes disponibles, introdueix un nou nombre de fitxa valid: ", nDisponibles);
        scanf("%d", &nFitxa); printf("\n");
    }
    primerLlista(&fitxaSeleccionada, jugador[i].fitxes);
    if (nFitxa == 1) { /* Al seleccionar la primera fitxa col·loquem iteradorLlista a NULL per esborrar correctament */
        iteradorLlista = NULL;
    }
    for (j = 0; j < nFitxa-1; ++j) { /* Només entra si nFitxa > 1 */
        iteradorLlista = fitxaSeleccionada;
        seguentLlista(jugador[i].fitxes, &fitxaSeleccionada); /* Avança l'iterador fitxaSeleccionada */
    }
    if (partida->esquerra == NULL) { /* Primer moviment de la partida */
        eliminarLlista(&jugador[i].fitxes, iteradorLlista, &fitxa);
        if (fitxa.info.superior == fitxa.info.inferior) { /* Posem la fitxa en posició vertical  si és un doble */
            fitxa.info.pos = FITXA_VERTICAL;
        }
        inserirLlista(&partida->esquerra, partida->esquerra, fitxa);
        partida->dreta = partida->esquerra; /* Al inserir la primera fitxa fem que partida->esquerra i partida->dreta siguin iguals */
        resultat = 1;
    }
    else { /* Altres moviments de la partida */
        opc = 'x';
        while (opc != 'd' && opc != 'e') {
            printf("Introdueix el costat on s'introdueix la fitxa: (d)reta o (e)squerra: ");
            scanf("%c", &opc); printf("\n");
        }
        if (opc == 'e') { /* Inserció a l'esquerra */
            if (partida->esquerra->info.pos == FITXA_DRETA) {
                n = partida->esquerra->info.inferior;
            }
            else {
                n = partida->esquerra->info.superior;
            }
        }
        else { /* Inserció a la dreta */
            if (partida->dreta->info.pos == FITXA_ESQUERRA) {
                n = partida->dreta->info.inferior;
            }
            else {
                n = partida->dreta->info.superior;
            }
        }
        fitxa = elementLlista(fitxaSeleccionada);
        if (fitxa.info.superior == n || fitxa.info.inferior == n) { /* La fitxa serà inserida a la partida */
            eliminarLlista(&jugador[i].fitxes, iteradorLlista, &fitxa);
            if (opc == 'e') {
                if (fitxa.info.superior == fitxa.info.inferior) {
                        fitxa.info.pos = FITXA_VERTICAL;
                }
                else {
                    if (fitxa.info.superior == n) {
                        fitxa.info.pos = FITXA_DRETA;
                    }
                }
                inserirLlista(&partida->esquerra, NULL, fitxa);
            }
            else {
                if (fitxa.info.superior == fitxa.info.inferior) {
                        fitxa.info.pos = FITXA_VERTICAL;
                }
                else {
                    if (fitxa.info.inferior == n) {
                        fitxa.info.pos = FITXA_DRETA;
                    }
                }
                inserirLlista(&partida->esquerra, partida->dreta, fitxa);
                seguentLlista(partida->esquerra, &partida->dreta);
            }
            if (esBuidaLlista(jugador[i].fitxes)) {
                resultat = 2;
            }
            else {
                resultat = 1;
            }
        }
        else { /* No s'ha inserit cap fitxa */
            resultat = 0;
        }
    }
    return(resultat);
}

void mostrar_resultats (tJugador jugador[]) {
    int i, j, minim, jActius;
    int puntuacio[MAX_JUGADORS];
    tNode *iteradorLlista;
    jActius = 0;
    for (i = 0; i <= MAX_JUGADORS-1; ++i) {
        puntuacio[i] = 0;
        if (jugador[i].nom != "") {
            primerLlista(&iteradorLlista, jugador[i].fitxes);
            printf("Ordenant");
            while (iteradorLlista != NULL) {
                puntuacio[i] = puntuacio[i] + iteradorLlista->info.superior + iteradorLlista->info.inferior;
                seguentLlista(jugador[i].fitxes, &iteradorLlista);
            }
            jActius = jActius + 1;
            printf("puntuacio[%d] = %d", i, puntuacio[i]);
        }
    }
    for (i = 1; i <= jActius-1; ++i) {
        minim = i;
        for (j = i+1; i <= jActius; ++j) {
            if (puntuacio[j] < puntuacio[minim]) {
                minim = j;
            }
        }
        intercanvia((char*)&jugador[i], (char*)&jugador[minim], sizeof(tJugador));
        intercanvia((char*)&puntuacio[i], (char*)&puntuacio[minim], sizeof(int));
    }
    printf("Llista ordenada");
    for (i = 0; i <= MAX_JUGADORS-1; i++) {
        if (jugador[i].nom != "") {
            if (jugador[i].fitxes == NULL) {
                printf("El jugador %s ha guanyat la partida amb 0 punts i sense fitxes", jugador[i].nom);
            }
            else {
                printf("%d. %s amb %d punts", i+1, jugador[i].nom, puntuacio[i]);
            }
        }
        else {
            printf("%d.", i+1);
        }
    }
}

void partida (tPartida *partida, tJugador *jugador) {
    int final, continuar;
    int indexJugador;
    partida->esquerra = NULL;
    partida->dreta = NULL;
    tPila fitxesDisponibles;
    tNode fitxa;
    fitxesDisponibles = obtenir_fitxes_barrejades();
    repartir(&fitxesDisponibles, jugador);
    final = 0;
    indexJugador = 0;
    demanar_tirar_fitxa(partida, jugador, indexJugador); /* Primer moviment */
    while (!final) {
        obtenir_index_seguent_jugador(jugador, &indexJugador);
        while (!pot_tirar(*partida, jugador, indexJugador) && !esBuidaPila(&fitxesDisponibles)) {
            agafar_fitxa_pila(&fitxesDisponibles, jugador, indexJugador);
        }
        final = !pot_tirar(*partida, jugador, indexJugador) && esBuidaPila(&fitxesDisponibles); /*Cambio AND i esBuidaPila*/
        if (!final) {
            continuar = 0;
            while (continuar == 0) {
                continuar = demanar_tirar_fitxa(partida, jugador, indexJugador);
                if (continuar == 2) { /* El jugador ha inserit la darrera fitxa */
                    final = 1;
                }
            }
        }
    }
    mostrar_resultats(jugador);
    for (indexJugador = 0; indexJugador < MAX_JUGADORS; ++indexJugador) { /* Lliberem memòria de les llistes de tots els jugadors */
        while (!esBuidaLlista(jugador[indexJugador].fitxes)) {
            eliminarLlista(&jugador[indexJugador].fitxes, NULL, &fitxa);
        }
    }
    while (!esBuidaLlista(partida->esquerra)) { /* Lliberem memòria de les fitxes de la partida */
        eliminarLlista(&partida->esquerra, NULL, &fitxa);
    }
    while (!esBuidaPila(&fitxesDisponibles)) { /* Lliberem la memòria utilitzada per la pila de fitxes fitxesDisponibles */
        fitxa = pop(&fitxesDisponibles);
    }
}

/* Programa principal                                                         */

int main () {
    tJugador jugador[MAX_JUGADORS];
    tPartida game;
    introduir_jugadors(jugador);
    partida(&game, jugador);

    system("PAUSE");
    return(0);
}