/*   Universidad de La Frontera
 *   Ingeniería Civil Electrónica
 *
 *   ICC-202 PROGRAMACION DE COMPUTADORES
 *
 *   Tarea 1
 *   Autores: Cristian Pinoleo Jara (c.pinoleo01@ufromail.cl)
 *            Max Cortés Torres (m.cortes09@gmail.com)
 *
 *   Fecha: 22-09-19
 *
 *   Descripción general del programa: El programa consiste en un tablero de seis filas y siete columnas, donde se deben introducir fichas (indicadas con las
 *   letras A y R de amarillo y rojo). Gana el primer jugador en conseguir alinear cuatro de sus fichas en una línea, ya sea horizontal, vertical u diagonal.
 */

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

int main(){

    int tablero[7][7] = {{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0}};
     /* Declaración e inicialización del arreglo tipo matriz "tablero" de seis filas por siete columnas (la declaración de siete filas se hizo para evitar
       que las jugadas se sobrescribieran en la primera fila, es decir, que la fila cero actúa como borde del tablero. Durante el transcurso del juego, no se considerará la columna cero. */

    int ficha;
    char scanColumna[20]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};                  //Declaración de variables ficha y columna que más adelante permitirá cambiar el valor de un elemento específico del tablero para introducir fichas. Luego se declararán variables dependientes de scanColumna para evitar dobles jugadas y filtrar las entradas.
    int jugador = 0;                                                                 //Declaración de la variable jugador, que indica el turno del jugador presente, comienza en "0", que indica el jugador 1 y más adelante cambia a "1" que indica el jugador 2, y alterna entre estos dos números durante el resto del programa.
    int ganador = 0;                                                                 //Delaración de la variable ganador, que indica si existe un ganador en el juego, varía entre "0" , "1" y "2",  para cero, no existe ganador, para uno el ganador es el jugador 1, y para dos el gaador es el jugador 2.


    for(int i=0; i < 6; i++){
            for(int j=0; j < 7; j++){

                printf("%i ");

            }
            printf("\n");

    }
    system("CLS"); //Limpia la pantalla de código basura generado al compilar el programa.
    printf("Conecta 4\n \n");
    printf("Bienvenido a Conecta 4.\nEl primer jugador en conseguir que cuatro de sus fichas formen una linea, gana.\n");
    printf("Este es su tablero:\n \n");

    for(int i=0; i < 6; i++){
            for(int j=0; j < 7; j++){

                printf("<O> ");

            }
            printf("\n");
            } /* Código que imprime por pantalla el tablero vacío que será usado en el juego. Consiste en un conjunto de bucles "for", el interior imprime un elemento
                 por columna espaciado para cada valor de "j" que varía desde cero hasta seis, en el bucle exterior, bajo el bucle interior, hay un salto de espacio para
                 que el la impresión salte un espacio cada vez que se completa una fila para cada valor de "i". */

    printf("\nEl jugador 1 tendra las fichas amarillas, el jugador 2 las rojas.\n");

while(ganador == 0){  //Inicio de bucle principal del juego, que continúa hasta que el valor de ganador sea distinto a cero.

    printf("Turno: jugador %i \n", jugador+1);

    printf("Elija una columna (del 1 al 7): \n");
    scanf("%s", &scanColumna);  //Petición al usuario( puede ser jugador 1 o jugador 2, según corresponda) que ingrese una columna.

    int k=0;
    while(k == 0){  //En caso de que el usuario ingrese una columna no perteneciente al tablero (ya sea un numero o letra) , el programa pedirá que se ingrese otra.

        int column = (int)scanColumna[0];

            if(((column < 56) && (column > 48))){
               while(scanColumna[1]!=0){
                printf("El dato digitado no es un valor correcto. Ingrese un valor numerico correspondiente a alguna columna.\n");
                fflush(stdin);
                scanf("%s",&scanColumna);
                }
                k=1;
                break;
            }
               else{
                printf("El dato digitado no es un valor correcto. Ingrese un valor numerico correspondiente a alguna columna.\n");
                fflush(stdin);
                scanf("%s",&scanColumna);
                }
           }



    int columna = (int)scanColumna[0];
    columna -=49 ;   // A la variable columna se le resta 48 (para utilizarlo como un número de 0 al 7), y una unidad para facilitar su uso más adelante

    switch(jugador){
        case 0:
            ficha = 1;
            break;

        case 1:
            ficha = 2;
            break;
    }

    int l = 1;  //   Las funciones que implican la variable L están destinadas a indicar al jugador cuando la columna seleccionada está llena, conservando su turno, inicializada en uno.
    for (int i = 1; i <7 ; i++){
        if (tablero[i][columna] == 0)
        {
            tablero[i][columna]= ficha;
            l = 0;
            break;
        }

    } /* Bucle "for" que permite que las fichas "bajen" al final del tablero cuando existen expacios vacíos, si se cumple la condición, el punto donde evaluó será el punto en el cual se ubicará la ficha.
		 además, el valor de "l" cambiará a cero y las funciones dependientes de esta variable no se realizarán. Si no se cumple la condición, no se crea una ficha en elpacio específico y el valor
		 de "l" queda intacto. */

    if(l == 1){
        printf("Columna %i llena \n",columna+1);
    } // Impresión por pantalla que avida si una columna está llena. se basa en el valor de "l".

    switch(jugador){  // Condicional Switch que permite introducir distintos números al tablero, dependiendo de cual es el jugador que las introduce.
        case 0:

            ficha = 1;

            break;

        case 1:

            ficha = 2;

            break;

    }

    for(int i=6; i>=1; i--){
        for(int j=0; j<7; j++ ){
            if(tablero[i][j] == 1){
                printf("<A> ", tablero[i][j]);
            }
            else if(tablero[i][j] == 2){
                printf("<R> ", tablero[i][j]);
            }
            else{
                printf("<O> ", tablero[i][j]);
            }   /*  Conjunto de bucles que imprimen el tablero por pantalla, se basa en el conjunto al inicio del programa, pero el bucle interior, posee un condicional
                   "if" que pregunta si algún espacio tiene los valores uno o dos, si se cumple cualquiera de estas condiciones, la ficha impresa tendrá la letra "R"
                    para el color rojo asignado al jugador 1 o la letra "A" para el color amarillo asignado al jugador 2. Si la condiciónes no se cumplen se imprime un
                    espacio vacío, que indica que no hay ficha en aquel lugar. */


        }
        printf("\n");

    }

    if(l == 1){

        switch(jugador){
            case 0:
                    jugador = 0;
                break;

            case 1:
                    jugador = 1;
                break;
        }

    }
    else{
        switch(jugador){
            case 0:
                jugador = 1;
            break;

            case 1:
                jugador = 0;
            break;
        }


    }  // Condicional que permite alternar los turnos de los jugadores. Toma en cuenta si el turno utilizado por el jugador se "perdió" por una columna llena.

    int segundobreak=0; //Variable que permite terminar el bucle siguiente después de cumplirse la condición en el bucle anidado inicializada en cero.

    for(int j=0; j<7; j++){


        for(int i=6; i>0; i--){


            if((tablero[i][j]==tablero[i-1][j]) && (tablero[i-1][j]==tablero[i-2][j]) && (tablero[i-2][j]==tablero[i-3][j]) && (tablero[i][j]!= 0)){
                if(tablero[i][j]==1){
                ganador = 1;
                segundobreak = 1;
                break;
                }
                else{
                    ganador = 2;
                    segundobreak = 1;
                    break;
                }

            }
        }

        if(segundobreak == 1){
            break;
        }

    } /*   Conjunto de bucles "for" que permiten encontrar un ganador verticalmente. El bucle interior se guía por la variable "i" que indica las filas del elemento
           del tablero, y la función de este es evaluar la condición "si existen cuatro elementos iguales, consecutivos y distintos de cero" (de esta manera se
           verifica que los elementos deben ser una ficha, ya que cero es el estado vacío), si la condición se cumple entonces se evalúa si el elemento también es uno
           si esto se cumple, entonces ganador será igual a uno, si no se cumple, ganador será igual a dos, la variable segundobreak igual a uno (que influye en el bucle exterior)
		    y un break(que detiene el bucle interior), si no se cumple, el bucle continúa sin ejecutar instrucciones. El bucle exterior se guía por la variable "j" que indica
			la columna del elemento del tablero contiene un condicional "if" que pregunta si el valor de la variable "segundobreak" es uno, si la condición se cumple, se detiene
			el bucle interior. Si no se cumple, el bucle continúa sin ejecutar instrucciones.   */

    for(int i=1; i<7; i++){


        for(int j=0; j<5; j++){


            if((tablero[i][j]==tablero[i][j+1]) && (tablero[i][j+1]==tablero[i][j+2]) && (tablero[i][j+2]==tablero[i][j+3]) && (tablero[i][j]!= 0)){
                if(tablero[i][j]==1){
                    ganador = 1;
                    segundobreak = 1;
                    break;
                }
                else{
                    ganador = 2;
                    segundobreak = 1;
                    break;
                }
            }
        }

        if(segundobreak == 1){
            break;
        }

    } /*   Conjunto de bucles "for", encargados de verificar si existe un ganador horizontalmente. El sistema es muy similar al verificador vertical.
           El bucle revisa cada posición en el tablero, y compara las posiciones a la derecha para revisar si son iguales. De ser asi (y no ser ceros,
           para eso la ultima condición), se declara ganador al jugador cuyas fichas forman horizontalmente una línea de cuatro. Si no se cumple, no
           se ejecuntan las instrucciones del bucle, y se continúa con el programa. */

    for(int i=1; i<5; i++){


        for(int j=0; j<5; j++){


            if((tablero[i][j]==tablero[i+1][j+1]) && (tablero[i+1][j+1]==tablero[i+2][j+2]) && (tablero[i+2][j+2]==tablero[i+3][j+3]) && (tablero[i][j]!=0)){
                if(tablero[i][j]==1){
                    ganador = 1;
                    segundobreak = 1;
                    break;
                }
                else{
                    ganador = 2;
                    segundobreak = 1;
                    break;
                }
            }
        }

        if(segundobreak == 1){
            break;
        }
    } /* Conjunto de bucles "for", encargados de verificar si existe un ganador diagonalmente de izquierda a deracha diagonalmente. Las posición de cada ficha es comparado con la que se encuentra una unidad a
		la derecha u una unidad hacia abajo, es decir, que que para cualquier posición inicial se evalúa la que se encuentra en "fila inicial mas uno" y "columna inicial mas uno". Si exsten cuatro fichas
		iguales consecutivas de forma diagonal distintas de cero (que indica un espacio vacío), entonces se para a la siguiente condición, que pregunra si la ficha original evaluada tiene el valor de uno. En
		este caso, se declara un ganador, que será el jugador 1. En el caso contrario, el ganador delarado será el jugador 2.   */

    for(int i=7; i>3; i--){


        for(int j=0; j<5; j++){


            if((tablero[i][j]==tablero[i-1][j+1]) && (tablero[i-1][j+1]==tablero[i-2][j+2]) && (tablero[i-2][j+2]==tablero[i-3][j+3]) && (tablero[i][j]!=0)){
                if(tablero[i][j]==1){
                    ganador = 1;
                    segundobreak = 1;
                    break;
                }
                else{
                    ganador = 2;
                    segundobreak = 1;
                    break;
                }
            }
        }

        if(segundobreak == 1){
            break;
        }
    }  /* Par de bucles "for" que revisan diagonalmente si existe un ganador. El sistema de revisión es similar a los anteriores,
          se compara cada ficha con la ficha diagonal superior derecha, luego estas se comparan con su respectiva diagonal superior derecha,
          y finalmente se compara esta última con su diagonal superior derecha. Si todas son iguales, y todas son distintas a 0, se declara
          un ganador (el jugador cuyas fichas forman la diagonal).*/

}
    printf("Tenemos un ganador!! El jugador %i es el vencedor.", ganador); // código que imprime la existencia de un ganador y también imprime dicho ganador.

    return 0;
}