C# Program

This is a battleship game that I made in C#, very early on my programming journey (sorry in advance for the bad practices and spaghetti code):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Naval
{
    class Program
    {
        static void Main(string[] args)
        {
            //ARREGLOS
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //declaramos 10 arreglos de 10 elementos por cada tabla: 4 tablas, entonces 40
            //arreglos, esto para poder determinar la posición.
            //Utilizaremos 0, 1, 2 y 3 para determinar si la posicion esta vacia (negro), si es barco
           //de usuario(verde), si el tiro no es barco de nadie(blanco), y si es barco o golpe de la
           //computadora(rojo).
           //Solamente representaremos la tabla 1 y 2 del usuario, las tablas 1 y 2 de la
           //computadora seran lógicas (se les llamara tableros en la parte gráfica).
           //Tabla 1 usuario
            int[] renglon1tablausuario1 = new int[10];
            int[] renglon2tablausuario1 = new int[10];
            int[] renglon3tablausuario1 = new int[10];
            int[] renglon4tablausuario1 = new int[10];
            int[] renglon5tablausuario1 = new int[10];
            int[] renglon6tablausuario1 = new int[10];
            int[] renglon7tablausuario1 = new int[10];
            int[] renglon8tablausuario1 = new int[10];
            int[] renglon9tablausuario1 = new int[10];
            int[] renglon10tablausuario1 = new int[10];
            //Tabla 2 usuario
            int[] renglon1tablausuario2 = new int[10];
            int[] renglon2tablausuario2 = new int[10];
            int[] renglon3tablausuario2 = new int[10];
            int[] renglon4tablausuario2 = new int[10];
            int[] renglon5tablausuario2 = new int[10];
            int[] renglon6tablausuario2 = new int[10];
            int[] renglon7tablausuario2 = new int[10];
            int[] renglon8tablausuario2 = new int[10];
            int[] renglon9tablausuario2 = new int[10];
            int[] renglon10tablausuario2 = new int[10];
            //Tabla 1 computadora
            int[] renglon1tablacomputadora1 = new int[10];
            int[] renglon2tablacomputadora1 = new int[10];
            int[] renglon3tablacomputadora1 = new int[10];
            int[] renglon4tablacomputadora1 = new int[10];
            int[] renglon5tablacomputadora1 = new int[10];
            int[] renglon6tablacomputadora1 = new int[10];
            int[] renglon7tablacomputadora1 = new int[10];
            int[] renglon8tablacomputadora1 = new int[10];
            int[] renglon9tablacomputadora1 = new int[10];
            int[] renglon10tablacomputadora1 = new int[10];
            //Tabla 2 computadora
            int[] renglon1tablacomputadora2 = new int[10];
            int[] renglon2tablacomputadora2 = new int[10];
            int[] renglon3tablacomputadora2 = new int[10];
            int[] renglon4tablacomputadora2 = new int[10];
            int[] renglon5tablacomputadora2 = new int[10];
            int[] renglon6tablacomputadora2 = new int[10];
            int[] renglon7tablacomputadora2 = new int[10];
            int[] renglon8tablacomputadora2 = new int[10];
            int[] renglon9tablacomputadora2 = new int[10];
            int[] renglon10tablacomputadora2 = new int[10];
            //Tal vez era mas sencillo usar arreglos multidimensionales, pero no supe como
            //utilizarlos de manera correcta :(
            /////////CONTADORES
            //necesitamos un ciclo while dependiendo de dos contadores, de los golpes del
            //usuario y de los golpes de la maquina
            int contadorusuario = 0;
            int contadorcomputadora = 0;
            //////////////////////////////CODIGO PRINCIPAL
            //Comenzamos con el menu inicial
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("*****************************************************************************************************");
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("Bienvenido a Batalla Naval\n\nPresiona 1 si deseas jugar\nPresiona cualquier otra tecla si deseas salir");
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.WriteLine("*****************************************************************************************************");
            Console.ResetColor();
            //Declaramos la decision del menu inicial, con esta regresamos en el while
            string decision1 = Console.ReadLine();
            //NOTAS antes de empezar
            Console.Clear();
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("Tu campo de batalla es el de la izquierda, y el del enemigo el de la derecha, tus jugadas y las de el enemigo se veran reflejadas en los tableros.");
            Console.ResetColor();
            Console.ReadKey();
            //Comenzamos el ciclo while para poder volver a jugar después
            while (decision1 == "1")
            {
                //reseteamos los contadores
                contadorusuario = 0;
                contadorcomputadora = 0;
                //Rellenamos los arreglos dentro del ciclo while para poder regenerar cada vez
                //que queramos jugar, rellenaremos la tabla 1 del usuario, la tabla 2 del usuario, la tabla 1 de
                //la computadora, y la tabla 2 de la computadora
                //i dentro del 0 al 9 para rellenar las posiciones de los elementos de los arreglos,
                //y solamente con 0 para generar campos vacios(para poderlos representar gráficamente).
                for (int i = 0; i <= 9; i++)
                {
                    //Rellenamos Tabla 1 usuario
                    renglon1tablausuario1[i] = 0;
                    renglon2tablausuario1[i] = 0;
                    renglon3tablausuario1[i] = 0;
                    renglon4tablausuario1[i] = 0;
                    renglon5tablausuario1[i] = 0;
                    renglon6tablausuario1[i] = 0;
                    renglon7tablausuario1[i] = 0;
                    renglon8tablausuario1[i] = 0;
                    renglon9tablausuario1[i] = 0;
                    renglon10tablausuario1[i] = 0;
                    //Rellenamos Tabla 2 usuario
                    renglon1tablausuario2[i] = 0;
                    renglon2tablausuario2[i] = 0;
                    renglon3tablausuario2[i] = 0;
                    renglon4tablausuario2[i] = 0;
                    renglon5tablausuario2[i] = 0;
                    renglon6tablausuario2[i] = 0;
                    renglon7tablausuario2[i] = 0;
                    renglon8tablausuario2[i] = 0;
                    renglon9tablausuario2[i] = 0;
                    renglon10tablausuario2[i] = 0;
                    //Rellenamos Tabla 1 computadora
                    renglon1tablacomputadora1[i] = 0;
                    renglon2tablacomputadora1[i] = 0;
                    renglon3tablacomputadora1[i] = 0;
                    renglon4tablacomputadora1[i] = 0;
                    renglon5tablacomputadora1[i] = 0;
                    renglon6tablacomputadora1[i] = 0;
                    renglon7tablacomputadora1[i] = 0;
                    renglon8tablacomputadora1[i] = 0;
                    renglon9tablacomputadora1[i] = 0;
                    renglon10tablacomputadora1[i] = 0;
                    //Rellenamos Tabla 2 computadora
                    renglon1tablacomputadora2[i] = 0;
                    renglon2tablacomputadora2[i] = 0;
                    renglon3tablacomputadora2[i] = 0;
                    renglon4tablacomputadora2[i] = 0;
                    renglon5tablacomputadora2[i] = 0;
                    renglon6tablacomputadora2[i] = 0;
                    renglon7tablacomputadora2[i] = 0;
                    renglon8tablacomputadora2[i] = 0;
                    renglon9tablacomputadora2[i] = 0;
                    renglon10tablacomputadora2[i] = 0;
                }
                //vamos a generar numero aleatorio para x, y 3 (6 en total usuario + computadora)
                //veces(una cada barco)
                Random rnd = new Random();
                //para y es de 1 a 10 para cada renglon
                int randomy1 = rnd.Next(1, 10);
                int randomy2 = rnd.Next(1, 10);
                int randomy3 = rnd.Next(1, 10);
                //para x es de 1 a 8 (0 a 7 por ser arreglo) para poder generar el barco hacia la
                //derecha
                int randomx1 = rnd.Next(0, 7);
                int randomx2 = rnd.Next(0, 7);
                int randomx3 = rnd.Next(0, 7);
                //comparamos randomx 1, para evitar que sean justo debajo
                while (randomx1 == randomx2 || randomx1 == randomx3)
                {
                    randomx1 = rnd.Next(0, 7);
                }
                //comparamos randomx 2, para evitar que sean justo debajo
                while (randomx2 == randomx1 || randomx2 == randomx3)
                {
                    randomx2 = rnd.Next(0, 7);
                }
                //comparamos randomx 3, para evitar que sean justo debajo
                while (randomx3 == randomx2 || randomx1 == randomx3)
                {
                    randomx3 = rnd.Next(0, 7);
                }
                //tenemos las x, ahora veamos las y
                //solo buscamos que no sean iguales, por que ya las separamos en las x
                //comparamos randomy 1
                while (randomy1 == randomy2 || randomy1 == randomy3)
                {
                    randomy1 = rnd.Next(1, 10);
                }
                //comparamos randomy 2
                while (randomy1 == randomy2 || randomy2 == randomy3)
                {
                    randomy2 = rnd.Next(1, 10);
                }
                //comparamos randomy 3
                while (randomy3 == randomy2 || randomy1 == randomy3)
                {
                    randomy3 = rnd.Next(1, 10);
                }
                //creamos un switch para cada renglon de los randomy, y sustituimos su
                //respectivo randomx
                //randomx +1, +2 para generar el barquito
                //randomy1, con randomx1
                switch (randomy1)
                {
                    case 1:
                        renglon1tablausuario1[randomx1] = 1;
                        renglon1tablausuario1[randomx1 + 1] = 1;
                        renglon1tablausuario1[randomx1 + 2] = 1;
                        break;
                    case 2:
                        renglon2tablausuario1[randomx1] = 1;
                        renglon2tablausuario1[randomx1 + 1] = 1;
                        renglon2tablausuario1[randomx1 + 2] = 1;
                        break;
                    case 3:
                        renglon3tablausuario1[randomx1] = 1;
                        renglon3tablausuario1[randomx1 + 1] = 1;
                        renglon3tablausuario1[randomx1 + 2] = 1;
                        break;
                    case 4:
                        renglon4tablausuario1[randomx1] = 1;
                        renglon4tablausuario1[randomx1 + 1] = 1;
                        renglon4tablausuario1[randomx1 + 2] = 1;
                        break;
                    case 5:
                        renglon5tablausuario1[randomx1] = 1;
                        renglon5tablausuario1[randomx1 + 1] = 1;
                        renglon5tablausuario1[randomx1 + 2] = 1;
                        break;
                    case 6:
                        renglon6tablausuario1[randomx1] = 1;
                        renglon6tablausuario1[randomx1 + 1] = 1;
                        renglon6tablausuario1[randomx1 + 2] = 1;
                        break;
                    case 7:
                        renglon7tablausuario1[randomx1] = 1;
                        renglon7tablausuario1[randomx1 + 1] = 1;
                        renglon7tablausuario1[randomx1 + 2] = 1;
                        break;
                    case 8:
                        renglon8tablausuario1[randomx1] = 1;
                        renglon8tablausuario1[randomx1 + 1] = 1;
                        renglon8tablausuario1[randomx1 + 2] = 1;
                        break;
                    case 9:
                        renglon9tablausuario1[randomx1] = 1;
                        renglon9tablausuario1[randomx1 + 1] = 1;
                        renglon9tablausuario1[randomx1 + 2] = 1;
                        break;
                    case 10:
                        renglon10tablausuario1[randomx1] = 1;
                        renglon10tablausuario1[randomx1 + 1] = 1;
                        renglon10tablausuario1[randomx1 + 2] = 1;
                        break;
                    default:
                        break;
                }
                //randomy2, con randomx2
                switch (randomy2)
                {
                    case 1:
                        renglon1tablausuario1[randomx2] = 1;
                        renglon1tablausuario1[randomx2 + 1] = 1;
                        renglon1tablausuario1[randomx2 + 2] = 1;
                        break;
                    case 2:
                        renglon2tablausuario1[randomx2] = 1;
                        renglon2tablausuario1[randomx2 + 1] = 1;
                        renglon2tablausuario1[randomx2 + 2] = 1;
                        break;
                    case 3:
                        renglon3tablausuario1[randomx2] = 1;
                        renglon3tablausuario1[randomx2 + 1] = 1;
                        renglon3tablausuario1[randomx2 + 2] = 1;
                        break;
                    case 4:
                        renglon4tablausuario1[randomx2] = 1;
                        renglon4tablausuario1[randomx2 + 1] = 1;
                        renglon4tablausuario1[randomx2 + 2] = 1;
                        break;
                    case 5:
                        renglon5tablausuario1[randomx2] = 1;
                        renglon5tablausuario1[randomx2 + 1] = 1;
                        renglon5tablausuario1[randomx2 + 2] = 1;
                        break;
                    case 6:
                        renglon6tablausuario1[randomx2] = 1;
                        renglon6tablausuario1[randomx2 + 1] = 1;
                        renglon6tablausuario1[randomx2 + 2] = 1;
                        break;
                    case 7:
                        renglon7tablausuario1[randomx2] = 1;
                        renglon7tablausuario1[randomx2 + 1] = 1;
                        renglon7tablausuario1[randomx2 + 2] = 1;
                        break;
                    case 8:
                        renglon8tablausuario1[randomx2] = 1;
                        renglon8tablausuario1[randomx2 + 1] = 1;
                        renglon8tablausuario1[randomx2 + 2] = 1;
                        break;
                    case 9:
                        renglon9tablausuario1[randomx2] = 1;
                        renglon9tablausuario1[randomx2 + 1] = 1;
                        renglon9tablausuario1[randomx2 + 2] = 1;
                        break;
                    case 10:
                        renglon10tablausuario1[randomx2] = 1;
                        renglon10tablausuario1[randomx2 + 1] = 1;
                        renglon10tablausuario1[randomx2 + 2] = 1;
                        break;
                    default:
                        break;
                }
                //randomy3, con randomx3
                switch (randomy3)
                {
                    case 1:
                        renglon1tablausuario1[randomx3] = 1;
                        renglon1tablausuario1[randomx3 + 1] = 1;
                        renglon1tablausuario1[randomx3 + 2] = 1;
                        break;
                    case 2:
                        renglon2tablausuario1[randomx3] = 1;
                        renglon2tablausuario1[randomx3 + 1] = 1;
                        renglon2tablausuario1[randomx3 + 2] = 1;
                        break;
                    case 3:
                        renglon3tablausuario1[randomx3] = 1;
                        renglon3tablausuario1[randomx3 + 1] = 1;
                        renglon3tablausuario1[randomx3 + 2] = 1;
                        break;
                    case 4:
                        renglon4tablausuario1[randomx3] = 1;
                        renglon4tablausuario1[randomx3 + 1] = 1;
                        renglon4tablausuario1[randomx3 + 2] = 1;
                        break;
                    case 5:
                        renglon5tablausuario1[randomx3] = 1;
                        renglon5tablausuario1[randomx3 + 1] = 1;
                        renglon5tablausuario1[randomx3 + 2] = 1;
                        break;
                    case 6:
                        renglon6tablausuario1[randomx3] = 1;
                        renglon6tablausuario1[randomx3 + 1] = 1;
                        renglon6tablausuario1[randomx3 + 2] = 1;
                        break;
                    case 7:
                        renglon7tablausuario1[randomx3] = 1;
                        renglon7tablausuario1[randomx3 + 1] = 1;
                        renglon7tablausuario1[randomx3 + 2] = 1;
                        break;
                    case 8:
                        renglon8tablausuario1[randomx3] = 1;
                        renglon8tablausuario1[randomx3 + 1] = 1;
                        renglon8tablausuario1[randomx3 + 2] = 1;
                        break;
                    case 9:
                        renglon9tablausuario1[randomx3] = 1;
                        renglon9tablausuario1[randomx3 + 1] = 1;
                        renglon9tablausuario1[randomx3 + 2] = 1;
                        break;
                    case 10:
                        renglon10tablausuario1[randomx3] = 1;
                        renglon10tablausuario1[randomx3 + 1] = 1;
                        renglon10tablausuario1[randomx3 + 2] = 1;
                        break;
                    default:
                        break;
                }
                //los tableros 2 se iran rellenando despues
                //generamos el tablero 1 de la computadora
                int randomy4 = rnd.Next(1, 10);
                int randomy5 = rnd.Next(1, 10);
                int randomy6 = rnd.Next(1, 10);
                //para x es de 1 a 8 (0 a 7 por ser arreglo) para poder generar el barco hacia la
                //derecha
                int randomx4 = rnd.Next(0, 7);
                int randomx5 = rnd.Next(0, 7);
                int randomx6 = rnd.Next(0, 7);
                //comparamos randomx 1, para evitar que sean justo debajo
                while (randomx4 == randomx5 || randomx4 == randomx6)
                {
                    randomx4 = rnd.Next(0, 7);
                }
                //comparamos randomx 2, para evitar que sean justo debajo
                while (randomx5 == randomx4 || randomx5 == randomx6)
                {
                    randomx5 = rnd.Next(0, 7);
                }
                //comparamos randomx 3, para evitar que sean justo debajo
                while (randomx6 == randomx5 || randomx4 == randomx6)
                {
                    randomx6 = rnd.Next(0, 7);
                }
                //tenemos las x, ahora veamos las y
                //solo buscamos que no sean iguales, por que ya las separamos en las x
                //comparamos randomy 1
                while (randomy4 == randomy5 || randomy4 == randomy6)
                {
                    randomy4 = rnd.Next(1, 10);
                }
                //comparamos randomy 2
                while (randomy4 == randomy5 || randomy5 == randomy6)
                {
                    randomy5 = rnd.Next(1, 10);
                }
                //comparamos randomy 3
                while (randomy6 == randomy5 || randomy4 == randomy6)
                {
                    randomy6 = rnd.Next(1, 10);
                }
                //creamos un switch para cada renglon de los randomy, y sustituimos su
                //respectivo randomx
                //randomx +1, +2 para generar el barquito
                //randomy4, con randomx4
                switch (randomy4)
                {
                    case 1:
                        renglon1tablacomputadora1[randomx4] = 1;
                        renglon1tablacomputadora1[randomx4 + 1] = 1;
                        renglon1tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    case 2:
                        renglon2tablacomputadora1[randomx4] = 1;
                        renglon2tablacomputadora1[randomx4 + 1] = 1;
                        renglon2tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    case 3:
                        renglon3tablacomputadora1[randomx4] = 1;
                        renglon3tablacomputadora1[randomx4 + 1] = 1;
                        renglon3tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    case 4:
                        renglon4tablacomputadora1[randomx4] = 1;
                        renglon4tablacomputadora1[randomx4 + 1] = 1;
                        renglon4tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    case 5:
                        renglon5tablacomputadora1[randomx4] = 1;
                        renglon5tablacomputadora1[randomx4 + 1] = 1;
                        renglon5tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    case 6:
                        renglon6tablacomputadora1[randomx4] = 1;
                        renglon6tablacomputadora1[randomx4 + 1] = 1;
                        renglon6tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    case 7:
                        renglon7tablacomputadora1[randomx4] = 1;
                        renglon7tablacomputadora1[randomx4 + 1] = 1;
                        renglon7tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    case 8:
                        renglon8tablacomputadora1[randomx4] = 1;
                        renglon8tablacomputadora1[randomx4 + 1] = 1;
                        renglon8tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    case 9:
                        renglon9tablacomputadora1[randomx4] = 1;
                        renglon9tablacomputadora1[randomx4 + 1] = 1;
                        renglon9tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    case 10:
                        renglon10tablacomputadora1[randomx4] = 1;
                        renglon10tablacomputadora1[randomx4 + 1] = 1;
                        renglon10tablacomputadora1[randomx4 + 2] = 1;
                        break;
                    default:
                        break;
                }
                //randomy5, con randomx5
                switch (randomy5)
                {
                    case 1:
                        renglon1tablacomputadora1[randomx5] = 1;
                        renglon1tablacomputadora1[randomx5 + 1] = 1;
                        renglon1tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    case 2:
                        renglon2tablacomputadora1[randomx5] = 1;
                        renglon2tablacomputadora1[randomx5 + 1] = 1;
                        renglon2tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    case 3:
                        renglon3tablacomputadora1[randomx5] = 1;
                        renglon3tablacomputadora1[randomx5 + 1] = 1;
                        renglon3tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    case 4:
                        renglon4tablacomputadora1[randomx5] = 1;
                        renglon4tablacomputadora1[randomx5 + 1] = 1;
                        renglon4tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    case 5:
                        renglon5tablacomputadora1[randomx5] = 1;
                        renglon5tablacomputadora1[randomx5 + 1] = 1;
                        renglon5tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    case 6:
                        renglon6tablacomputadora1[randomx5] = 1;
                        renglon6tablacomputadora1[randomx5 + 1] = 1;
                        renglon6tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    case 7:
                        renglon7tablacomputadora1[randomx5] = 1;
                        renglon7tablacomputadora1[randomx5 + 1] = 1;
                        renglon7tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    case 8:
                        renglon8tablacomputadora1[randomx5] = 1;
                        renglon8tablacomputadora1[randomx5 + 1] = 1;
                        renglon8tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    case 9:
                        renglon9tablacomputadora1[randomx5] = 1;
                        renglon9tablacomputadora1[randomx5 + 1] = 1;
                        renglon9tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    case 10:
                        renglon10tablacomputadora1[randomx5] = 1;
                        renglon10tablacomputadora1[randomx5 + 1] = 1;
                        renglon10tablacomputadora1[randomx5 + 2] = 1;
                        break;
                    default:
                        break;
                }
                //randomy6, con randomx6
                switch (randomy6)
                {
                    case 1:
                        renglon1tablacomputadora1[randomx6] = 1;
                        renglon1tablacomputadora1[randomx6 + 1] = 1;
                        renglon1tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    case 2:
                        renglon2tablacomputadora1[randomx6] = 1;
                        renglon2tablacomputadora1[randomx6 + 1] = 1;
                        renglon2tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    case 3:
                        renglon3tablacomputadora1[randomx6] = 1;
                        renglon3tablacomputadora1[randomx6 + 1] = 1;
                        renglon3tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    case 4:
                        renglon4tablacomputadora1[randomx6] = 1;
                        renglon4tablacomputadora1[randomx6 + 1] = 1;
                        renglon4tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    case 5:
                        renglon5tablacomputadora1[randomx6] = 1;
                        renglon5tablacomputadora1[randomx6 + 1] = 1;
                        renglon5tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    case 6:
                        renglon6tablacomputadora1[randomx6] = 1;
                        renglon6tablacomputadora1[randomx6 + 1] = 1;
                        renglon6tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    case 7:
                        renglon7tablacomputadora1[randomx6] = 1;
                        renglon7tablacomputadora1[randomx6 + 1] = 1;
                        renglon7tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    case 8:
                        renglon8tablacomputadora1[randomx6] = 1;
                        renglon8tablacomputadora1[randomx6 + 1] = 1;
                        renglon8tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    case 9:
                        renglon9tablacomputadora1[randomx6] = 1;
                        renglon9tablacomputadora1[randomx6 + 1] = 1;
                        renglon9tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    case 10:
                        renglon10tablacomputadora1[randomx6] = 1;
                        renglon10tablacomputadora1[randomx6 + 1] = 1;
                        renglon10tablacomputadora1[randomx6 + 2] = 1;
                        break;
                    default:
                        break;
                }
                //ya estan generados ambos puntos iniciales, ahora QUE EMPIECE EL JUEGO :)
                // menor a 8 por que son 9 espacios, del 0 al 9
                while (contadorusuario != 9 && contadorcomputadora != 9)
                {
                    //estas dos funciones se estaran refrescando frecuentemente, representan el
                    //tablero, las mostramos inicialmente
                Tablero1usuario(renglon1tablausuario1, renglon2tablausuario1,
                renglon3tablausuario1, renglon4tablausuario1, renglon5tablausuario1,
                renglon6tablausuario1, renglon7tablausuario1, renglon8tablausuario1,
                renglon9tablausuario1, renglon10tablausuario1);
                    Tablero2usuario(renglon1tablausuario2, renglon2tablausuario2,
                    renglon3tablausuario2, renglon4tablausuario2, renglon5tablausuario2,
                    renglon6tablausuario2, renglon7tablausuario2, renglon8tablausuario2,
                    renglon9tablausuario2, renglon10tablausuario2);
                    //sabias palabras
                    Console.WriteLine("Es tu turno, escoge sabiamente.\n\n");
                    //debido a la logica del codigo, la coordenada x esta bien
                    Console.WriteLine("Escribe la coordenada 'x' de tu proximo ataque (0 - 9).");
                    int ataquex = int.Parse(Console.ReadLine());
                    //debido a la logica del codigo, a la coordenada y se le debe añadir una unidad
                    Console.WriteLine("Escribe la coordenada 'y' de tu proximo ataque (0 - 9).");
                    int ataquey = int.Parse(Console.ReadLine());
                    ataquey = ataquey + 1;
                    //comenzamos los condicionales para el ataque usuario a computadora
                    if (ataquex >= 0 && ataquex <= 9)
                    {
                        switch (ataquey)
                        {
                            case 1:
                                //entramos si no ha habido un ataque previo
                                if (renglon1tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon1tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon1tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon1tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon1tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon1tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 2:
                                //entramos si no ha habido un ataque previo
                                if (renglon2tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon2tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon2tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon2tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon2tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon2tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 3:
                                //entramos si no ha habido un ataque previo
                                if (renglon3tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon3tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon3tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon3tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon3tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon3tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 4:
                                //entramos si no ha habido un ataque previo
                                if (renglon4tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon4tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon4tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon4tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon4tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon4tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 5:
                                //entramos si no ha habido un ataque previo
                                if (renglon5tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon5tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon5tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon5tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon5tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon5tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 6:
                                //entramos si no ha habido un ataque previo
                                if (renglon6tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon6tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon6tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon6tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon6tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon6tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 7:
                                //entramos si no ha habido un ataque previo
                                if (renglon7tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon7tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon7tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon7tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon7tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon7tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 8:
                                //entramos si no ha habido un ataque previo
                                if (renglon8tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon8tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon8tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon8tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon8tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon8tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 9:
                                //entramos si no ha habido un ataque previo
                                if (renglon9tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon9tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon9tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon9tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon9tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon9tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 10:
                                //entramos si no ha habido un ataque previo
                                if (renglon10tablausuario2[ataquex] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon10tablacomputadora1[ataquex] == 1)
                                    {
                                        renglon10tablausuario2[ataquex] = 3;
                                        contadorusuario = contadorusuario + 1;
                                        Console.WriteLine("¡Tu ataque fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon10tablacomputadora1[ataquex] == 0)
                                    {
                                        renglon10tablausuario2[ataquex] = 2;
                                        Console.WriteLine("Buen intento, pero fallaste.");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon10tablausuario2[ataquex] != 0)
                                    {
                                        Console.WriteLine("Revisa tus coordenadas, repetiste ataque.");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            //default para perder turno
                            default:
                                Console.WriteLine("Perdiste tu turno por chistoso");
                                Console.ReadKey();
                                break;
                        }
                    }
                    else
                    {
                        Console.WriteLine("Perdiste tu turno por chistoso");
                        Console.ReadKey();
                    }
                    //mostramos el contador para que el usuario sepa cuanto le faltan
                    Console.WriteLine("\n\nTe faltan " + (9 - contadorusuario) + " golpes al enemigo para ganar.");
                    Console.ReadKey();
                    //repetimos las funciones para que se limpie el espacio
                    Tablero1usuario(renglon1tablausuario1, renglon2tablausuario1,
                    renglon3tablausuario1, renglon4tablausuario1, renglon5tablausuario1,
                    renglon6tablausuario1, renglon7tablausuario1, renglon8tablausuario1,
                    renglon9tablausuario1, renglon10tablausuario1);
                    Tablero2usuario(renglon1tablausuario2, renglon2tablausuario2,
                    renglon3tablausuario2, renglon4tablausuario2, renglon5tablausuario2,
                    renglon6tablausuario2, renglon7tablausuario2, renglon8tablausuario2,
                    renglon9tablausuario2, renglon10tablausuario2);
                    Console.WriteLine("Es el turno del enemigo. Es posible que se equivoque.\n\n");
                    Console.ReadKey();
                    //comenzamos los condicionales para el ataque computadora a usuario
                    //Conseguimos coordenadas aleatorias
                    //Le damos una probabilidad de 1 entre 11 que se equivoque para poner el
                    //juego interesante:)
                     int ataquecomputadorax = rnd.Next(0, 10);
                    int ataquecomputadoray = rnd.Next(0, 10);
                    //comienza el ataque de la computadora
                    if (ataquecomputadorax >= 0 && ataquecomputadorax <= 9)
                    {
                        switch (ataquecomputadoray)
                        {
                            case 1:
                                //entramos si no ha habido un ataque previo
                                if (renglon1tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon1tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon1tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon1tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon1tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon1tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon1tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon1tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 2:
                                //entramos si no ha habido un ataque previo
                                if (renglon2tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon2tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon2tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon2tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon2tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon2tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon2tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon2tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 3:
                                //entramos si no ha habido un ataque previo
                                if (renglon3tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon3tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon3tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon3tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon3tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon3tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon3tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon3tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 4:
                                //entramos si no ha habido un ataque previo
                                if (renglon4tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon4tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon4tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon4tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon4tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon4tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon4tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon4tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 5:
                                //entramos si no ha habido un ataque previo
                                if (renglon5tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon5tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon5tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon5tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon5tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon5tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon5tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon5tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 6:
                                //entramos si no ha habido un ataque previo
                                if (renglon6tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon6tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon6tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon6tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon6tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon6tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon6tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon6tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 7:
                                //entramos si no ha habido un ataque previo
                                if (renglon7tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon7tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon7tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon7tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon7tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon7tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon7tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon7tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 8:
                                //entramos si no ha habido un ataque previo
                                if (renglon8tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon8tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon8tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon8tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon8tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon8tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon8tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon8tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 9:
                                //entramos si no ha habido un ataque previo
                                if (renglon9tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon9tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon9tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon9tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon9tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon9tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon9tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon9tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            case 10:
                                //entramos si no ha habido un ataque previo
                                if (renglon10tablacomputadora2[ataquecomputadorax] == 0)
                                {
                                    //si no ha sido un ataque previo, y fue exitoso
                                    if (renglon10tablausuario1[ataquecomputadorax] == 1)
                                    {
                                        renglon10tablacomputadora2[ataquecomputadorax] = 3;
                                        renglon10tablausuario1[ataquecomputadorax] = 3;
                                        contadorcomputadora = contadorcomputadora + 1;
                                        Console.WriteLine("¡El ataque del enemigo fue efectivo!");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                    //si no ha sido un ataque previo, y no fue exitoso
                                    if (renglon10tablausuario1[ataquecomputadorax] == 0)
                                    {
                                        renglon10tablacomputadora2[ataquecomputadorax] = 2;
                                        renglon10tablausuario1[ataquecomputadorax] = 2;
                                        Console.WriteLine("¡Enhorabuena! El enemigo fallo.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                //si hubo un ataque previo
                                else
                                {
                                    if (renglon10tablacomputadora2[ataquecomputadorax] != 0)
                                    {
                                        Console.WriteLine("¡Enhorabuena! El enemigo repitio ataque.");
                                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                        ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                        Console.ReadKey();
                                    }
                                }
                                break;
                            //default para perder turno
                            default:
                                Console.WriteLine("¡El enemigo se equivoco!");
                                Console.WriteLine("El enemigo ataco en las coordenadas (" +
                                ataquecomputadorax + ", " + (ataquecomputadoray - 1) + ")");
                                Console.ReadKey();
                                break;
                        }
                    }
                    else
                    {
                        Console.WriteLine("¡El enemigo se equivoco!");
                        Console.WriteLine("El enemigo ataco en las coordenadas (" +
                        ataquecomputadorax + ", " + ataquecomputadoray + ")");
                        Console.ReadKey();
                    }
                }
                //felicitamos al usuario, si gano
                if (contadorusuario == 9)
                {
                    Console.WriteLine("¡Felicidades, ganaste la Batalla Naval!\n\n");
                    Console.ReadKey();
                }
                //avisamos al usuario que perdio
                if (contadorcomputadora == 9)
                {
                    Console.WriteLine("Mejor suerte para la proxima :(\n\n");
                    Console.ReadKey();
                }
                Console.Clear();
                Console.WriteLine("Presiona 1 si deseas volver a jugar\nPresiona cualquier otra tecla si deseas salir");
                decision1 = Console.ReadLine();
            }
            //Salimos del ciclo while, y nos despedimos
            Console.Clear();
            Console.WriteLine("Gracias por utilizar el programa, ¡hasta pronto!");
            Console.ReadKey();
        }
        //Generamos el tablero 1 (grafico) del usuario con sus 10 arreglos respectivos
        static void Tablero1usuario(int[] renglon1tablausuario1, int[] renglon2tablausuario1, int[]
        renglon3tablausuario1, int[] renglon4tablausuario1, int[] renglon5tablausuario1, int[]
        renglon6tablausuario1, int[] renglon7tablausuario1, int[] renglon8tablausuario1, int[]
        renglon9tablausuario1, int[] renglon10tablausuario1)
        {
            Console.Clear();
            //Ponemos en la posicion inicial el cursor
            Console.SetCursorPosition(0, 0);
            //Espacio, luego 1 al 10, por lo tanto comienza en x=1 y termina en x =10
            Console.WriteLine(" 0123456789");
            //Numeros Verticales, saltando un renglon, comienza en y=1 y termina en y = 10
            Console.Write("0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n");
            //Rellenamos los renglones
            //si es 0, se queda en negro, si es 1 se cambia a verde, si es 2 se cambia a blanco,
            //si es 3 se cambia a rojo
            //renglon 1
            Console.SetCursorPosition(1, 1);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon1tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon1tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon1tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon1tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon1tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon1tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon1tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon1tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 2
            Console.SetCursorPosition(1, 2);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon2tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon2tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon2tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon2tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon2tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon2tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon2tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon2tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 3
            Console.SetCursorPosition(1, 3);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon3tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon3tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon3tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon3tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon3tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon3tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon3tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon3tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 4
            Console.SetCursorPosition(1, 4);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon4tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon4tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon4tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon4tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon4tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon4tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon4tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon4tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 5
            Console.SetCursorPosition(1, 5);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon5tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon5tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon5tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon5tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon5tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon5tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon5tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon5tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 6
            Console.SetCursorPosition(1, 6);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon6tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon6tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon6tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon6tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon6tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon6tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon6tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon6tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 7
            Console.SetCursorPosition(1, 7);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon7tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon7tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon7tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon7tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon7tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon7tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon7tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon7tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 8
            Console.SetCursorPosition(1, 8);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon8tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon8tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon8tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon8tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon8tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon8tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon8tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon8tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 9
            Console.SetCursorPosition(1, 9);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon9tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon9tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon9tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon9tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon9tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon9tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon9tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon9tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 10
            Console.SetCursorPosition(1, 10);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon10tablausuario1[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon10tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon10tablausuario1[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon10tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon10tablausuario1[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon10tablausuario1[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon10tablausuario1[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon10tablausuario1[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            Console.Write("\n\n");
        }
        //Generamos el tablero 2 (grafico) del usuario con sus 10 arreglos respectivos
        static void Tablero2usuario(int[] renglon1tablausuario2, int[] renglon2tablausuario2, int[]
        renglon3tablausuario2, int[] renglon4tablausuario2, int[] renglon5tablausuario2, int[]
        renglon6tablausuario2, int[] renglon7tablausuario2, int[] renglon8tablausuario2, int[]
        renglon9tablausuario2, int[] renglon10tablausuario2)
        {
            //Ponemos en la posicion inicial el cursor
            Console.SetCursorPosition(14, 0);
            //Espacio, luego 1 al 10, por lo tanto comienza en x=1 y termina en x =10
            Console.Write(" 0123456789");
            //Como tenemos que tomar en cuenta la primera tabla, tenemos que poner la
            //posición para cada renglon
        Console.SetCursorPosition(14, 1);
            Console.Write("0");
            Console.SetCursorPosition(14, 2);
            Console.Write("1");
            Console.SetCursorPosition(14, 3);
            Console.Write("2");
            Console.SetCursorPosition(14, 4);
            Console.Write("3");
            Console.SetCursorPosition(14, 5);
            Console.Write("4");
            Console.SetCursorPosition(14, 6);
            Console.Write("5");
            Console.SetCursorPosition(14, 7);
            Console.Write("6");
            Console.SetCursorPosition(14, 8);
            Console.Write("7");
            Console.SetCursorPosition(14, 9);
            Console.Write("8");
            Console.SetCursorPosition(14, 10);
            Console.Write("9");
            //Rellenamos los renglones, ajustando a 15 por haber ocupado ya el 14
            //si es 0, se queda en negro, si es 1 se cambia a verde, si es 2 se cambia a blanco,
            //si es 3 se cambia a rojo
            //renglon 1
            Console.SetCursorPosition(15, 1);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon1tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon1tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon1tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon1tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon1tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon1tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon1tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon1tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 2
            Console.SetCursorPosition(15, 2);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon2tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon2tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon2tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon2tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon2tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon2tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon2tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon2tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 3
            Console.SetCursorPosition(15, 3);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon3tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon3tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon3tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon3tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon3tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon3tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon3tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon3tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 4
            Console.SetCursorPosition(15, 4);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon4tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon4tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon4tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon4tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon4tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon4tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon4tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon4tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 5
            Console.SetCursorPosition(15, 5);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon5tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon5tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon5tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon5tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon5tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon5tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon5tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon5tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 6
            Console.SetCursorPosition(15, 6);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon6tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon6tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon6tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon6tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon6tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon6tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon6tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon6tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 7
            Console.SetCursorPosition(15, 7);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon7tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon7tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon7tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon7tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon7tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon7tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon7tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon7tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 8
            Console.SetCursorPosition(15, 8);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon8tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon8tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon8tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon8tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon8tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon8tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon8tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon8tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 9
            Console.SetCursorPosition(15, 9);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon9tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon9tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon3tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon9tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon9tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon9tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon9tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon9tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            //renglon 10
            Console.SetCursorPosition(15, 10);
            for (int i = 0; i <= 9; i++)
            {
                if (renglon10tablausuario2[i] == 0)
                {
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.Write(renglon10tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                }
                if (renglon10tablausuario2[i] == 1)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.BackgroundColor = ConsoleColor.Green;
                    Console.Write(renglon10tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon10tablausuario2[i] == 2)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.White;
                    Console.Write(renglon10tablausuario2[i]);
                    Console.BackgroundColor = ConsoleColor.Black;
                }
                if (renglon10tablausuario2[i] == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.Write(renglon10tablausuario2[i]);
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.BackgroundColor = ConsoleColor.Black;
                }
            }
            Console.Write("\n\n");
        }
    }
}