Visitante!
Faça seu Login ou Registre-se!

Galeria de Jogos

[C#] Tic tac toe - Utilizando o Windows forms para criar mini-jogos I 3 Respostas | 206 Visualizações

0 Membros e 1 Visitante estão vendo este tópico.

MayLeone

  • *
  • Mensagens: 463 Ouro: 1124

    Vencedor CRM Awards - Melhor Eventer Membros que se destacaram no Mega-Evento de Reconstrução

  • CRM
    • Unity
    • Ver perfil
  • Óculos do Rickas
C# - Tutoriais de mini-jogos para iniciantes! - 1



Introdução:
Olá, pessoal! Como estão? Hoje estarei começando uma série de tutoriais voltados à linguagem de programação em C# para iniciantes!
Espero que esse conteúdo ajude o pessoal da comunidade em ter um certo conhecimento em C#, mesmo porque isso seria bem útil em nosso cenário visto que a engine Unity utiliza o C# na programação.  :e.e:
Gostaria de enfatizar que também estou aprendendo C#, sou uma iniciante assim como muitos, mas estou tentando aprender essa linguagem de programação e me dedicando em colocar o que foi absorvido na prática desenvolvendo códigos mais simples de início, por isso os tutoriais que estarei postando aqui serão voltados ao público iniciante, tudo com relação ao o que eu aprendi e julgue ser de utilidade pública.



O que preciso para programar em C# inicialmente?
No tutorial de hoje nós vamos utilizar o Visual C# Express por ser mais leve (mas você pode estar utilizando o Visual Studio que também é excelente e possui a mesma interface), para criarmos um mini-game de jogo da velha apenas utilizando variáveis de uma classe pública, e algumas condições, vamos lá?



Criando seu novo projeto:
Abra o Visual C# Express, e vá em ''File >> New Project >> Windows Form Application."
No campo "Name", você digitará "Jogo da velha" ou qualquer outro nome que você queira dar ao aplicativo:
Spoiler
[close]


As lacunas do jogo da velha no formulário:
Agora com o formulário aberto você irá na opção ''toolbox'' (caixa de ferramentas) encontrada no canto esquerdo da tela, e selecione a opção ''Button'', arrastando-o para seu formulário.
Ajeite as dimensões do botão para que ele fique um quadrado, pois esses botões serão as grades do jogo da velha, onde os desenhos dos ''x'' e dos ''o'' ficarão inscritos:



Como não queremos que esses botões tenham algo escrito, porque eles serão as grades do jogo, dê um clique no botão, que daí no canto inferior direito da sua tela aparecerá a janela de propriedades do evento, nessa janela você vai na opção ''Text'' e onde está escrito ''button1'' você simplesmente apaga:



A grade do jogo da velha possui 3 linhas e 3 colunas, portanto ainda faltam mais 8 botões para formarmos a grade completa. Tendo isso em mente, de um CTRL +C CTRL + V no botão criado, e crie mais 8 botões novos, os dispondo em 3 linhas e 3 colunas, assim:



Vamos também registrar as pontuações de cada jogador e os empates: Para isso criamos três ''labels'' com os nomes: "P1 Vitórias", "P2 Vitórias" e "Empates".
Vá novamente à toolbox e selecione a opção ''label'' e arraste 3 labels distintas para seu formulário:



Vamos também criar mais 3 labels para exibir as variáveis dessas informações. Todas elas com o texto inicial ''Nada'':


E por fim, criaremos mais um botão, só que dessa vez esse botão será para ''limpar a tela'' e resetar o jogo, para que os players possam jogar de novo quando o jogo terminar:


Inicializando as variáveis globais:
Agora que já terminamos de configurar o design do formulário vamos programar os botões.
Dê um duplo clique no primeiro botão e abra a tela de scripts.
Dentro do bloco do método do botão da primeira lacuna da grade do jogo nós iremos programar o que acontecerá quando o player clicar aqui:

Spoiler
[close]

Mas acima desse código vamos criar uma classe pública do programa, para que possamos definir as variáveis globais onde poderemos acessá-las em qualquer método do script:

Código: [Selecionar]
public class Global
        {

        }

Dentro dessa classe criaremos a definição de dois tipos de variáveis: inteiro e boleanos (lógicos):

Código: [Selecionar]
  public class Global
        {
            public static bool
                public static int

        }

A variável boleana será a variável que irá definir se está na vez do jogador 1 (false) ou na vez do jogador 2 (true), e também teremos uma variável para definir se os botões estão desabilitados, impedindo que os jogadores cliquem nas grades após ser anunciado o vencedor ou o empate. Os botões só voltarão a ficar habilitados quando o jogador clicar no botão ''Reset".
Então vamos definir as duas variáveis lógicas:

Código: [Selecionar]
public class Global
        {
            public static bool turn, button_disable;
                public static int

        }

Agora vamos definir as variáveis inteiras que irão contabilizar as vitórias de cada jogador, e o empate, e também quantas rodadas se passaram no jogo:

Código: [Selecionar]
  public class Global
        {
            public static bool turn, button_disable;
            public static int player1_wins = 0, player2_wins = 0, tie = 0, rounds = 0;

        }

Ainda dentro da definição das variáveis inteiras vamos definir variáveis distintas para cada grade do jogo: Vamos chamar a variável da primeira grade de "A", da segunda grade de "B" e assim sucessivamente:

Código: [Selecionar]
public class Global
        {
            public static bool turn, button_disable;
            public static int player1_wins = 0, player2_wins = 0, tie = 0, rounds=0,  A = 0, B = 0, C = 0, D = 0, E = 0, F = 0, G = 0, H = 0, I = 0;

        }

Dica: Nessa parte você pode utilizar uma array também, caso deseje o código mais compacto!

Clicando nas lacunas:
Feito isso, vá ao método do primeiro botão da grade (que a partir de agora chamaremos de "A").
O que acontecerá quando o jogador clicar aqui? Ou vai aparecer um "X" ou um "O", certo? Então vamos criar uma condição que verifique três casos ao mesmo tempo:

Primeiro: Se está na vez do jogador 1 ou na vez do jogador 2;
Segundo: Se o botão está habilitado na grade;
Terceiro: Se essa grade ainda não está ocupada.
Crie a condição da seguinte forma:

Código: [Selecionar]
  if (Global.turn == false && Global.button_disable == false && Global.A == 0)
            {

            }

A primeira verificação irá analisar se a variável lógica ''turn'' é false ou true, sendo false a vez do jogador 1.
A segunda verificação acontecerá em torno do botão, se está habilitado (false).
E por fim, a terceira verificação é com relação se está grade está ocupada: Caso a variável "A" seja 0, isso significa que a grade está vazia e poderá ser preenchida, caso seja um número diferente de zero, isso significa que a grade já está ocupada e o jogador não poderá colocar sua peça aqui.

Dentro da condição você irá colocar para que o botão agora tenha escrito o texto "X", a variável A fique igual a 1, a variável ''rounds'' aumente 1 e a variável turn fique true, dando a vez para o próximo jogador:

Código: [Selecionar]
if (Global.turn == false && Global.button_disable == false && Global.A == 0)
            {
                button1.Text = "X";
                Global.A = 1;
                Global.rounds++;
                Global.turn = true;
            }

Agora faremos mais uma condição com as mesmas verificações, mas agora para o jogador 2, sendo a variável ''turn'' tendo que ser ''true'' o texto deve ser "O", e a variável "A" deve ficar igualada a 2, bem como a variável turn agora deve ficar false:

Código: [Selecionar]
private void button1_Click(object sender, EventArgs e)
        {
            // Verificação da jogada do player 1(X):

            if (Global.turn == false && Global.button_disable == false && Global.A == 0)
            {
                button1.Text = "X";
                Global.A = 1;
                Global.rounds++;
                Global.turn = true;
            }
            // Verificação da jogada do player 2(O):
            if (Global.turn == true && Global.button_disable == false && Global.A == 0)
            {
                button1.Text = "O";
                Global.A = 2;
                Global.rounds++;
                Global.turn = false;
            }

        }

Você pode pressionar F5 no seu teclado para debugar o código e testar: Clique na primeira lacuna da grade e veja que aparecerá o X ali, e note que se você tentar clicar novamente nessa lacuna, o X não é substituído pelo O:



Agora que está tudo okay, volte no método do botão A, e adicione o seguinte comando:
checkingWinners(); nas condições de cada jogador:

Código: [Selecionar]
if (Global.turn == false && Global.button_disable == false && Global.A == 0)
            {
                button1.Text = "X";
                Global.A = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }
            // Verificação da jogada do player 2(O):
            if (Global.turn == true && Global.button_disable == false && Global.A == 0)
            {
                button1.Text = "O";
                Global.A = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }

        }

Aqui nós estaremos chamando um método de verificação para ver quem ganhou no jogo ou se deu empate.
Para não nos depararmos com futuros erros ao debugar o teste, abaixo do método desse botão crie um método privado com o nome checkingWinner() e vamos por enquanto deixar vazio, porém já já nós vamos escrever o que ele fará:

private void checkingWinner()
        {

        }



Volte para a janela do formulário e dê um duplo clique no botão ao lado do botão A:
Copie o código do botão A e cole dentro do método do botão B, substituindo nas verificações a variável A por B, nas atribuições onde está A coloque B, onde está escrito ''button1'' você coloca ''button2'' e seu código ficará assim:

Código: [Selecionar]
private void button2_Click(object sender, EventArgs e)
        {
            if (Global.turn == false && Global.button_disable == false && Global.B == 0)
            {
                button2.Text = "X";
                Global.B = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }
            if (Global.turn == true && Global.button_disable == false && Global.B == 0)
            {
                button2.Text = "O";
                Global.B = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }

        }

Debuge (F5) e veja que agora você tem os turnos dos jogadores alternados, pois agora temos o jogador X e o jogador O:



Só temos dois botões programados, o que você deve fazer agora é colar o código do primeiro botão dentro dos métodos dos outros sete botões (dando um duplo clique em cada um para abrir seu método automaticamente) e não se esquecendo de substituir as variáveis como fizemos acima.
Depois de programar cada botão, você terá um código assim:

Código: [Selecionar]
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace Jogo_da_velha
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        public class Global
        {
            public static bool turn, button_disable;
            public static int player1_wins = 0, player2_wins = 0, tie = 0, rounds = 0, A = 0, B = 0, C = 0, D = 0, E = 0, F = 0, G = 0, H = 0, I = 0;

        }

        private void button1_Click(object sender, EventArgs e)
        {
            // Verificação da jogada do player 1(X):

            if (Global.turn == false && Global.button_disable == false && Global.A == 0)
            {
                button1.Text = "X";
                Global.A = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }
            // Verificação da jogada do player 2(O):
            if (Global.turn == true && Global.button_disable == false && Global.A == 0)
            {
                button1.Text = "O";
                Global.A = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }

        }

        private void checkingWinner()
        {

        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (Global.turn == false && Global.button_disable == false && Global.B == 0)
            {
                button2.Text = "X";
                Global.B = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }
           
            if (Global.turn == true && Global.button_disable == false && Global.B == 0)
            {
                button2.Text = "O";
                Global.B = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }

        }

        private void button3_Click(object sender, EventArgs e)
        {
            if (Global.turn == false && Global.button_disable == false && Global.C == 0)
            {
                button3.Text = "X";
                Global.C = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }

            if (Global.turn == true && Global.button_disable == false && Global.C == 0)
            {
                button3.Text = "O";
                Global.C = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }

        }

        private void button4_Click(object sender, EventArgs e)
        {
            if (Global.turn == false && Global.button_disable == false && Global.D == 0)
            {
                button4.Text = "X";
                Global.D = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }

            if (Global.turn == true && Global.button_disable == false && Global.D == 0)
            {
                button4.Text = "O";
                Global.D = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }
        }

        private void button5_Click(object sender, EventArgs e)
        {
            if (Global.turn == false && Global.button_disable == false && Global.E == 0)
            {
                button5.Text = "X";
                Global.E = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }

            if (Global.turn == true && Global.button_disable == false && Global.E == 0)
            {
                button5.Text = "O";
                Global.E = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }
        }

        private void button6_Click(object sender, EventArgs e)
        {
            if (Global.turn == false && Global.button_disable == false && Global.F == 0)
            {
                button6.Text = "X";
                Global.F = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }

            if (Global.turn == true && Global.button_disable == false && Global.F == 0)
            {
                button6.Text = "O";
                Global.F = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }
        }

        private void button7_Click(object sender, EventArgs e)
        {
            if (Global.turn == false && Global.button_disable == false && Global.G == 0)
            {
                button7.Text = "X";
                Global.G = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }

            if (Global.turn == true && Global.button_disable == false && Global.G == 0)
            {
                button7.Text = "O";
                Global.G = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }
        }

        private void button8_Click(object sender, EventArgs e)
        {
            if (Global.turn == false && Global.button_disable == false && Global.H == 0)
            {
                button8.Text = "X";
                Global.H = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }

            if (Global.turn == true && Global.button_disable == false && Global.H == 0)
            {
                button8.Text = "O";
                Global.H = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }
        }

        private void button9_Click(object sender, EventArgs e)
        {
            if (Global.turn == false && Global.button_disable == false && Global.I == 0)
            {
                button9.Text = "X";
                Global.I = 1;
                Global.rounds++;
                checkingWinner();
                Global.turn = true;
            }

            if (Global.turn == true && Global.button_disable == false && Global.I == 0)
            {
                button9.Text = "O";
                Global.I = 2;
                Global.rounds++;
                checkingWinner();
                Global.turn = false;
            }
        }
    }
}

Se você programou tudo corretamente, ao debugar você poderá clicar em qualquer lacuna da grade e terá as peças sendo dispostas conforme seus cliques, alternando nos turnos de cada jogador:



Veja que no exemplo acima o jogador 1 teria ganho, tendo a vitória na diagonal, mas como ainda não programamos a checagem de vitórias e empates, nada ocorreu.
Vamos acabar com esse problema agora?



Verificando as vitórias e empates:
Volte ao método checkingWinner() e vamos primeiramente checar se o jogador 1 venceu.
Para nos auxiliar nessa etapa, esboce uma grade de jogo da velha num editor de imagens e nomeie as lacunas de A à I conforme nosso código, para visualizarmos mais facilmente as possibilidades de vitórias:



Perceba que o jogador pelas horizontais pode ganhar colocando as peças nas seguintes lacunas:

Primeiro: a, b, c
Segundo: d, e, f
Terceiro: g,h,i

Então faremos as verificações na horizontal do jogador 1 com base se as variáveis estiverem igualadas a 1.
Dentro das condições exibiremos a mensagem em popup anunciando que o jogador 1 venceu, adicionaremos +1 à variável player1_wins, atualizaremos as labels que mostram os pontos, e desabilitaremos os botões:

Código: [Selecionar]
private void checkingWinner()
        {
            // Verificações de vitórias do jogador 1(X) nas horizontais:
            if (Global.A == 1 && Global.B == 1 && Global.C == 1)
            {
                Global.player1_wins++;
                label4.Text = Convert.ToString(Global.player1_wins);
                MessageBox.Show("Jogador 1 venceu!");
                Global.button_disable = true;
            }

            if (Global.D == 1 && Global.E == 1 && Global.F == 1)
            {
                Global.player1_wins++;
                label4.Text = Convert.ToString(Global.player1_wins);
                MessageBox.Show("Jogador 1 venceu!");
                Global.button_disable = true;
            }

            if (Global.G == 1 && Global.H == 1 && Global.I == 1)
            {
                Global.player1_wins++;
                label4.Text = Convert.ToString(Global.player1_wins);
                MessageBox.Show("Jogador 1 venceu!");
                Global.button_disable = true;
            }

        }

Veja no print abaixo uma vitória do jogador 1 pelas horizontais (D, E, F):



Para não termos que ficar colando sempre esse trecho da vitória e tornar o código extenso e pesado, podemos criar um método privado com o nome wins(): Nesse método nós iremos verificar uma nova variável inteira (com o nome de p1) - que será definida lá na classe global- e definiremos que se ela for 1, daremos a vitória para o jogador 1, se for 2 a vitória é do jogador 2:

Código: [Selecionar]
private void wins()
        {
            if (Global.p1 == 1)
            {
                Global.player1_wins++;
                label4.Text = Convert.ToString(Global.player1_wins);
                MessageBox.Show("Jogador 1 venceu!");
                Global.button_disable = true;
            }
            else  if  (Global.p1 == 2)
           {
                Global.player2_wins++;
                label5.Text = Convert.ToString(Global.player2_wins);
                MessageBox.Show("Jogador 2 venceu!");
                Global.button_disable = true;
            }

        }

Nas condições das verificações das vitórias pelas horizontais apague o que tem dentro e coloque para que a variável p1 fique 1 e chame o método wins:

Código: [Selecionar]
// Verificações de vitórias do jogador 1(X) nas horizontais:
            if (Global.A == 1 && Global.B == 1 && Global.C == 1)
            {
                Global.p1 = 1;
                wins();
            }

            if (Global.D == 1 && Global.E == 1 && Global.F == 1)
            {
                Global.p1 = 1;
                wins();
            }

            if (Global.G == 1 && Global.H == 1 && Global.I == 1)
            {
                Global.p1 = 1;
                wins();
            }

Vamos agora programar as vitórias do jogador 1 pelas verticais, podendo ser:

Primeiro: a, d, g
Segundo: b, e , h
Terceiro: c, f, i

As verificações devem estar assim:

Código: [Selecionar]
// Verificações de vitórias do jogador 1(X) nas verticais:
            if (Global.A == 1 && Global.D == 1 && Global.G == 1)
            {
                Global.p1 =1;
                wins();
            }

            if (Global.B == 1 && Global.E == 1 && Global.H == 1)
            {
                Global.p1 = 1;
                wins();
            }

            if (Global.C == 1 && Global.F == 1 && Global.I == 1)
            {
                Global.p1 =1;
                wins();
            }

E por fim, as verificações de vitórias do player 1 pelas duas diagonais: a, e, i ou c, e, g:

Código: [Selecionar]
// Verificações de vitórias do jogador 1(X) nas diagonais:
            if (Global.A == 1 && Global.E == 1 && Global.I == 1)
            {
                Global.p1 = 1;
                wins();
            }

            if (Global.C == 1 && Global.E == 1 && Global.G == 1)
            {
                Global.p1 = 1;
                wins();
            }

Agora você pode copiar todo esse código e colar nesse mesmo método (checkingWinner) só que com as verificações referentes ao player 2, ou seja, onde temos em cada condição Global.variavelTal == 1, substitua por 2 e onde há Global.p1 == 1 coloque 2.
No final, seu método deve estar assim:

Código: [Selecionar]
private void checkingWinner()
        {
            // Verificações de vitórias do jogador 1(X) nas horizontais:
            if (Global.A == 1 && Global.B == 1 && Global.C == 1)
            {
                Global.p1 = 1;
                wins();
            }

            if (Global.D == 1 && Global.E == 1 && Global.F == 1)
            {
                Global.p1 = 1;
                wins();
            }

            if (Global.G == 1 && Global.H == 1 && Global.I == 1)
            {
                Global.p1 = 1;
                wins();
            }

            // Verificações de vitórias do jogador 1(X) nas verticais:
            if (Global.A == 1 && Global.D == 1 && Global.G == 1)
            {
                Global.p1 = 1;
                wins();
            }

            if (Global.B == 1 && Global.E == 1 && Global.H == 1)
            {
                Global.p1 = 1;
                wins();
            }

            if (Global.C == 1 && Global.F == 1 && Global.I == 1)
            {
                Global.p1 = 1;
                wins();
            }

            // Verificações de vitórias do jogador 1(X) nas diagonais:
            if (Global.A == 1 && Global.E == 1 && Global.I == 1)
            {
                Global.p1 = 1;
                wins();
            }

            if (Global.C == 1 && Global.E == 1 && Global.G == 1)
            {
                Global.p1 = 1;
                wins();
            }

            // Verificações de vitórias do jogador 2(O) nas horizontais:
            if (Global.A == 2 && Global.B == 2 && Global.C == 2)
            {
                Global.p1 = 2;
                wins();
            }

            if (Global.D == 2 && Global.E == 2 && Global.F == 2)
            {
                Global.p1 = 2;
                wins();
            }

            if (Global.G == 2 && Global.H == 2 && Global.I == 2)
            {
                Global.p1 = 2;
                wins();
            }

            // Verificações de vitórias do jogador 2(O) nas verticais:
            if (Global.A == 2 && Global.D == 2 && Global.G == 2)
            {
                Global.p1 = 2;
                wins();
            }

            if (Global.B == 2 && Global.E == 2 && Global.H == 2)
            {
                Global.p1 = 2;
                wins();
            }

            if (Global.C == 2 && Global.F == 2 && Global.I == 2)
            {
                Global.p1 = 2;
                wins();
            }

            // Verificações de vitórias do jogador 2(O) nas diagonais:
            if (Global.A == 2 && Global.E == 2 && Global.I == 2)
            {
                Global.p1 = 2;
                wins();
            }

            if (Global.C == 2 && Global.E == 2 && Global.G == 2)
            {
                Global.p1 = 2;
                wins();
            }

        }

Temos agora verificações das vitórias para o jogador 1 e para o jogador 2, por fim, faremos a verificação se deu empate, ou seja, se não há vencedores (p1 =0) e se já se passaram 9 rodadas (todas as lacunas foram preenchidas.)
Essa checagem também será feita no método checkingWiiner():

Código: [Selecionar]
if (Global.p1 == 0 && Global.rounds == 9)
            {
                Global.tie++;
                label6.Text = Convert.ToString(Global.tie);
                MessageBox.Show("Empate");
                Global.button_disable = true;

            }

Programando o reset:
Nosso aplicativo está quase completo, só precisamos programar o botão de reset para que os jogadores possam reiniciar o jogo;
Volte ao formulário e dê um duplo clique no botão ''reset'' e dentro do método dele faça o seguinte:

Código: [Selecionar]
private void button10_Click(object sender, EventArgs e)
        {
            Global.A = 0;
            Global.B = 0;
            Global.C = 0;
            Global.D = 0;
            Global.E = 0;
            Global.F = 0;
            Global.G = 0;
            Global.H = 0;
            Global.I = 0;
            Global.rounds = 0;
            button1.Text = " ";
            button2.Text = " ";
            button3.Text = " ";
            button4.Text = " ";
            button4.Text = " ";
            button5.Text = " ";
            button6.Text = " ";
            button7.Text = " ";
            button8.Text = " ";
            button9.Text = " ";
            Global.button_disable = false;

            if (Global.p1 == 1 || Global.p1 == 0)
            {
                Global.turn = false;
                Global.p1 = 0;
            }
            else if (Global.p1 == 2)
            {
                Global.turn = true;
                Global.p1 = 0;
            }
        }

Aqui nós iremos limpar todas as lacunas e zerar todas as variáveis de verificação, também irá analisar quem ganhou, pois dependendo de quem ganhou, vai iniciar na próxima rodada.

Se você fez tudo conforme o tutorial, seu script deve estar assim ao final de tudo:

Clique aqui para ver!

Finalizando:
E o tutorial chegou ao fim! Debugue o código e veja se está tudo correto, qualquer dúvida ou bug pode me enviar que eu tentarei auxiliar!
Lembrando que existem muitas formas de programar algo, e com certeza existe um jeito alternativo para desenvolver esse mini game, mas a intenção era utilizar conceitos primários da linguagem para ajudar no aprendizado dos iniciantes.
Espero que tenham gostado, e até mais.

               
« Última modificação: 21 Jun 2017, 15:57 por MayLeone »

MaxuelZanus

  • *
  • Mensagens: 117 Ouro: 41
  • Herooooo!!!
    • RPG Maker VX/Ace
    • Ver perfil
    • E-mail
  • Phoenix
Muito bom May, vai me ajudar muito já que estou aprendendo pelo visual studio no meu curso.  :wow: :wow:
 

Nandikki

  • *
  • Mensagens: 1385 Ouro: 644

    Participantes do Maps Together 2

  • Run!
    • Unity
    • Ver perfil
  • NightWalker
Oi May! Coincidentemente comecei a estudar C# por conta do laboratório em que entrei. Bem, pretendo dar umas olhadas nas suas aulas.

O jogo da velha é um jogo muito interessante de se fazer para treinar (sobretudo a parte de IA hehe), quando o fiz em Java utilizei um vetor bidimensional 3x3 para representar as casas. Acho que encurta um pouco.

Enfim, parabéns e até mais.

MayLeone

  • *
  • Mensagens: 463 Ouro: 1124

    Vencedor CRM Awards - Melhor Eventer Membros que se destacaram no Mega-Evento de Reconstrução

  • CRM
    • Unity
    • Ver perfil
  • Óculos do Rickas
Muito bom May, vai me ajudar muito já que estou aprendendo pelo visual studio no meu curso.  :wow: :wow:
Que bom que poderei ajudar com seu curso, fico muito feliz!

Oi May! Coincidentemente comecei a estudar C# por conta do laboratório em que entrei. Bem, pretendo dar umas olhadas nas suas aulas.

O jogo da velha é um jogo muito interessante de se fazer para treinar (sobretudo a parte de IA hehe), quando o fiz em Java utilizei um vetor bidimensional 3x3 para representar as casas. Acho que encurta um pouco.

Enfim, parabéns e até mais.
Com certeza utilizar uma matriz deixaria o código mais compacto (eu até cito isso no tutorial  :lol: ), mas a ideia era utilizar apenas os princípios básicos da lógica em C# porque o tutorial é um exemplo de uma aula para iniciantes, porém com certeza ficaria mais 'bonito' e leve.
E já que você falou em IA, eu programei ontem a IA pra esse sistema, vou estar postando o tutorial sobre em breve.
No mais, agradeço pelo comentário.

 

Versão Mobile