/*
 * File:   batallanaval.c
 * Author: Rodrigo Fuentealba
 *
 */

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

#define LLENO 'X'
#define VACIO ' '
#define AGUAS '+'
#define PUNTO '*'

#define LARGO 5
#define BUQUE 5

/*
 * Estructura para manejo de posiciones
 */

typedef struct
{
    int x;
    int y;
} posicion;

/*
 * Estructura para manejo de informacin de los jugadores
 */

typedef struct {
    int puntos;
    char campo[LARGO][LARGO];
} jugador;

/*
 * Enumeracin de booleanos
 */

typedef enum
{
    false,
    true
} boolean;

/*
 * Operaciones de pantalla
 */

    /*
     * Limpiando la pantalla
     */

    void pantalla_limpiar(void)
    {
        printf("\033[2J");
    }

    /*
     * Escribiendo una linea
     */

    void pantalla_imprimirlinea(void)
    {
        printf("\n");
        printf("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
        printf("\n");
    }

    /*
     * Mostrando el ttulo del juego
     */

    void pantalla_mostrartitulo(void)
    {
        pantalla_imprimirlinea();
        printf("            LA BATALLA NAVAL            ");
        pantalla_imprimirlinea();
    }

    /*
     * Mostrando el campo
     */

    int pantalla_mostrarcampo(char campo[LARGO][LARGO], boolean visible)
    {
        int i;
        int j;

        printf("\nY  |");
        printf("\n---|------------------------");

        for(i=LARGO-1;i>=0;i--)
        {
            printf("\n%d  |  ", i);
            for(j=0;j<LARGO;j++)
            {
                if(visible == true)
                {
                    printf("%c    ", campo[j][i]);
                }
                else
                {
                    if(campo[j][i] == LLENO)
                    {
                        printf("%c    ", VACIO);
                    }
                    else
                    {
                        printf("%c    ", campo[j][i]);
                    }
                }
            }
        }
        printf("\n---|------------------------");
        printf("\n X |   0    1    2    3    4\n");

        return 0;
    }

    /*
     * Operaciones de posicionamiento
     */

    posicion posicion_generar()
    {
        posicion ingreso;

        ingreso.x = rand() % 5;
        ingreso.y = rand() % 5;

        return ingreso;
    }

    posicion posicion_ingresar()
    {
        posicion ingreso;
        boolean auxiliar;
    
        ingreso.x = -1;
        auxiliar = false;
        
        while(ingreso.x < 0 || ingreso.x >= LARGO)
        {
            if(auxiliar == true)
            {
                printf("\a");
                printf("\nValor fuera de rango.");
            }
            printf("\nIngrese el valor X de la posicion:");
            fscanf(stdin, "%d", &ingreso.x);
            fflush(stdin);
            auxiliar = true;
        }

        ingreso.y = -1;
        auxiliar = false;
        
        while(ingreso.y < 0 || ingreso.y >= LARGO)
        {
            if(auxiliar == true)
            {
                printf("\a");
                printf("\nValor fuera de rango. X es igual a %d", ingreso.x);
            }
            printf("\nIngrese el valor Y de la posicion:");
            fscanf(stdin, "%i", &ingreso.y);
            fflush(stdin);
            auxiliar = true;
        }

        return ingreso;
    }

    char posicion_leer(char campo[LARGO][LARGO], posicion ingreso)
    {
        return (campo[ingreso.x][ingreso.y]);
    }

    int posicion_escribir(char campo[LARGO][LARGO], posicion ingreso, char valor)
    {
        campo[ingreso.x][ingreso.y] = valor;
        return 0;
    }

    boolean posicion_comparar (char campo[LARGO][LARGO], posicion ingreso, char valor)
    {
        if(campo[ingreso.x][ingreso.y] == valor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

/*
 * Operaciones de matriz
 */

    /*
     * Limpiar el campo de trabajo
     */

    int campo_limpiar(char campo[LARGO][LARGO])
    {
        int i;
        int j;

        for(i=0;i<LARGO;i++)
        {
            for(j=0;j<LARGO;j++)
            {
                campo[i][j] = VACIO;
            }
        }

        return 0;
    }

    int campo_generar(char campo[LARGO][LARGO])
    {
        int i;
        int j;
        posicion ingreso;
        boolean bandera;

        for(i=0;i<BUQUE;i++)
        {
            bandera = false;
            while(!bandera)
            {
                ingreso = posicion_generar();
                //if(!posicion_comparar(campo, ingreso, LLENO))
                //{
                    posicion_escribir(campo, ingreso, LLENO);
                    bandera = true;
                //}
            }
        }
    }

    int campo_ingresar(char campo[LARGO][LARGO])
    {
        int i;
        int j;
        posicion ingreso;
        boolean bandera;

        for(i=0;i<BUQUE;i++)
        {
            bandera = false;
            while(!bandera == true)
            {
                ingreso = posicion_ingresar();
                if(!posicion_comparar(campo, ingreso, LLENO))
                {
                    posicion_escribir(campo, ingreso, LLENO);
                    bandera = true;
                }
            }
        }
    }

/*
 * Juego
 */

int main(int argc, char** argv)
{
    jugador cpu;
    jugador humano;

    boolean bandera;
    posicion ingreso;

    srand(45698);

    pantalla_limpiar();
    pantalla_mostrartitulo();

    /*
     * CPU genera el campo
     */

    campo_limpiar(cpu.campo);
    campo_generar(cpu.campo);

    /*
     * Humano genera el campo
     */

    campo_limpiar(humano.campo);
    campo_ingresar(humano.campo);

    /*
     * Configurar puntajes
     */

    cpu.puntos = 0;
    humano.puntos = 0;

    /*
     * Comienza el juego
     */

    pantalla_limpiar();
    pantalla_mostrartitulo();

    while(cpu.puntos < 5 && humano.puntos < 5)
    {
        printf("\n\nEstado de la CPU (puntos %d):", cpu.puntos);
        pantalla_mostrarcampo(cpu.campo, false);
        printf("\n\nEstado del jugador (puntos %d):", humano.puntos);
        pantalla_mostrarcampo(humano.campo, true);

        bandera = false;

        while(bandera == false)
        {
            ingreso = posicion_ingresar();

            if(posicion_comparar(cpu.campo, ingreso, VACIO))
            {
                posicion_escribir(cpu.campo, ingreso, AGUAS);
                bandera = true;
            }

            if(posicion_comparar(cpu.campo, ingreso, LLENO))
            {
                posicion_escribir(cpu.campo, ingreso, PUNTO);
                humano.puntos = humano.puntos + 1;
                bandera = true;
            }

            if(posicion_comparar(cpu.campo, ingreso, AGUAS))
            {
                printf("Ya habias tirado ahi.");
                bandera = true;
            }

            if(posicion_comparar(cpu.campo, ingreso, PUNTO))
            {
                printf("Ya habias tirado ahi.");
                bandera = true;
            }

        }

        bandera = false;

        while(bandera == false)
        {
            ingreso = posicion_generar();

            if(posicion_comparar(humano.campo, ingreso, VACIO))
            {
                posicion_escribir(humano.campo, ingreso, AGUAS);
                bandera = true;
            }

            if(posicion_comparar(humano.campo, ingreso, LLENO))
            {
                posicion_escribir(humano.campo, ingreso, PUNTO);
                cpu.puntos = cpu.puntos + 1;
                bandera = true;
            }

            if(posicion_comparar(humano.campo, ingreso, AGUAS))
            {
                bandera = true;
            }

            if(posicion_comparar(humano.campo, ingreso, PUNTO))
            {
                bandera = true;
            }
        }

        if(cpu.puntos == humano.puntos)
        {
            printf("EMPATE: 5 a 5");
        }
        else
        {
            if(cpu.puntos == 5)
            {
                printf("\nGANA LA CPU: %d a %d", cpu.puntos, humano.puntos);
            }
            if(humano.puntos == 5)
            {
                printf("\nGANA EL JUGADOR: %d a %d", humano.puntos, cpu.puntos);
            }
        }
    }

    return 0;
}