static void Main(string[] args)
{
var campoMinado = new CampoMinado();
Console.WriteLine("Início do jogo\n=========");
Console.WriteLine(campoMinado.Tabuleiro);
// Realize sua codificação a partir deste ponto, boa sorte!
// Declaração de uma matriz que irá receber um cópia do campo minado; E declaração de uma string para receber o tabuleiro.
char[,] matrizTabuleiro = new char[9, 9];
string campo = "";
campo = campoMinado.Tabuleiro;
// Chama a função que copia a string do campo minado e preenche uma matriz [9,9] com os valores da string.
matrizTabuleiro = Copiar(campo, matrizTabuleiro);
// Bloco que chama a função para verificar uma casa segura dentro do tabuleiro e abrir.
while (campoMinado.JogoStatus == 0)
{
matrizTabuleiro = VerificaCasaSegura(matrizTabuleiro, campoMinado, campo);
}
Console.WriteLine("Status do Jogo: {0}", campoMinado.JogoStatus);
Console.ReadKey();
}
static void Main(string[] args)
{
var campoMinado = new CampoMinado();
Console.WriteLine("Início do jogo\n=========");
Console.WriteLine(campoMinado.Tabuleiro);
// Realize sua codificação a partir deste ponto, boa sorte!
}
static void Main(string[] args)
{
var linha = "";
var coluna = "";
int linha1;
int coluna1;
var campoMinado = new CampoMinado();
Console.WriteLine("Início do jogo\n=========");
while (campoMinado.JogoStatus == 0)
{
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine("Escolha uma linha de 1 a 9");
linha = Console.ReadLine();
int.TryParse(linha, out linha1);
while (linha1 <= 0 || linha1 > 9)
{
Console.WriteLine("Comando linha invalido. Entre com nova jogada");
linha = Console.ReadLine();
int.TryParse(linha, out linha1);
}
Console.WriteLine("Escolha uma coluna de 1 a 9");
coluna = Console.ReadLine();
int.TryParse(coluna, out coluna1);
while (coluna1 <= 0 || coluna1 > 9)
{
Console.WriteLine("Comando colunda invalido. Entre com nova jogada");
coluna = Console.ReadLine();
int.TryParse(coluna, out coluna1);
}
campoMinado.Abrir(linha1, coluna1);
switch (campoMinado.JogoStatus)
{
case 0:
Console.WriteLine("Continue jogando");
break;
case 2:
Console.WriteLine("Game Over");
Console.WriteLine(campoMinado.Tabuleiro);
break;
case 1:
Console.WriteLine("Voce venceu o jogo");
Console.WriteLine(campoMinado.Tabuleiro);
break;
}
}
Console.ReadLine();
}
static void Main(string[] args)
{
var campoMinado = new CampoMinado();
Console.WriteLine("Início do jogo\n=========");
Console.WriteLine(campoMinado.Tabuleiro);
// Realize sua codificação a partir deste ponto, boa sorte!
Random random = new Random();
int linha = 0;
int coluna = 0;
while (campoMinado.JogoStatus != 2)
{
try
{
linha = int.Parse(Console.ReadLine());
coluna = int.Parse(Console.ReadLine());
}
catch (System.FormatException)
{
System.Console.WriteLine("\nVocê não digitou um número, repita novamente.");
} finally {
campoMinado.Abrir(linha, coluna);
}
}
while (campoMinado.JogoStatus != 2)
{
System.Console.Write("\nDigite o número da linha: ");
int linha = int.Parse(Console.ReadLine());
System.Console.Write("Digite o número da coluna: ");
int coluna = int.Parse(Console.ReadLine());
campoMinado.Abrir(linha, coluna);
Console.WriteLine(campoMinado.Tabuleiro);
var pausa = Console.ReadKey();
Console.Clear();
}
if (campoMinado.JogoStatus == 1)
{
System.Console.WriteLine("\nMeus parabéns, você ganhou!");
}
else
{
Console.WriteLine(campoMinado.Tabuleiro);
System.Console.WriteLine("\nVocê perdeu, tente da próxima vez!");
System.Console.WriteLine("Quer tentar de novo?");
int resposta = 0;
while (resposta == 0)
{
try
{
System.Console.Write("(1 - Sim / 2 - Não): ");
resposta = int.Parse(Console.ReadLine());
}
catch (System.FormatException)
{
System.Console.WriteLine("\nVocê não digitou um número, repita novamente.");
}
}
if (resposta == 1)
{
Console.Clear();
Program.Main(null);
}
else
{
System.Console.WriteLine("------ FIM DE JOGO ------");
var pausa = Console.ReadKey();
}
}
}
static void Main(string[] args)
{
var campoMinado = new CampoMinado();
Console.WriteLine("Início do jogo\n=========");
Console.WriteLine(campoMinado.Tabuleiro);
// Realize sua codificação a partir deste ponto, boa sorte!
// Define as cores padrão do console.
Console.ForegroundColor = ConsoleColor.White;
// Variável para armazenar a informação da tecla.
ConsoleKeyInfo key;
//Menu para continuação do jogo.
Console.WriteLine(" -----------------------------------------------------------");
Console.WriteLine(" | BEM VINDO AO JOGO CAMPO MINADO |");
Console.WriteLine(" | |");
Console.WriteLine(" | Pressione ENTER para continuar ou ESC para sair do jogo |");
Console.WriteLine(" -----------------------------------------------------------");
// Executa um bloco de instruções para continuar o jogo.
// Critério de saída: Pressionar tecla ESC.
do
{
// Recebe uma entrada do usuário.
key = Console.ReadKey(true);
// Condicional para continuar o jogo.
if (key.Key == ConsoleKey.Enter)
{
// Executa um bloco de instruções para inserir o número da linha e coluna no tabuleiro.
// Condição de saída: Status do jogo diferente de 0 - Em aberto.
do
{
// Instância da classe MensagensDeErros.
var mensagensDeErros = new MensagensDeErros();
// Limpa a tela inicial.
Console.Clear();
// Define as cores padrão do console.
Console.ForegroundColor = ConsoleColor.White;
// Váriaveis para validar entradas dos valores.
bool linhaValida = false;
bool colunaValida = false;
bool PosicaoPreechida = false;
int linhaInserir = 0;
int colunaInserir = 0;
// Exibe para o usuário o status do jogo atual.
Console.WriteLine(" -------------------------STATUS DO JOGO------------------------------");
Console.WriteLine("| Jogo em aberto, continue procurando as casas que não possuem bombas |");
Console.WriteLine(" ---------------------------------------------------------------------");
// Recebe o tabuleiro para ser formatado.
char[,] tabuleiroReverso = ObterTabuleiroReverso(campoMinado.Tabuleiro);
// Imprimi um tabuleiro formatado.
ImprimirTabaleiroFormatado(tabuleiroReverso);
// Executa um bloco de instruções para entradas do usuário.
// Condições de saída: Intervelo Linha e Coluna entre 1 e 9, posição informada no tabuleiro não estar preenchida.
do
{
// Tratativa de exceções.
try
{ // Enquanto linhaValida for falsa repete o laço para receber entrada do usuário.
while (!(linhaValida))
{
// Defini as cores padrão do console.
Console.ResetColor();
Console.Write("\n\nPor favor, selecione a linha no intervalo entre 1 e 9 que deseja abrir: ");
int linha = int.Parse(Console.ReadLine());
// Recebe o resultado valor válido ou inválido.
linhaValida = ValidarIntervalo(linha);
// Condicional se o valor da linhaValida for falso, fora do intervalo de 1 a 9.
if (!(linhaValida))
{
// Exibe mensagem de erro para valor fora do intervalo.
mensagensDeErros.MensagemErroValorForaDoIntervalo(linha);
}
// Condicional se o retorno for verdadeiro.
else
{ // Armazena na variável o valor da linha validado.
linhaInserir = linha;
}
}
// Enquanto ColunaValida for falsa repete o laço para receber uma entrada do usuário.
while (!(colunaValida))
{
// Defini as cores padrão do console.
Console.ResetColor();
Console.Write("\nPor favor, selecione a coluna no intervalo entre 1 e 9 que deseja abrir: ");
int coluna = int.Parse(Console.ReadLine());
// Recebe o resultado valor válido ou inválido.
colunaValida = ValidarIntervalo(coluna);
// Condicional se o valor da ColunaValida for falso, fora do intervalo de 1 a 9.
if (!(colunaValida))
{
// Exibe mensagem de erro para valor fora do intervalo.
mensagensDeErros.MensagemErroValorForaDoIntervalo(coluna);
}
else
{ // Armazena na variável o valor da coluna validado.
colunaInserir = coluna;
}
}
}
// Tratativa de exceção - Não armazena a mensagem de erro.
catch (Exception)
{
// Altera cor do texto para amarelo.
Console.ForegroundColor = ConsoleColor.Yellow;
// Exibe Mensagem de erro para entrada inválida.
Console.WriteLine("\n\n\t\tENTRADA INVÁLIDA");
Console.WriteLine("\n Você informou um valor fora do intervalo entre 1 e 9 ");
continue;
}
// Recebe se o a posição selecionada está preenchida ou não.
bool resultado = PosicaoPreenchida(tabuleiroReverso, linhaInserir, colunaInserir);
// Condicional se a posição está preenchida.
if (resultado == true)
{
// Exibe mensagem de erro para posição já preenchida.
mensagensDeErros.MensagemErroPosicaoPreenchida();
}
// Condicional se a posição não preenchida.
else
{
PosicaoPreechida = false;
}
// Repete o laço enquanto linhaValida e colunaValida forem falso e posição preenchida verdadeiro.
} while ((!linhaValida) && (!colunaValida) && (!PosicaoPreechida));
// Função envia os valores para classe CampoMinado - método Abrir os valores da linha e coluna.
campoMinado.Abrir(linhaInserir, colunaInserir);
// Repetição do laço enquanto o status do jogo for diferente de 2 e 1.
} while (campoMinado.JogoStatus != 2 && campoMinado.JogoStatus != 1);
// Recebe o tabuleiro para ser formatado.
char[,] tabuleiroReversoAtualizado = ObterTabuleiroReverso(campoMinado.Tabuleiro);
// Condicional de vitória se o status do jogo for igual 1.
if (campoMinado.JogoStatus == 1)
{
Console.Clear();
// Altera a cor do texto para verde.
Console.ForegroundColor = ConsoleColor.Green;
// Exibe mensagem de vitória para o usuário.
Console.WriteLine("\t ------------------STATUS DO JOGO-----------------");
Console.WriteLine("\t |VOCÊ ENCONTROU TODAS AS CASAS QUE NÃO POSSUI BOMBA|");
Console.WriteLine("\t --------------------------------------------------");
// Exibe com todas as casas que não possuem bomba.
ImprimirTabaleiroFormatado(tabuleiroReversoAtualizado);
Console.WriteLine("\t __ __ ___ _______ _______ ______ ___ _______ __ ");
Console.WriteLine("\t| | | || || || || _ | | | _ | | | ");
Console.WriteLine("\t| |_| || ||_ _|| _ || | || | || |_| | | | ");
Console.WriteLine("\t| || | | | | | | || |_||_ | || | | | ");
Console.WriteLine("\t| || | | | | |_| || __ || || | |__| ");
Console.WriteLine("\t | | | | | | | || | | || || _ | __ ");
Console.WriteLine("\t |___| |___| |___| |_______||___| |_||___||__| |__| |__|\n ");
Console.WriteLine(" Pressione ESC para sair do jogo ");
// Finaliza a aplicação.
Environment.Exit(0);
}
// Condicional de derrota se o status do jogo não for igual a 1.
else
{
// Limpa a tela do jogo em aberto.
Console.Clear();
// Altera a cor do texto para vermelho.
Console.ForegroundColor = ConsoleColor.Red;
// Exibe mensagem de derrota para o usuário.
Console.WriteLine("\t ----------------STATUS DO JOGO---------------- ");
Console.WriteLine("\t | GAME OVER, VOCÊ ENCONTROU UMA BOMBA |");
Console.WriteLine("\t ----------------------------------------------- ");
// Exibe o tabuleiro com a posição da bomba.
ImprimirTabaleiroFormatado(tabuleiroReversoAtualizado);
Console.WriteLine("\t\t _______ _______ _______ __ __ __ ");
Console.WriteLine("\t\t| _ || || || |_| | | | ");
Console.WriteLine("\t\t| |_| || _ || _ || | | | ");
Console.WriteLine("\t\t| || | | || | | || | | | ");
Console.WriteLine("\t\t| _ | | |_| || |_| || | |__| ");
Console.WriteLine("\t\t| |_| || || || ||_|| | __ ");
Console.WriteLine("\t\t|_______||_______||_______||_| |_| |__|\n ");
Console.WriteLine(" Pressione ESC para sair do jogo ");
// Finaliza a aplicação.
Environment.Exit(0);
}
}
// Repetição do laço enquanto a tecla ESC for falsa.
} while (key.Key != ConsoleKey.Escape);
}
static void Main(string[] args)
{
var campoMinado = new CampoMinado();
Console.WriteLine("Início do jogo\n=========");
Console.WriteLine(campoMinado.Tabuleiro);
// Realize sua codificação a partir deste ponto, boa sorte!
Console.WriteLine("\n");
string percorreCampo = campoMinado.Tabuleiro;
for (var i = 0; i <= percorreCampo.Length; i++)
{
for (var j = 0; j <= percorreCampo.Length; j++)
{
if (i == 4 && j == 1)
{
campoMinado.Abrir(i, j);
}
if (i == 5 && j == 2)
{
campoMinado.Abrir(i, j);
}
if (i == 5 && j == 3)
{
campoMinado.Abrir(i, j);
}
if (i == 5 && j == 6)
{
campoMinado.Abrir(i, j);
}
if (i == 6 && j == 1)
{
campoMinado.Abrir(i, j);
}
if (i == 6 && j == 7)
{
campoMinado.Abrir(i, j);
}
if (i == 6 && j == 9)
{
campoMinado.Abrir(i, j);
}
}
}
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine();
if (campoMinado.JogoStatus == 0)
{
Console.WriteLine("Aberto!!!");
}
else if (campoMinado.JogoStatus == 1)
{
Console.WriteLine("Vitória!!!");
}
else
{
Console.WriteLine("GemeOver!!!");
}
Console.WriteLine("\n");
}
static void Main(string[] args)
{
var campoMinado = new CampoMinado();
Console.WriteLine("Início do jogo\n=========");
Console.WriteLine(campoMinado.Tabuleiro);
// Realize sua codificação a partir deste ponto, boa sorte!
List <int> bombasMarcadas = new List <int>();
List <int> vizinhosFechados;
Operacoes minhasOperacoes = new Operacoes();
Vizinho vizinhosAtuais;
string tabuleiro = campoMinado.Tabuleiro;
int statusDoJogo = campoMinado.JogoStatus;
int tamanho = tabuleiro.Length;
bool novaBombaEncontrada;
bool podeAbrirVizinhos;
int quantidadeCasasFechadas;
int bordas = 0;
int index = 0;
int linha;
int coluna;
char posicaoAtual;
int valorCasaAtual;
Console.ReadKey();
do
{
posicaoAtual = tabuleiro[index];
// Analisa se a posição atual é borda, casa fechada ou número maior do que 0;
if (posicaoAtual == '\n' || posicaoAtual == '\r')
{
bordas++;
index++;
}
else if (posicaoAtual == '0' || posicaoAtual == '-')
{
index++;
}
else
{
valorCasaAtual = int.Parse(posicaoAtual.ToString());
vizinhosAtuais = minhasOperacoes.IdentificarVizinhos(index, tabuleiro);
vizinhosFechados = minhasOperacoes.IdentificarVizinhosFechados(vizinhosAtuais, index, bordas);
quantidadeCasasFechadas = vizinhosFechados.Count;
if (quantidadeCasasFechadas == valorCasaAtual)
{
novaBombaEncontrada = minhasOperacoes.MarcaBomba(vizinhosFechados, bombasMarcadas);
if (novaBombaEncontrada)
{
index = 0;
bordas = 0;
}
else
{
index++;
}
}
else if (quantidadeCasasFechadas > valorCasaAtual)
{
podeAbrirVizinhos = minhasOperacoes.AvaliaAbrirVizinhos(bombasMarcadas, vizinhosFechados, quantidadeCasasFechadas, valorCasaAtual);
if (podeAbrirVizinhos)
{
foreach (var vizinhoFechado in vizinhosFechados)
{
linha = (int)(vizinhoFechado / 9) + 1;
coluna = (vizinhoFechado % 9) + 1;
campoMinado.Abrir(linha, coluna);
tabuleiro = campoMinado.Tabuleiro;
Console.Clear();
Console.WriteLine($"A casa da linha {linha}, coluna {coluna} foi aberta!");
Console.WriteLine(tabuleiro);
Console.ReadKey();
}
index = 0;
bordas = 0;
}
else
{
index++;
}
}
}
} while (index < tamanho && statusDoJogo == 0);
Console.Clear();
statusDoJogo = campoMinado.JogoStatus;
tabuleiro = campoMinado.Tabuleiro;
Console.WriteLine($"Status do jogo: {statusDoJogo}");
Console.WriteLine("\n \n ");
Console.WriteLine($"{tabuleiro}");
Console.WriteLine("\nFim de jogo!");
Console.ReadKey();
}
// Função que verifica uma casa segura para ser aberta e marca opções identificadas como bomba.
public static char[,] VerificaCasaSegura(char[,] matrizTabuleiro, CampoMinado campoMinado, string campo)
{
// contador será utilizado para contar as casas não abertas ao redor de cada posição.
var contador = 0;
// auxJ será utilizado para guardar a linha de um casa segura de ser aberta.
var auxJ = 0;
// auxI será utilizado para guardar a coluna de um casa segura de ser aberta.
var auxI = 0;
// contador será utilizado para contar as bombas ao redor de cada posição.
var contadorBomba = 0;
campo = campoMinado.Tabuleiro;
for (var i = 0; i < 9; i++)
{
for (var j = 0; j < 9; j++)
{
// Verificando casas seguras de abrir ao redor do valor 1.
if (matrizTabuleiro[i, j] == '1')
{
// Verificar lado direito.
if (j + 1 >= 0 && j + 1 < 9)
{
if (matrizTabuleiro[i, j + 1] == '-')
{
contador++;
auxI = i;
auxJ = j + 1;
}
else if (matrizTabuleiro[i, j + 1] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal direita inferior.
if (i + 1 >= 0 && i + 1 < 9 && j + 1 >= 0 && j + 1 < 9)
{
if (matrizTabuleiro[i + 1, j + 1] == '-')
{
contador++;
auxI = i + 1;
auxJ = j + 1;
}
else if (matrizTabuleiro[i + 1, j + 1] == '*')
{
contadorBomba++;
}
}
// Verificar abaixo
if (i + 1 >= 0 && i + 1 < 9)
{
if (matrizTabuleiro[i + 1, j] == '-')
{
contador++;
auxI = i + 1;
auxJ = j;
}
else if (matrizTabuleiro[i + 1, j] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal esquerda inferior.
if (i + 1 >= 0 && i + 1 < 9 && j - 1 >= 0 && j - 1 < 9)
{
if (matrizTabuleiro[i + 1, j - 1] == '-')
{
contador++;
auxI = i + 1;
auxJ = j - 1;
}
else if (matrizTabuleiro[i + 1, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar lado esquerdo.
if (j - 1 >= 0 && j - 1 < 9)
{
if (matrizTabuleiro[i, j - 1] == '-')
{
contador++;
auxI = i;
auxJ = j - 1;
}
else if (matrizTabuleiro[i, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal esquerda superior.
if (i - 1 >= 0 && i - 1 < 9 && j - 1 >= 0 && j - 1 < 9)
{
if (matrizTabuleiro[i - 1, j - 1] == '-')
{
contador++;
auxI = i - 1;
auxJ = j - 1;
}
else if (matrizTabuleiro[i - 1, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar superior
if (i - 1 >= 0 && i - 1 < 9)
{
if (matrizTabuleiro[i - 1, j] == '-')
{
contador++;
auxI = i - 1;
auxJ = j;
}
else if (matrizTabuleiro[i - 1, j] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal direita superior.
if (i - 1 >= 0 && i - 1 < 9 && j + 1 >= 0 && j + 1 < 9)
{
if (matrizTabuleiro[i - 1, j + 1] == '-')
{
contador++;
auxI = i - 1;
auxJ = j + 1;
}
else if (matrizTabuleiro[i - 1, j + 1] == '*')
{
contadorBomba++;
}
}
// Verifica se apenas uma das 8 possiveis posições em volta do elemento não foi aberta.
// Caso o contador esteja em 1 a condição será satisfeita o que determina que a posição '-' é bomba.
// Caso exista bomba ao redor do valor 1, se existir bomba e casas vazias abre a casa vazia.
if (contador == 1 && contadorBomba == 0)
{
matrizTabuleiro[auxI, auxJ] = '*';
}
if (contador == 1 && contadorBomba == 1)
{
// Bloco chama o metodo da classe CampoMinado para abrir um a posição.
// Exibe o resultado na tela e faz uma nova cópia do tabuleiro.
campoMinado.Abrir(auxI + 1, auxJ + 1);
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine();
campo = campoMinado.Tabuleiro;
matrizTabuleiro = Copiar(campo, matrizTabuleiro);
}
if (contador >= 1 && contadorBomba == 1)
{
campoMinado.Abrir(auxI + 1, auxJ + 1);
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine();
campo = campoMinado.Tabuleiro;
matrizTabuleiro = Copiar(campo, matrizTabuleiro);
}
contador = 0;
contadorBomba = 0;
}
// Verificando casas seguras de abrir ao redor do valor 2.
if (matrizTabuleiro[i, j] == '2')
{
// Verificar lado direito.
if (j + 1 > 0 && j + 1 < 9)
{
if (matrizTabuleiro[i, j + 1] == '-')
{
contador++;
auxI = i;
auxJ = j + 1;
}
else if (matrizTabuleiro[i, j + 1] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal direita inferior.
if (i + 1 > 0 && i + 1 < 9 && j + 1 > 0 && j + 1 < 9)
{
if (matrizTabuleiro[i + 1, j + 1] == '-')
{
contador++;
auxI = i + 1;
auxJ = j + 1;
}
else if (matrizTabuleiro[i + 1, j + 1] == '*')
{
contadorBomba++;
}
}
// Verificar abaixo
if (i + 1 > 0 && i + 1 < 9)
{
if (matrizTabuleiro[i + 1, j] == '-')
{
contador++;
auxI = i + 1;
auxJ = j;
}
else if (matrizTabuleiro[i + 1, j] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal esquerda inferior.
if (i + 1 > 0 && i + 1 < 9 && j - 1 > 0 && j - 1 < 9)
{
if (matrizTabuleiro[i + 1, j - 1] == '-')
{
contador++;
auxI = i + 1;
auxJ = j - 1;
}
else if (matrizTabuleiro[i + 1, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar lado esquerdo.
if (j - 1 > 0 && j - 1 < 9)
{
if (matrizTabuleiro[i, j - 1] == '-')
{
contador++;
auxI = i;
auxJ = j - 1;
}
else if (matrizTabuleiro[i, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal esquerda superior.
if (i - 1 > 0 && i - 1 < 9 && j - 1 > 0 && j - 1 < 9)
{
if (matrizTabuleiro[i - 1, j - 1] == '-')
{
contador++;
auxI = i - 1;
auxJ = j - 1;
}
else if (matrizTabuleiro[i - 1, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar superior
if (i - 1 > 0 && i - 1 < 9)
{
if (matrizTabuleiro[i - 1, j] == '-')
{
contador++;
auxI = i - 1;
auxJ = j;
}
else if (matrizTabuleiro[i - 1, j] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal direita superior.
if (i - 1 > 0 && i - 1 < 9 && j + 1 > 0 && j + 1 < 9)
{
if (matrizTabuleiro[i - 1, j + 1] == '-')
{
contador++;
auxI = i - 1;
auxJ = j + 1;
}
else if (matrizTabuleiro[i - 1, j + 1] == '*')
{
contadorBomba++;
}
}
// Verifica se existe bomba ao redor do valor 2, se existir 2 bombas e casas vazias abre a casa vazia
// Verifica se existe bomba ao redor do valor 2, se existir bomba e uma casa vazia marca a casa vazia como bomba
if (contador == 1 && contadorBomba == 1)
{
matrizTabuleiro[auxI, auxJ] = '*';
}
if (contador == 1 && contadorBomba == 2)
{
// Bloco chama o metodo da classe CampoMinado para abrir um a posição.
// Exibe o resultado na tela e faz uma nova cópia do tabuleiro.
campoMinado.Abrir(auxI + 1, auxJ + 1);
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine();
campo = campoMinado.Tabuleiro;
matrizTabuleiro = Copiar(campo, matrizTabuleiro);
}
if (contador > 1 && contadorBomba == 2)
{
// Bloco chama o metodo da classe CampoMinado para abrir um a posição.
// Exibe o resultado na tela e faz uma nova cópia do tabuleiro.
campoMinado.Abrir(auxI + 1, auxJ + 1);
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine();
campo = campoMinado.Tabuleiro;
matrizTabuleiro = Copiar(campo, matrizTabuleiro);
}
if (contador >= 2 && contadorBomba == 0)
{
matrizTabuleiro[auxI, auxJ] = '*';
}
contador = 0;
contadorBomba = 0;
}
// Verificando casas seguras de abrir ao redor do valor 3.
if (matrizTabuleiro[i, j] == '3')
{
// Verificar lado direito.
if (j + 1 > 0 && j + 1 < 9)
{
if (matrizTabuleiro[i, j + 1] == '-')
{
contador++;
auxI = i;
auxJ = j + 1;
}
else if (matrizTabuleiro[i, j + 1] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal direita inferior.
if (i + 1 > 0 && i + 1 < 9 && j + 1 > 0 && j + 1 < 9)
{
if (matrizTabuleiro[i + 1, j + 1] == '-')
{
contador++;
auxI = i + 1;
auxJ = j + 1;
}
else if (matrizTabuleiro[i + 1, j + 1] == '*')
{
contadorBomba++;
}
}
// Verificar abaixo
if (i + 1 > 0 && i + 1 < 9)
{
if (matrizTabuleiro[i + 1, j] == '-')
{
contador++;
auxI = i + 1;
auxJ = j;
}
else if (matrizTabuleiro[i + 1, j] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal esquerda inferior.
if (i + 1 > 0 && i + 1 < 9 && j - 1 > 0 && j - 1 < 9)
{
if (matrizTabuleiro[i + 1, j - 1] == '-')
{
contador++;
auxI = i + 1;
auxJ = j - 1;
}
else if (matrizTabuleiro[i + 1, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar lado esquerdo.
if (j - 1 > 0 && j - 1 < 9)
{
if (matrizTabuleiro[i, j - 1] == '-')
{
contador++;
auxI = i;
auxJ = j - 1;
}
else if (matrizTabuleiro[i, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal esquerda superior.
if (i - 1 > 0 && i - 1 < 9 && j - 1 > 0 && j - 1 < 9)
{
if (matrizTabuleiro[i - 1, j - 1] == '-')
{
contador++;
auxI = i - 1;
auxJ = j - 1;
}
else if (matrizTabuleiro[i - 1, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar superior
if (i - 1 > 0 && i - 1 < 9)
{
if (matrizTabuleiro[i - 1, j] == '-')
{
contador++;
auxI = i - 1;
auxJ = j;
}
else if (matrizTabuleiro[i - 1, j] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal direita superior.
if (i - 1 > 0 && i - 1 < 9 && j + 1 > 0 && j + 1 < 9)
{
if (matrizTabuleiro[i - 1, j + 1] == '-')
{
contador++;
auxI = i - 1;
auxJ = j + 1;
}
else if (matrizTabuleiro[i - 1, j + 1] == '*')
{
contadorBomba++;
}
}
// Verifica se existe bomba ao redor do valor 3, se existir 3 bombas e casas vazias abre a casa vazia
// Verifica se existe bomba ao redor do valor 3, se existir 1 bomba e 2 casas vazias marca a casa vazia como bomba
if (contador == 1 && contadorBomba == 2)
{
matrizTabuleiro[auxI, auxJ] = '*';
}
if (contador == 1 && contadorBomba == 3)
{
// Bloco chama o metodo da classe CampoMinado para abrir um a posição.
// Exibe o resultado na tela e faz uma nova cópia do tabuleiro.
campoMinado.Abrir(auxI + 1, auxJ + 1);
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine();
campo = campoMinado.Tabuleiro;
matrizTabuleiro = Copiar(campo, matrizTabuleiro);
}
if (contador >= 1 && contadorBomba == 3)
{
// Bloco chama o metodo da classe CampoMinado para abrir um a posição.
// Exibe o resultado na tela e faz uma nova cópia do tabuleiro.
campoMinado.Abrir(auxI + 1, auxJ + 1);
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine();
campo = campoMinado.Tabuleiro;
matrizTabuleiro = Copiar(campo, matrizTabuleiro);
}
contador = 0;
contadorBomba = 0;
}
// Verificando casas seguras de abrir ao redor do valor 4.
if (matrizTabuleiro[i, j] == '4')
{
// Verificar lado direito.
if (j + 1 > 0 && j + 1 < 9)
{
if (matrizTabuleiro[i, j + 1] == '-')
{
contador++;
auxI = i;
auxJ = j + 1;
}
else if (matrizTabuleiro[i, j + 1] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal direita inferior.
if (i + 1 > 0 && i + 1 < 9 && j + 1 > 0 && j + 1 < 9)
{
if (matrizTabuleiro[i + 1, j + 1] == '-')
{
contador++;
auxI = i + 1;
auxJ = j + 1;
}
else if (matrizTabuleiro[i + 1, j + 1] == '*')
{
contadorBomba++;
}
}
// Verificar abaixo
if (i + 1 > 0 && i + 1 < 9)
{
if (matrizTabuleiro[i + 1, j] == '-')
{
contador++;
auxI = i + 1;
auxJ = j;
}
else if (matrizTabuleiro[i + 1, j] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal esquerda inferior.
if (i + 1 > 0 && i + 1 < 9 && j - 1 > 0 && j - 1 < 9)
{
if (matrizTabuleiro[i + 1, j - 1] == '-')
{
contador++;
auxI = i + 1;
auxJ = j - 1;
}
else if (matrizTabuleiro[i + 1, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar lado esquerdo.
if (j - 1 > 0 && j - 1 < 9)
{
if (matrizTabuleiro[i, j - 1] == '-')
{
contador++;
auxI = i;
auxJ = j - 1;
}
else if (matrizTabuleiro[i, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal esquerda superior.
if (i - 1 > 0 && i - 1 < 9 && j - 1 > 0 && j - 1 < 9)
{
if (matrizTabuleiro[i - 1, j - 1] == '-')
{
contador++;
auxI = i - 1;
auxJ = j - 1;
}
else if (matrizTabuleiro[i - 1, j - 1] == '*')
{
contadorBomba++;
}
}
// Verificar superior
if (i - 1 > 0 && i - 1 < 9)
{
if (matrizTabuleiro[i - 1, j] == '-')
{
contador++;
auxI = i - 1;
auxJ = j;
}
else if (matrizTabuleiro[i - 1, j] == '*')
{
contadorBomba++;
}
}
// Verificar diagonal direita superior.
if (i - 1 > 0 && i - 1 < 9 && j + 1 > 0 && j + 1 < 9)
{
if (matrizTabuleiro[i - 1, j + 1] == '-')
{
contador++;
auxI = i - 1;
auxJ = j + 1;
}
else if (matrizTabuleiro[i - 1, j + 1] == '*')
{
contadorBomba++;
}
}
// Verifica se existe bomba ao redor do valor 4, se existir 4 bombas e casas vazias abre a casa vazia
// Verifica se existe bomba ao redor do valor 4, se existir 3 bombas e 1 casa vazia marca a casa vazia como bomba
if (contador == 1 && contadorBomba == 3)
{
matrizTabuleiro[auxI, auxJ] = '*';
}
if (contador == 1 && contadorBomba == 4)
{
// Bloco chama o metodo da classe CampoMinado para abrir um a posição.
// Exibe o resultado na tela e faz uma nova cópia do tabuleiro.
campoMinado.Abrir(auxI + 1, auxJ + 1);
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine();
campo = campoMinado.Tabuleiro;
matrizTabuleiro = Copiar(campo, matrizTabuleiro);
}
if (contador >= 1 && contadorBomba == 4)
{
// Bloco chama o metodo da classe CampoMinado para abrir um a posição.
// Exibe o resultado na tela e faz uma nova cópia do tabuleiro.
campoMinado.Abrir(auxI + 1, auxJ + 1);
Console.WriteLine(campoMinado.Tabuleiro);
Console.WriteLine();
campo = campoMinado.Tabuleiro;
matrizTabuleiro = Copiar(campo, matrizTabuleiro);
}
contador = 0;
contadorBomba = 0;
}
}
}
return(matrizTabuleiro);
}
