‫Bem-vindo de volta a este vídeo, você terá um pequeno desafio e deve criar o jogo da velha, como pode ver
‫aqui, apenas um jogo de console, não um jogo de formato ou algo parecido, mas apenas um jogo de
‫console, como você pode ver aqui, com nove valores ou nove campos e jogador, um pode escolher um campo depois, o jogador dois pode escolher
‫um campo e assim por diante.
‫E por exemplo, existe o campo um e dois um.
‫E agora é um oh, então este não é um zero, é um oh então o jogador para Stern é e vou inserir cinco e
‫posso ver que cinco é substituído por um X e apenas os números que você pode ver ainda estão disponíveis .
‫Então, digamos que eu insira cinco novamente como jogador um, isso me dirá a entrada incorreta.
‫Use outro campo.
‫Tudo bem.
‫Vou usar três.
‫Então, digamos que o jogador dois não entenda que você deve apenas inserir números e ele apenas insere um G ou
‫o que quer que ele diga.
‫Por favor, não insira uma entrada incorreta.
‫Use outro campo.
‫Direito.
‫Portanto, ainda é um jogador para Stern.
‫Então o que ele vai fazer?
‫Ele vai tentar vencer.
‫Portanto, este será um jogador muito próximo.
‫Vou vencer e estamos satisfeitos por ter vencido, então ele tem três cruzamentos consecutivos e bem, pressione qualquer tecla para
‫reiniciar o jogo.
‫Vou pressionar e manter e teremos uma nova rodada, então você também deve criar uma funcionalidade de redefinição.
‫Tudo bem.
‫Então é isso.
‫Tente construir isso.
‫Você precisará usar para os arrays.
‫Você precisará usar switch no caso e métodos e muitas coisas diferentes que tocamos nos
‫últimos vídeos.
‫Isso vai demorar um pouco e sua solução pode ser muito diferente da minha.
‫E sim, em geral, se você não chegar a lugar nenhum, se for muito difícil para você, não se preocupe.
‫Você pode simplesmente acompanhar e tentar entender todas as etapas que estou percorrendo e explicarei tudo
‫o que estou fazendo.
‫Mas é melhor se você realmente tentar por si mesmo, porque quando você tentar por
‫si mesmo, você encontrará soluções que irão catapultar muito a sua habilidade, porque simplesmente fazendo você aprenderá mais e apenas observando, você não
‫aprenderá como Muito de.
‫Então isso é muito importante.
‫Contanto que você encontre áreas e as conserte sozinho, é quando o aprendizado realmente entra em ação.
‫E é isso que é realmente importante que você tente por si mesmo.
‫Tudo bem.
‫Portanto, espero que você pause o vídeo agora e experimente, e isso pode levar algum tempo, então você não deve terminar
‫em cinco minutos.
‫Bem, talvez você esteja certo e consiga, mas caso contrário isso pode demorar um pouco, mais de uma hora
‫ou até mais de duas horas, dependendo da solução que você escolher.
‫E como eu disse, existem muitas maneiras diferentes de resolver esse problema.
‫E eu tenho apenas um que achei ser o mais próximo do que aprendemos até agora.
‫Portanto, está usando a funcionalidade que todos nós aprendemos até agora.
‫Portanto, nada muito novo.
‫E sim, é por isso que vou prosseguir e construir o aplicativo agora.
‫Tudo bem.
‫Como eu disse, espero que você tenha tentado criar por conta própria.
‫Vou criar um novo arquivo de projeto novo.
‫Projeto, e vou chamar isso de exercício jogo da velha, e então será um aplicativo de console mais uma vez e clique em
‫OK, agora, antes de fazer qualquer lógica complexa, onde verifico quem tem um e todos esses tipos de coisas, Vou
‫começar bem simples.
‫Vou apenas criar nosso campo de jogo primeiro.
‫E com isso quero dizer até mesmo a escrita do console.
‫Vou criar um novo método e chamar esse campo public static void set.
‫E eu o torno estático apenas para poder usá-lo no meu método principal.
‫Caso contrário, eu teria que criar um objeto de exercício de jogo da velha para usar o referido campo.
‫Mas torná-lo estático é totalmente aceitável.
‫Então, a seguir, dentro do meu método de campo definido, eu preciso escrever o console jurídico daquela linha de Vereide e ele vai se parecer
‫um pouco com isso.
‫Portanto, as aspas colocam muitos campos vazios, depois uma barra vertical, alguns campos vazios e novamente alguns campos vazios.
‫Portanto, esta é a primeira linha.
‫Em seguida, console a linha certa novamente.
‫Você também pode usar o toque duplo C, W.
‫Essa é a versão mais rápida.
‫E então dois e os pontos ou campos vazios e novamente, um cachimbo.
‫E aqui o que eu faço é prepará-lo para que possamos exibir os números.
‫E quais são os números que desejo exibir?
‫Bem, isso é algo que teremos que usar mais tarde ou criar mais tarde.
‫Portanto, por enquanto, direi apenas um, dois e três.
‫Mas, mais tarde, precisaremos mudar isso.
‫Vou adicionar isso à minha lista para substituir números por variáveis.
‫OK, agora preciso criar uma função semelhante a essa, mas aqui terei sublinhados e podemos mudar isso se vermos mais tarde que isso não é suficiente ou não
‫parece tão bom, pode facilmente mudar isso mais
‫tarde.
‫Tudo bem.
‫Então.
‫É basicamente isso, precisamos fazer isso várias vezes agora, então vou copiar isso, na verdade.
‫Vou copiar tudo isso.
‫E aí estamos nós.
‫E, finalmente, mais uma linha disso, e deve ser tudo.
‫Vamos dar uma olhada.
‫Vamos chamar esse método de Field e vamos ver como fica no console.
‫Na verdade, precisamos executar o console, mas a linha vermelha.
‫Tudo bem.
‫A chave é ainda melhor.
‫Vamos ver.
‫E nós não estamos em uma posição perfeita ainda.
‫Então, vamos dar uma olhada.
‫Certo, um problema aqui é que preciso de cinco pontos de distância, então cinco espaços vazios.
‫O mesmo aqui, um, dois, três, quatro, cinco, um, dois, três, quatro, cinco.
‫OK, assim está bom.
‫Então agora vamos usar isso e substituir as linhas onde tínhamos isso.
‫Então aqui está um pequeno teste.
‫Você sabe, trata-se de fazer com que pareça bom e há alguns testes envolvidos.
‫Vou usar a mesma abordagem aqui e vou copiar essas duas linhas e substituí-las.
‫Tudo bem.
‫Agora, antes, devemos ter dois em ambas as direções.
‫Foi testado e lá estamos nós.
‫Então isso já parece muito melhor.
‫Um dois três.
‫OK.
‫Esses números devem ser substituídos mais tarde, como eu disse.
‫Mas já é assim que podemos definir o campo.
‫Então você pode imaginar que isso já vai nos ajudar a zerar o campo mais tarde.
‫Tudo bem.
‫Em seguida, agora que temos isso, precisamos realmente criar o campo e o campo de jogo deve ser,
‫bem, um campo em termos de programação especial, criar o campo de jogo.
‫E o que ele fará é estático ou não criará o campo de jogo.
‫Mas vai ser um personagem estático do Dockray playfield.
‫Portanto, você também pode usar inteiros ou strings aqui.
‫Mas os personagens são os mais eficientes em termos de recursos.
‫Vou convocar um campo de jogo e aqui preciso ter as diferentes funções.
‫Então, uma linha com o um, dois e três e a
‫mesma coisa com o próximo.
‫Então, quatro ou cinco e seis e assim por diante.
‫Vou substituir os números em um segundo.
‫Então este é o quatro, cinco, seis, sete.
‫Na verdade, são sete, oito e nove.
‫Então, aí estamos.
‫Este é o nosso campo de jogo.
‫Agora, o que precisamos fazer é realmente substituir esses números aqui pelo campo de jogo aqui.
‫Então é assim que geralmente tocarei para você. Deve olhar no início e queremos substituir os números aqui
‫mais tarde.
‫Pelo usuário.
‫Tudo bem, então o que usamos aqui em vez de um é na verdade este campo de jogo em uma posição específica.
‫Então, na verdade, nós nos livramos dessa parte aqui.
‫OK, agora você precisa ver isso um pouco melhor.
‫Portanto, este é o campo de jogo e eu precisamos ter o campo de jogo na posição zero zero.
‫Tudo bem.
‫E agora fazemos a mesma coisa para os dois.
‫Então, zero.
‫Vamos.
‫Um e zero.
‫Vamos dois.
‫E então a segunda linha, é um zero um um e um dois se você não tiver certeza do que isso significa.
‫Portanto, este é zero zero.
‫Esta é a primeira linha.
‫E essa é a linha dois.
‫OK então.
‫Este é Rosero aqui, e este é real, e agora precisamos fazer a mesma coisa com Roe também.
‫Então isso vai ser zero.
‫Haverá um.
‫E, finalmente, temos dois para fazer dois.
‫Então, agora vamos começar de novo.
‫E ainda devemos obter o mesmo resultado para que sejamos um, dois, três e assim por diante.
‫Excelente.
‫Portanto, agora nosso campo de jogo ou campo de jogo está preparado.
‫Agora vamos verificar como podemos obter a entrada do usuário.
‫E o que precisamos, portanto, é criar.
‫Uma variável que será nosso jogador, então jogador será, digamos que comecemos com o jogador um.
‫Dissemos aquele jogador dois e você verá mais tarde porque faz sentido defini-lo como dois,
‫então precisamos da entrada do usuário e a entrada é zero.
‫E vou definir isso como zero porque nenhum dos campos aqui é zero.
‫Portanto, usá-lo usando zero é ótimo aqui.
‫E por último, precisamos de um booleano que verifique se a entrada está correta, porque se não
‫estiver, queremos bem, queremos informar o jogador e tentar obter a entrada correta.
‫Tudo bem, agora que temos isso, precisamos criar um grande ou muito longo do, enquanto o fazemos e depois de
‫muitas linhas temos a instrução selvagem.
‫E aqui, vou apenas usar true.
‫Por que eles usam do while com true?
‫Bem, isso é porque eu quero que o usuário sempre possa inserir algo no meu jogo.
‫E, neste caso, eu faço algum código em execução aqui que não será automatizado.
‫Depende da entrada do usuário.
‫Portanto, não é um loop infinito, mas sempre será verdadeiro, contanto que joguemos o jogo.
‫É por isso que precisamos fazer um tempo.
‫Verdade.
‫Tudo bem.
‫Em seguida, o que precisamos verificar é se o jogador um é quem deve jogar ou também é um jogador?
‫Então de quem é a vez?
‫Se player for igual a dois, então o dito player será igual a um e, se realmente pudermos usar elsea else player
‫será igual a dois.
‫Portanto, você pode usar El's ou então se, em nosso caso, o jogador só puder ter dois valores.
‫Mas se algo der errado e por algum motivo os jogadores aumentarem para dois, isso sempre será ou aumentou e sempre
‫será esse problema que sempre será o jogador também.
‫Então é por isso que vou ter certeza, não mais?
‫Se um jogador for igual a um, mude para o jogador dois.
‫Portanto, agora, com base em quem é a vez, preciso executar uma instrução switch.
‫Então, vou apenas dizer trocar de jogador.
‫Portanto, com base em quem é a vez, vamos executar alguns códigos.
‫Digamos que o caso seja um.
‫Portanto, significa que o jogador deve jogar uma vez.
‫E, na verdade, deixe-me adicionar algum código aqui, código errado, contanto que.
‫O programa roda, então se o seu reprodutor quiser e o que nós queremos fazer?
‫Bem, queremos verificar o que ele digitou?
‫E atribua bem o número, atribua X a esse número, então temos aqui o campo de jogo, então este é um,
‫dois, três.
‫E o que eu quero agora é se for o jogador um, então eu quero que ele seja substituído por um X.
‫Então, se ele entrar em um, por exemplo.
‫Então, para fazer isso, eu simplesmente crio outra opção aqui, alterne a entrada, porque com base na entrada, quero verificar este
‫caso para que o jogador entre em um jogador ou campo de jogo na posição zero zero
‫deve ser substituído por um X e então queremos quebrar.
‫Então terminamos, aliás, ainda estamos reclamando.
‫Isso porque não quebramos esse ciclo de alternância aqui e agora, e agora está acontecendo.
‫Então troco o campo de jogo por um X e aqui está reclamando porque usei barbante e para ter
‫certeza de que funciona, uso chaar agora.
‫Como você pode ver os apóstrofos, eles estão lá para os personagens.
‫E como você sabe, o campo de jogo contém muitos personagens.
‫Portanto, é uma matriz 2D de personagens.
‫É por isso que preciso usar dessa forma.
‫Tudo bem.
‫Então esse é um caso um.
‫E agora preciso fazer a mesma coisa para os diferentes casos que temos.
‫Portanto, para o caso dois, o que precisamos?
‫Precisamos ter zero um quatro três um.
‫Ou, na verdade, caso de zero a quatro, pois deveria ser um zero seis cinco, é um e um.
‫E se você não tem certeza do que eu faço aqui, verifique novamente, Rosero, então esta é a posição zero zero, esta é a
‫posição zero um, disposta zero dois e assim por diante.
‫Então é isso que estou fazendo aqui.
‫OK, estou substituindo-os pelos valores corretos.
‫Portanto, o sete está em dois e zero.
‫Oito é dois e um e nove é um dois e dois.
‫Então isso vai ser.
‫O que acontecerá se o jogador vencer e houver um valor?
‫E sempre vai substituí-lo por um ex.
‫Agora, o que podemos fazer agora é copiar todo o código e fazer a mesma coisa para um jogador escrever,
‫então poderíamos apenas dizer, OK, vamos copiar isso e então vamos executá-lo para o jogador realmente vou
‫mostrar você que só para você ver porque essa não é a melhor abordagem.
‫Vou adicionar outro caso aqui, caso seja também e agora precisamos sair dele também.
‫Então, na verdade, essa quebra aqui.
‫Estar aqui e aqui, nós quebramos também.
‫E temos outro caso de switch, então eu poderia copiar este código aqui, na verdade, e posso
‫colá-lo aqui, mas há uma maneira mais agradável de criar um método que simplesmente verifica.
‫É jogar um ou o jogador realmente vai retornar um X ou não.
‫Portanto, vamos prosseguir e criar este método.
‫Public static void Unter X ou oh, vou apenas mantê-lo simples, e o que eu preciso aqui é que preciso de um
‫inteiro.
‫Preciso de uma entrevista e vou ligar para aquele jogador, então o que faço agora é cortar este código
‫daqui.
‫Então, qual declaração, vou cortá-la aqui e não vou precisar mais daquela aqui, ainda vou precisar de
‫jogadores e o que vou fazer é criar um novo personagem.
‫Sinal de jogador, e vou defini-lo como um sinal vazio por enquanto, ou um caractere vazio, que não está vazio e é
‫e é um espaço aqui.
‫Portanto, agora, se um jogador é igual a um, podemos fazer isso em uma linha aqui.
‫O sinal do jogador vai ser.
‫Ex.
‫Caso contrário, se um jogador é igual a jogar, seu filho vai ser por que ou como neste caso e agora.
‫Precisamos usar nossa entrada também, então vou precisar inserir e que tipo de entrada foi?
‫A entrada era um número inteiro, certo.
‫OK, então vou usar a entrada aqui e a entrada.
‫E agora eu substituo este X aqui pelo seno do jogador.
‫Tudo bem, agora o que podemos fazer é usar este método em vez de executar este código aqui duas vezes.
‫Tudo bem, agora temos esse método.
‫Na verdade, não precisamos mais trocar de caixa porque já temos o player aqui.
‫Então dizemos jogador um, e então podemos simplesmente executar o código aqui.
‫Então vamos fazer isso.
‫Isso definiu o jogador aqui.
‫E porque temos um texto um pouco mais longo aqui, precisamos usar as chaves onde temos, porque temos
‫um código de várias linhas que queremos executar.
‫É por isso que precisamos inserir isso.
‫OK, agora posso prosseguir e livrar-me de toda esta instrução switch case aqui e só preciso chamar
‫meu método aqui.
‫Portanto, o método de chamada foi denominado Enter X ou.
‫Ah, e aqui vai dizer digite X ou O primeiro para o jogador.
‫Tudo bem.
‫Isso será o jogador e a entrada e essa será a entrada.
‫Então, eu apenas digo o jogador e a entrada é o que eu quero obter aqui.
‫Então eu faço a mesma coisa para o jogador também.
‫E o que isso fará é simplesmente configurá-lo como X ou O.
‫E executará o código corretamente para mim.
‫E, a propósito, podemos nos livrar disso porque já o substituímos, então não precisamos
‫mais disso.
‫Tudo bem, agora vamos verificar a entrada do usuário, porque ainda não fazemos isso.
‫Então, aqui, eu quero criar outro do while, do while e o que é o while?
‫Então, qual é a condição?
‫É a entrada.
‫Correto é falso.
‫Portanto, desde que a entrada esteja incorreta, quero prosseguir e tentar novamente.
‫Então, aqui, vamos pedir ao jogador para inserir seu código e.
‫Sim, para ir em frente.
‫Então, vou apenas adicionar a isso aqui.
‫Consola esse direito.
‫E jogador na posição zero.
‫Então, qual é o jogador que deve escolher o seu campo.
‫E agora precisamos obter a entrada do usuário.
‫Vou usar a conversão de entrada para INT 32 e vou usar o console que lê a linha.
‫Portanto, desejo obter a entrada do usuário e convertê-la em nossa entrada.
‫Então, ele vai usar essa string e fazer um inteiro com ela e armazenado na entrada.
‫E agora podemos prosseguir e usar a entrada.
‫A propósito, já usamos input aqui, mas isso não é problema porque é o loop do while.
‫Então, vai chegar a essa entrada e vai alterá-la para o que inserimos.
‫Então, primeiro será zero, depois será verificado novamente e, em seguida, será o que
‫inserimos.
‫Tudo bem.
‫Portanto, esta será a nossa chave aqui e agora.
‫Vamos ver.
‫Vamos ver o que acontece.
‫Tudo bem.
‫Então, aí estamos.
‫E não mostra o texto que acabamos de escrever.
‫Então, toda essa linha aqui.
‫Direito.
‫Mas se eu pressionar Enter, ele aparecerá.
‫E isso porque ainda temos a chave aqui.
‫Então, disse Field, tínhamos isso antes para que ainda pudéssemos ver o que está em nosso programa ou em nosso
‫jogo.
‫E se eu me livrar dele agora, ficaremos bem.
‫Então, jogador um Escolha seu campo e eu irei inserir um.
‫Por exemplo, agora diz jogador para escolher seu campo e vou usar esses campos diferentes.
‫Agora, o que ainda não aconteceu é que nosso texto ainda não está sendo atualizado.
‫Então, isso é algo que temos que cuidar.
‫Agora, para fazer isso, precisamos limpar nosso console.
‫Portanto, o console não está claro o que vai acontecer aqui.
‫E agora o que precisamos fazer é definir nosso campo toda vez que estivermos neste loop do.
‫Portanto, o campo set não deve ser executado em nosso principal apenas uma vez, mas deve ser executado todas
‫as vezes que estivermos no loop.
‫Isso significa que simplesmente definiremos o campo aqui.
‫Agora vamos executá-lo novamente.
‫Lá foram, por favor, escolha seu campo.
‫E vou usar, digamos, seis.
‫Agora é o lugar para virar e, portanto, agora posso ver que seis entraram de repente.
‫Agora quatro devem ser inseridos na próxima vez que eu inserir algo.
‫E aí estamos nós.
‫Portanto, ainda temos o problema de que ele seja atualizado.
‫Muito tarde.
‫Não é atualizado depois que o usuário o insere, mas é atualizado posteriormente.
‫Então, vamos verificar como podemos resolver isso.
‫E isso porque o referido campo é antes de verificarmos o jogador.
‫Então vamos fazer isso.
‫Agora verificamos o jogador e depois fazemos isso em campo.
‫Agora vamos executá-lo novamente.
‫Então, vamos escolher um campo.
‫Vou escolher o campo cinco e vemos que agora é zero ou na verdade não.
‫Agora, o jogador dois vai escolher seis.
‫Isso é um X agora.
‫Três vai ser um velho dois vai ser um X e assim por diante.
‫Portanto, temos essa funcionalidade.
‫Mas o que ainda falta é a capacidade de verificar se o usuário inseriu algo que é permitido ou
‫não, porque o que ainda posso fazer é sobrescrever.
‫Então, digamos que o jogador um escolha um jogador para escolher este novamente.
‫Como você pode ver agora de um antigo run para um X, o jogador um dirá, OK, agora eu quero ter este
‫campo.
‫Então ele vai entrar.
‫Portanto, o que precisamos fazer agora é verificar se um jogador já inseriu algo
‫e, se o fez, não queremos que o outro jogador autorize ou substitua esse campo.
‫Isso é algo que precisamos fazer neste loop while, porque aqui verificamos se a
‫entrada está correta e podemos definir a entrada incorreta se o usuário não inserir o valor correto.
‫A propósito, já que estamos nisso, também podemos resolver um problema que temos aqui.
‫Então, se eu entrar, digamos G, meu programa trava.
‫Portanto, tenho esta entrada que cria um erro para que possamos obtê-lo com um try and catch, para que possamos resolver o problema
‫com um try catch.
‫E esta vai ser uma captura de tentativa muito, muito simples.
‫Portanto, não vou torná-lo mais complexo do que isso.
‫E a única coisa que vou fazer é eu.
‫Meio que direto para o console, linha certa, digite um número.
‫Então, agora, se alguém fizer isso de novo, vou inserir qualquer coisa, certo?
‫Ainda não está travando, mas também não está gravando no console porque será reinicializado posteriormente.
‫Ou não é?
‫Bem, sim, está reiniciando muito porque não pedimos uma próxima declaração aqui.
‫Então, o que precisamos fazer a seguir é corrigir esse erro.
‫Agora precisamos verificar se a entrada é um e o campo de jogo.
‫Nessa posição, então em zero zero, que é a posição um, ainda é um caractere de um e precisamos
‫de outro colchete aqui.
‫Então esse é um caso.
‫Então disse a entrada, corrija para verdadeiro e agora precisamos fazer
‫a mesma coisa com todos os campos que temos.
‫Então, se a entrada for igual a dois e o campo de jogo ainda estiver aberto naquele campo, naquela posição,
‫então será zero.
‫Um ainda é um dois, então vá em frente e disse a entrada correta para Drew também.
‫E aqui estou faltando outro sinal de igual.
‫OK, então isso é o que precisamos copiar e colar várias vezes para que possamos capturar cada caso.
‫Então são três, quatro, cinco, seis.
‫E aqui.
‫Corri para um erro aqui sete.
‫Oito.
‫E nove e agora, é claro, preciso substituir essas posições aqui também, e preciso ajustar
‫esses caracteres.
‫Então, sete, oito, nove.
‫Agora temos o três era um zero para os atacantes em um zero.
‫Então, cinco era um um um, na verdade, seis era com um para aquele um era dois zero.
‫Tive de um e dois para dois, então agora temos todos os casos corretos.
‫Quando tudo está bem e agora precisamos de um outro mar, senão algo não está correto, então queremos informar
‫o usuário sobre isso.
‫Portanto, console a linha vermelha e você alinhará a entrada incorreta.
‫Use outro campo e também podemos ter certeza de que a entrada correta está definida como falsa.
‫O que realmente podemos fazer aqui é criar a região, então chamarei essa região e ela será
‫e.
‫Logo depois dessa peça aqui e região.
‫Então deixe-me fazer isso, e agora também quero informar sobre o que esta região faz e seu teste ou teste se o campo já
‫foi usado, porque essa é a ideia por trás de toda essa região ou por trás de todo esse código
‫selvagem que temos aqui, que verifica, OK, esse combustível é consumido ou não?
‫Se for usado, faça outra coisa.
‫Se não for usado, vá em frente e execute-o novamente.
‫Vamos ver se um usa um jogador para tentar usar outro novamente e diz, entrada incorreta,
‫use outro campo.
‫Então ele agora usa isso, ok?
‫E como você pode ver, posso simplesmente inserir os diferentes valores e tudo parece estar bem.
‫Mas como você também pode ver, o jogador um já ganhou duas vezes.
‫Então ele cruzou aqui.
‫Então, isso é algo que precisamos verificar a seguir.
‫Portanto, precisamos verificar se existe um vencedor e vamos criar uma nova região.
‫Logo abaixo do dito Campo, onde verificamos o vencedor.
‫Então aqui, nova
‫região e estou indo para e a região diretamente e região e aqui eu tenho o código completo para verificar a condição de
‫vitória.
‫E como nós fazemos isso?
‫Bem, precisamos verificar quais personagens os diferentes jogadores têm.
‫Então, nós tínhamos aquele jogador aqui assinado pelo jogador.
‫Um é um X quatro jogadores, dois é um O.
‫Então, o que precisamos verificar agora.
‫Ou, na verdade, foi da maneira certa?
‫Sim, para a peça um, é uma peça extra, dois é um oh, então esses são os personagens corretos.
‫Então, o que precisamos verificar aqui ou irei usá-lo com um array ou fazer com
‫um array de personagens de jogadores são um X e um O, e agora para cada personagem que eu tenho para cada jogador char no jogador Char's, Quero verificar
‫a condição de vitória.
‫Então o que isso fará é verificar se é verdadeiro para um X ou se é verdadeiro para um out.
‫Então aqui nós simplesmente verificamos OK, se o jogador um está ganhando ou se o jogador dois está ganhando.
‫E fazemos isso verificando
‫se play zero zero é igual a player char.
‫E o campo
‫de jogo zero um é igual ao jogador Cha e também o campo de jogo tinha zero, dois é igual ao jogador CHA.
‫Então, se for esse o caso, vá em frente e execute algum código, então aqui, vou escrever algo
‫como, por enquanto, S. C. , Temos um vencedor.
‫Tudo bem.
‫Então, eu só quero testar isso antes de escrevermos toda a instrução if, que é muito, muito mais longa.
‫Portanto, o jogador um vai ganhar a primeira linha porque esta é a única estrada em que entramos aqui.
‫Portanto, no caso de todos os três campos dentro daquela linha, o caractere ser o mesmo, temos um vencedor.
‫Então essa é praticamente a única coisa que colocamos aqui.
‫Vou dizer, OK, o jogador um será um.
‫O jogador dois será para jogador.
‫Um vai ser dois, cinco e três.
‫E temos um vencedor.
‫Você vê que a primeira linha está cheia de zeros ou O's, o que significa que temos um vencedor.
‫E agora o que precisamos fazer é substituir isso por todas as diferentes condições que podemos
‫ter.
‫Então, com todas as posições diferentes e se você olhar para o jogo, vou abri-lo novamente.
‫As condições de vitória possíveis são um, dois, três, quatro, cinco, seis, sete, oito, nove.
‫Então temos sete cinco três um cinco nove um quatro sete, dois, cinco, oito e três seis nove.
‫Portanto, temos um, dois, três, seis.
‫Mais dois, então temos oito condições diferentes nas quais temos um vencedor, e isso é basicamente o que
‫precisamos fazer aqui.
‫Portanto, precisamos criar isso oito vezes com as diferentes opções.
‫Então, vou parar com isso aqui.
‫E a cada vez precisamos usar um pedido assinado porque essas são as condições para ganhar o pedido.
‫Vou fazer isso mais seis vezes.
‫Portanto, temos um, dois, três, quatro, cinco, seis, sete, oito.
‫Isso é bom.
‫E agora, como eu disse, as diferentes condições são zero, zero e assim por diante.
‫Agora, a mesma coisa com o um um zero um um e um dois, então com uma terceira linha, dois a
‫dois zero dois um e dois dois.
‫Então temos os horizontais indo de cima para baixo.
‫Então, zero zero, um zero e dois zero.
‫Então temos um e um, na verdade, zero e um, desculpe, zero um.
‫Então um um e um dois zero, dois para um e dois dois, e agora
‫temos os diagonais, então é zero zero então verificamos zero zero, então um um e dois dois.
‫E finalmente nós temos.
‫Um, dois, um, um e.
‫Para zero, então essas devem ser as condições que temos e agora só precisamos verificar quem tem uma.
‫Então, o que verificamos aqui é esta longa declaração.
‫Se o jogador, personagem ou jogador do jogador for igual a um X, sabemos que o jogador dois tem um.
‫Portanto, a linha vermelha do console em um jogador de nova linha também tem um.
‫E aqui eu realmente preciso ser muito cuidadoso assim.
‫Tudo bem.
‫Então esse é o único caso.
‫E então o outro caso é que o outro jogador venceu.
‫Vou usar o El's aqui e vai dizer que o jogador um ganhou.
‫E também quero sair do jogo aqui.
‫Então entre aqui.
‫Então, vamos executá-lo e ver se podemos realmente reproduzir isso.
‫Então, digamos que queremos ter o diagonal.
‫Então, um, dois, cinco, três, nove.
‫E vemos que o jogador um tem um.
‫Então, o que queremos agora é reiniciar o jogo e permitir a criação de uma nova rodada para que os
‫jogadores possam correr e jogar novamente.
‫E o que também não cobrimos é um empate.
‫Portanto, ainda precisamos cobrir o empate.
‫Mas primeiro, vamos reiniciar o campo assim que tivermos um vencedor.
‫Então, o que eu quero fazer é, antes de sair, reiniciar o campo.
‫Então aqui para fazer reset de campo e para definir um campo, já temos uma função para isso ou um método.
‫Criamos este método de conjunto de campos que faz exatamente isso.
‫Ele define o campo mais uma vez.
‫Mas o que ele não faz ainda, ele não redefine nosso campo de jogo porque nosso campo de jogo atualmente está definido com
‫um valor específico.
‫Então, isso pode ser um X, isso pode ser um O e assim por diante.
‫Portanto, para ter certeza de que podemos sempre redefinir, precisamos copiar isso.
‫E é uma versão padrão.
‫E vou chamar esse campo de jogo de inicial.
‫Então é assim que é inicialmente, e é esse que nós constantemente substituímos.
‫Portanto, agora precisamos de outro método que fará a redefinição e o método de redefinição será
‫chamado de campo de redefinição de vazio público estático.
‫E o que eu preciso fazer aqui é, em primeiro lugar, definir meu campo de jogo para o campo de jogo inicial.
‫Então, como foi inicialmente e então posso definir meu campo.
‫Agora vamos reiniciar o jogo assim que o jogador vencer e isso está aqui.
‫Então o jogador um tem um ou o jogador dois tem um.
‫Então, vamos reiniciar aqui.
‫Redefina o campo.
‫A propósito, talvez devêssemos também dizer ao jogador ou ao usuário que ele pode reiniciar o jogo.
‫Então console a linha certa, por favor, e ou pressione qualquer tecla para reiniciar o jogo.
‫E ele apenas diria.
‫Console pensou Ricky, e depois, onde você define o jogo.
‫OK, vamos testar.
‫Escolha o seu campo um, dois, cinco, três, nove, um jogador, um tem uma jogada.
‫Pressione qualquer tecla para reiniciar o jogo.
‫Eu pressiono qualquer tecla e lá estão eles.
‫Reiniciámos o jogo e agora são jogadores para jogar, um jogador para jogar, como podem ver aqui, escolha o seu
‫campo.
‫Oh, vamos tentar novamente.
‫Como você pode ver, agora temos um pedido diferente.
‫Jogue dois como um.
‫Pressione qualquer tecla para reiniciar o jogo.
‫Ótimo se eu digitar algo incorreto e ainda receber esse erro, mas tudo bem.
‫E isso é exatamente o que eu queria.
‫Então eu pego.
‫Eu percebo o erro com o try.
‫Alcançar o tinha.
‫Então agora só falta uma coisa: se houver um empate e houver muitas maneiras de resolver esse
‫problema.
‫E o mais fácil é criar uma variável chamada voltas.
‫E essa variável vai se manter.
‫A quantidade de voltas que já jogamos é igual a zero.
‫Portanto, no início, temos zero voltas.
‫E cada vez que zeramos ou configuramos o campo, queremos aumentar as voltas em um.
‫Porque esse método quando é chamado?
‫Vamos verificar, disse Field.
‫É chamado Cada vez que entramos no Loop Do While, e é apenas quando há uma entrada correta
‫do usuário.
‫Agora, se tivermos este campo de curvas, também precisamos ter cuidado para redefinir esse campo de curvas assim que redefinirmos
‫todo o nosso campo.
‫Por campo, quero dizer que este é o campo do nosso jogo.
‫Mas a dissuasão é um campo porque é uma variável global.
‫Direito.
‫Então eu quero reiniciar o turno assim que reiniciarmos o jogo.
‫Portanto, reinicie o campo aqui, dizemos que o turn é igual a zero ou, para ser mais preciso, porque já aumentamos os turnos em
‫um.
‫Precisamos fazer isso logo depois.
‫Portanto, agora só precisamos verificar se essa condição é verdadeira.
‫Portanto, aqui temos a condição vencedora if an elz e aqui esta declaração if e aqui temos a declaração P&L.
‫Portanto, se não temos um vencedor, temos um drone.
‫Ou, para ser mais preciso, o turno evasivo é igual a 10.
‫Então temos um empate.
‫Portanto, o que dizemos aqui é a mesma coisa que fazemos aqui.
‫Também precisamos sair do jogo e reiniciar o jogo.
‫Portanto, campo de pesquisa e.
‫Devemos informar ao jogador que não houve vencedor, então vou apenas entrar, sorteio como texto aqui.
‫Tudo bem, agora ainda temos um problema no jogo, então vamos, antes de tudo, empatar.
‫Vamos verificar o sorteio primeiro.
‫Então, um, dois, três, quatro.
‫Seis, cinco.
‫Oito, nove e sete, e vemos que ficamos bêbados, basta pressionar qualquer tecla para reiniciar o jogo e funcionar
‫também.
‫Agora vamos tentar novamente.
‫Bem, na verdade, não tentando, mas ganhando.
‫E vemos o jogador dois quando um pressiona enter e nosso jogo não reinicia.
‫E isso tem a ver com nossa variável estática aqui.
‫Portanto, esta inicial do campo de jogo do personagem.
‫E o que eu preciso fazer é me livrar dele aqui e preciso torná-lo desbloqueado para criar
‫uma variável local, que estará dentro do nosso campo de redefinição.
‫Então, vou apenas criar este campo de jogo inicial e vou defini-lo no meu campo de jogo.
‫Então, vamos testar isso mais uma vez.
‫Um dois três quatro cinco seis sete.
‫Jogue um tem um.
‫OK, agora, um, dois, três, quatro, cinco, seis, sete.
‫Jogar dois é um.
‫E Ricky e você vêem que é reiniciado.
‫Agora, algo que descobri foi testado e vi que ainda havia um pequeno erro é
‫dois, um, três.
‫Quatro, depois cinco, seis e oito.
‫E como você pode ver, temos uma condição em que o jogador tem um, mas não está preso ou não
‫está preso ou preso aqui.
‫Assim, ele pode ver que o jogador dois tem um.
‫Mesmo que o jogador um tenha um com zero zero zero.
‫Oh.
‫Portanto, ainda há um pequeno problema nas minhas condições aqui.
‫E você já deve ter percebido isso antes.
‫Vou mostrar como consertar isso.
‫E essa deve ser esta condição aqui.
‫Então, zero um, então é um um.
‫E este não deve ser um dois, mas deve ser dois um.
‫Agora vamos testar novamente.
‫Vamos ver se pegamos essa condição, então um, dois, três, cinco, quatro, oito, e vemos o jogador dois como
‫um.
‫Tudo bem.
‫Então nós temos aquele e sim, é basicamente isso.
‫Nosso jogo funciona e faz o que deveria.
‫Existem algumas coisas que você ainda pode melhorar, é claro.
‫Então, por exemplo, este sinal de caractere.
‫Então, entregamos uma entrada e verificamos essa entrada mais uma vez, criamos um sinal de caractere e assim por diante.
‫Mas poderíamos tornar as coisas ainda mais fáceis para não levarmos o próprio player para cá.
‫Mas o que pegamos é um personagem que é o personagem do jogador ou o sinal do jogador.
‫Então deve ser isso.
‫Pode ser a mesma coisa.
‫Assim, o sinal do jogador faz mais sentido porque o usamos aqui.
‫Então, não precisaríamos criar todo esse código aqui.
‫Então, vamos nos livrar disso.
‫E, em vez disso, quando chamamos esse método, o que fazemos aqui, entregamos o personagem.
‫Então, para o jogador um, dissemos que era o O, eu acho, e para o jogador dois, era o X, então isso fará a
‫mesma coisa.
‫E agora diminuímos um pouco nossas linhas de código e você pode ir em frente e melhorar o código ainda
‫mais.
‫Mas isso foi apenas um código que eu acho que você deve ser capaz de escrever com base no que aprendeu
‫até agora neste curso.
‫Tudo bem, então espero que você consiga fazer isso, embora pareça muito diferente no seu caso e por favor, vá em frente
‫e compartilhe sua solução ou se você pegou minha solução que eu tenho aqui e a melhorou, por favor, vá em
‫frente e compartilhe como Nós vamos.
‫E sim, é basicamente isso.
‫Um vídeo bem longo.
‫Eu sei que.
‫Mas espero que você tenha aprendido muito com isso.
‫E mesmo que você não tenha feito isso, você apenas acompanhou e tentou construí-lo.
‫Então nos vemos no próximo vídeo.
‫Onde vamos examinar um tópico diferente.
‫Então, vejo você lá.