static void Main(string[] args)
        {
            try{
                PartidaDeXadrez partida = new PartidaDeXadrez();
                while (!partida.terminada)
                {
                    try{
                        Console.Clear();
                        Tela.imprimirPartida(partida);
                        Console.Write("Origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        bool[,] posicoesPosiveis = partida.tab.peca(origem).movimentosPossiveis();

                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPosiveis);
                        Console.WriteLine();
                        Console.Write("Destino: ");

                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);
                        partida.realizaJogada(origem, destino);
                    }catch (Exception e) {
                        Console.WriteLine(e.Message);
                        Console.ReadLine();
                    }
                }
                Tela.imprimirPartida(partida);
            }catch (TabuleiroException e) {
                Console.WriteLine(e.Message);
            }
        }
Exemple #2
0
        static void Main(string[] args)
        {
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                while (!partida.terminada)
                {
                    try
                    {
                        Console.Clear();
                        Tela.imprimirPartida(partida);

                        Console.WriteLine("--------------------------------------");
                        Console.Write("Origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis();

                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis);

                        Console.WriteLine();
                        Console.WriteLine("--------------------------------------");
                        Console.Write("Destino: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException e)
                    {
                        Console.WriteLine(e.Message);
                        Console.ReadLine();
                    }
                    catch (FormatException)
                    {
                        Console.WriteLine("Como jogar, exemplo: \nOrigem: a1 \nDestino: a5");
                        Console.ReadLine();
                    }
                    catch (IndexOutOfRangeException)
                    {
                        Console.WriteLine("Jogada fora dos limites do tabuleiro");
                        Console.ReadLine();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (TabuleiroException e)
            {
                Console.WriteLine(e.Message);
            }

            Console.ReadLine();
        }
Exemple #3
0
        static void Main(string[] args)
        {
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                while (!partida.terminada)
                {
                    //meu código
                    if (partida.promocao)
                    {
                        Console.WriteLine("Peão promovido! Escolha um número:");
                        Console.WriteLine("1 - Dama");
                        Console.WriteLine("2 - Bispo");
                        Console.WriteLine("3 - Torre");
                        Console.WriteLine("4 - Cavalo");

                        string s = Console.ReadLine();
                        partida.escolhaPromocao(s);
                    }
                    try
                    {
                        Console.Clear();
                        Tela.imprimirPartida(partida);

                        Console.WriteLine();
                        Console.Write("Origem:  ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis();

                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis);

                        Console.WriteLine();
                        Console.Write("Destino:  ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException e)
                    {
                        Console.WriteLine(e.Message);
                        Console.ReadLine();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (TabuleiroException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.ReadLine();
        }
        static void Main(string[] args)
        {
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();
                while (!partida.terminada)
                {
                    try
                    {
                        Console.Clear();
                        //Tela.printBoard(partida.tab);

                        //Console.WriteLine();

                        //Console.WriteLine("Turno: " + partida.turno);

                        //Console.WriteLine("Aguardando jogada: " + partida.jogadorAtual);

                        Tela.imprimirPartida(partida);
                        Console.WriteLine();

                        Console.Write("Origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        bool[,] posicoesPossiveis = partida.tab.piece(origem).moviementosPossiveis();


                        Console.Clear();
                        Tela.printBoard(partida.tab, posicoesPossiveis);

                        Console.WriteLine();

                        Console.Write("Destino: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }
                    catch (BoardException e)
                    {
                        Console.WriteLine(e.Message);
                        Console.ReadLine();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (BoardException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.ReadLine();
        }
Exemple #5
0
        static void Main(string[] args)
        {
            /*
             * PosicaoXadrez pos = new PosicaoXadrez('c', 1);
             *
             * Console.WriteLine(pos);
             *
             * Console.WriteLine(pos.toPosicao());
             *
             * Console.ReadLine();
             */

            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();
                while (!partida.terminada)
                {
                    try
                    {
                        Console.Clear();
                        Tela.imprimirPartida(partida);

                        Console.WriteLine();
                        Console.Write("Digite a posição da peça que deseja movimentar(ORIGEM): ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis();
                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis);

                        Console.WriteLine();
                        Console.Write("Digite a posição para aonde deseja movimentar(DESTINO): ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException e)
                    {
                        Console.WriteLine(e.Message);
                        Console.ReadLine();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (TabuleiroException e)
            {
                Console.WriteLine(e.Message);
            }

            Console.ReadLine();
        }
        static void Main(string[] args)
        {
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                while (!partida.terminada)
                {
                    try
                    {
                        Console.Clear();
                        Tela.imprimirPartida(partida);

                        //CAPTURANDO PECA A SER MOVIMENTADA
                        Console.WriteLine();
                        Console.Write("Origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoOrigem(origem);

                        //VERIFICANDO POSSIVEIS MOVIMENTOS
                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis();
                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis);

                        //CAPTURANDO POSICAO DE DESTINO
                        Console.WriteLine();
                        Console.Write("Destino: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }

                    catch (TabuleiroException e)
                    {
                        Console.WriteLine(e.Message);
                        Console.ReadLine();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
            }

            catch (TabuleiroException e)
            {
                Console.WriteLine(e.Message);
            }

            Console.ReadLine();
        }
        static void Main(string[] args)
        {
            #region Boas Vindas

            Console.WriteLine($"Olá {System.Environment.GetEnvironmentVariable("Username", EnvironmentVariableTarget.Process)}!");
            System.Threading.Thread.Sleep(TimeSpan.FromSeconds(2));
            Console.Clear();
            Console.WriteLine("Bom jogo!");
            System.Threading.Thread.Sleep(TimeSpan.FromSeconds(4));

            #endregion

            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                while (!partida.terminada)
                {
                    try{
                        Console.Clear();
                        Tela.imprimirPartida(partida);

                        Posicao origem = Tela.lerPosicaoXadrez(partida).ToPosicao();
                        partida.validarPosicaoDeOrigem(origem);
                        partida.mudaTipoPosicao();

                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis();

                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis, partida);

                        Posicao destino = Tela.lerPosicaoXadrez(partida, posicoesPossiveis, origem).ToPosicao();
                        partida.validarPosicaoDestino(origem, destino);
                        partida.mudaTipoPosicao();

                        partida.realizaJogada(origem, destino);
                    } catch (TabuleiroException e) {
                        Console.WriteLine(e.Message);
                        Console.ReadKey();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
                Console.ReadKey(true);
            }
            catch (TabuleiroException e) {
                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
        }
        static void Main(string[] args)
        {
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                while (!partida.Terminada)
                {
                    try
                    {
                        Console.Clear();
                        Tela.imprimirPartida(partida);

                        Console.WriteLine();
                        Console.Write("Origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        bool[,] posicoesPossiveis = partida.Tab.peca(origem).movimentosPossiveis();

                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.Tab, posicoesPossiveis);

                        Console.WriteLine();
                        Console.Write("Destino: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException e)
                    {
                        Console.WriteLine();
                        Console.WriteLine(e.Message);
                        ConsoleColor aux = Console.ForegroundColor;
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.Write("Tecle enter para repetir a jogada!");;
                        Console.ForegroundColor = aux;
                        Console.ReadLine();
                    }
                }

                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (TabuleiroException e)
            {
                Console.WriteLine(e.Message);
            }
        }
Exemple #9
0
        static void Main(string[] args)
        {
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                while (!partida.terminada)
                {
                    try
                    {
                        Console.Clear();
                        Tela.imprimirPartida(partida);
                        Console.WriteLine(); Console.WriteLine();
                        Console.Write("Peça a mover: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        // mostrar posições possiveis para a peça escolhida para mover
                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis();
                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis);
                        Console.WriteLine(); Console.WriteLine();


                        Console.Write("Destino da Peça: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException ex)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine(ex.Message);
                        Console.ReadLine();
                        Console.ResetColor();
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadLine();
        }
Exemple #10
0
        static void Main(string[] args)
        {
            Console.SetWindowSize(55, 20);
            //Console.SetWindowSize(100, 50);
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                while (!partida.terminada)
                {
                    try
                    {
                        Console.Clear();
                        Tela.imprimirPartida(partida);
                        Console.WriteLine();
                        Console.Write("Digite a posiçao de origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        //mostra uma tela com as movimentaçoes possiveis destacadas de cada peça
                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis();
                        // na classe tela foi criado outro metodo imprimir tabulero com as posicoesPossiveis como parametro.
                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis);
                        Console.WriteLine();
                        Console.Write("Digite a posição destino: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException e)
                    {
                        Console.WriteLine(e.Message);
                        Console.ReadLine();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (TabuleiroException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.ReadLine();
        }
Exemple #11
0
        static void Main(string[] args)
        {
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                while (!partida.terminada)
                {
                    try
                    {
                        Console.Clear();
                        Tela.imprimirPartida(partida);

                        Console.WriteLine();
                        Console.Write("Origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis(); //vai pegar a posiçao digitada na origem e armazenar na matiz posicoes.Posiveis

                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis); //vai mostrar as posições possíveis para movimento das peças

                        Console.WriteLine();
                        Console.Write("Destino: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);//validarPosicaoDeDestino é método da classe PartidaDeXadrez

                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException e)
                    {
                        Console.WriteLine(e.Message);
                        Console.ReadLine();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (TabuleiroException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.ReadLine();
        }
        static void Main(string[] args)
        {
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                while (!partida.terminada)
                {
                    try
                    {
                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tabu);
                        Console.WriteLine();
                        Console.WriteLine("Turno: " + partida.turno);
                        Console.WriteLine("Aguardando jogada: " + partida.jogadorAtual);

                        Console.Write("Origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoOrigem(origem);

                        //Imprime tabuleiro com a posição marcada
                        bool[,] posicoesPossiveis = partida.tabu.peca(origem).movimentosPossiveis();
                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tabu, posicoesPossiveis);

                        Console.WriteLine();
                        Console.Write("Destino: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException msg)
                    {
                        Console.WriteLine(msg.Message);
                        Console.ReadLine();
                    }
                }
            }
            catch (TabuleiroException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.ReadLine();
        }
Exemple #13
0
        static void Main(string[] args)
        {
            try {
                PartidaDeXadrez partida = new PartidaDeXadrez();
                Tela.imprimirTabuleiro(partida.tab);

                while (!partida.terminada) // Enquanto a partida não estiver terminada
                {
                    try {
                        Console.Clear(); // Limpa a tela
                        Tela.imprimirPartida(partida);

                        Console.WriteLine();
                        Console.Write("Origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao(); // Lê a posição e transforma ela na posição de matriz do sistema
                        partida.validarPosicaoDeOrigem(origem);

                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentoPossiveis();

                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis);

                        Console.WriteLine();
                        Console.Write("Destino: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException h) {
                        Console.WriteLine(h.Message);
                        Console.WriteLine();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (TabuleiroException e) {
                Console.WriteLine(e.Message);
            }
        }
        static void Main(string[] args)
        {
            try {
                PartidaDeXadrez partida = new PartidaDeXadrez();
                while (partida.terminada == false)
                {
                    try {
                        Console.Clear();
                        Tela.imprimirPartida(partida);
                        Console.WriteLine();
                        Console.Write("ORIGEM: ");
                        Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarPosicaoDeOrigem(origem);

                        //mostrar o tabuleiro marcado com os possiveis movimentos da peça
                        bool[,] possiveisMovimentosMarcados = partida.tab.peca(origem).movimentosPossiveis();
                        Console.Clear();
                        Tela.imprimirTabuleiro(partida.tab, possiveisMovimentosMarcados);

                        Console.WriteLine();
                        Console.Write("DESTINO: ");
                        Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                        partida.validarposicaoDeDestino(origem, destino);

                        partida.realizaJogada(origem, destino);
                    }catch (TabuleiroException e) {
                        Console.WriteLine(e.Message);
                        Console.ReadLine();
                    }
                }
                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (TabuleiroException e) {
                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
        }
Exemple #15
0
        static void Main(string[] args)
        {
            try
            {
                PartidaDeXadrez partida = new PartidaDeXadrez();

                // Enquanto a partida não for terminada
                while (!partida.terminada)
                {
                    try
                    {
                        // Limpar o terminal
                        Console.Clear();

                        // Imprime tabuleiro
                        Tela.imprimirPartida(partida);

                        Console.WriteLine();

                        // Pegar a posição, e transformar ela pra posição de matriz
                        Console.Write("Origem: ");
                        Posicao origem = Tela.lerPosicaoXadrez().paraPosicao();

                        // Validando origem
                        partida.validarPosicaoDeOrigem(origem);

                        // Guardando na matriz os movimentos possíveis da peça
                        bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis();

                        // Limpar o terminal
                        Console.Clear();

                        // Imprime tabuleiro, com os movimentos possíveis para peça
                        Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis);

                        Console.WriteLine();

                        Console.Write("Destino: ");
                        Posicao destino = Tela.lerPosicaoXadrez().paraPosicao();

                        // Validando destino
                        partida.validarPosicaoDeDestino(origem, destino);

                        // E realiza a jogada
                        partida.realizaJogada(origem, destino);
                    }
                    catch (TabuleiroException e)
                    {
                        Console.WriteLine();
                        Console.WriteLine(e.Message);

                        // Esperar o jogador apertar enter para repetir a jogada
                        Console.ReadLine();
                    }
                }

                Console.Clear();
                Tela.imprimirPartida(partida);
            }
            catch (TabuleiroException e)
            {
                Console.WriteLine(e.Message);
            }

            Console.ReadLine();
        }
        static void Main(string[] args)
        {
            var cores = Enum.GetValues(typeof(Cor)).Cast <Cor>();
            int menu  = 100;
            Cor jogador1;
            Cor jogador2;

            Console.WriteLine("---  Seja bem vindo ao XADREZ ONLINE  ---");
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("-------------------------------------------------");
            Console.WriteLine("|               Iniciar partida                 |");
            Console.WriteLine("-------------------------------------------------");
            Console.WriteLine("-------------------------------------------------");
            Console.WriteLine("|                   Sair                        |");
            Console.WriteLine("-------------------------------------------------");
            Console.WriteLine("-------------------------------------------------");
            Console.WriteLine("| Digite 0 para sair e 1 para iniciar a partida |");
            Console.WriteLine("-------------------------------------------------");
            Console.Write("> ");
            menu = int.Parse(Console.ReadLine());

            while (menu != 0)
            {
                try
                {
                    Console.WriteLine();
                    if (menu == 1)
                    {
                        Console.WriteLine("Selecione uma das cores abaixo:");
                        Console.WriteLine();

                        foreach (Cor c in cores)
                        {
                            Console.WriteLine("------------------------");
                            Console.WriteLine($"|   Cor: {c}");
                            Console.WriteLine("------------------------");
                        }
                        Console.WriteLine();
                        Console.Write("Digite a cor para o primeiro jogador: ");
                        jogador1 = Enum.Parse <Cor>(Console.ReadLine());

                        foreach (Cor c in cores)
                        {
                            if (c != jogador1)
                            {
                                Console.WriteLine("------------------------");
                                Console.WriteLine($"|   Cor: {c}");
                                Console.WriteLine("------------------------");
                            }
                        }
                        Console.WriteLine();
                        Console.Write("Digite a cor para o segundo jogador: ");
                        jogador2 = Enum.Parse <Cor>(Console.ReadLine());

                        try
                        {
                            PartidaDeXadrez partida = new PartidaDeXadrez(jogador1, jogador2);

                            while (!partida.terminada)
                            {
                                try
                                {
                                    Console.Clear();
                                    Tela.imprimirPartida(partida, jogador1, jogador2);

                                    Console.WriteLine();
                                    Console.Write("Origem: ");
                                    Posicao origem = Tela.lerPosicaoXadrez().toPosicao();
                                    partida.validarPosicaoDeOrigem(origem);

                                    bool[,] posicoesPossiveis = partida.tab.peca(origem).movimentosPossiveis();

                                    Console.Clear();
                                    Tela.imprimirTabuleiro(partida.tab, posicoesPossiveis);

                                    Console.WriteLine();
                                    Console.Write("Destino: ");
                                    Posicao destino = Tela.lerPosicaoXadrez().toPosicao();
                                    partida.validarPosicaoDeDestino(origem, destino);

                                    partida.realizaJogada(origem, destino);
                                }
                                catch (TabuleiroException e)
                                {
                                    Console.WriteLine(e.Message);
                                    Console.ReadLine();
                                }
                                catch (Exception e)
                                {
                                    Console.WriteLine("Erro inexperado: " + e.Message);
                                    Console.WriteLine("Pressione enter para continuar...");
                                    Console.ReadLine();
                                }
                            }
                            Console.Clear();
                            Tela.imprimirPartida(partida, jogador1, jogador2);
                        }
                        catch (TabuleiroException e)
                        {
                            Console.WriteLine(e.Message);
                        }
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine("Erro inexperado: " + e.Message);
                }

                Console.ReadLine();
            }
        }