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");
}
}
}