C# - Tic tac toe (Tutoriais para iniciantes)

[Mayleone]

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.  :ksksks: 
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

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

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:

public class Global
        {

        }

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

  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:

 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:

  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:

 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:

  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:

 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:

 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:

 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:

 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:

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:

 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:

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:

 // 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:

// 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:

// 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:

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():

 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:

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.

 

[Bruce Azkan]

Alou, [member=895]Mayleone[/member]!

Comecei uma tentativa de seguir seu tutorial, só que eu tenho o Visual Studio 2013.

Quando dou duplo clique no primeiro botão pra começar a digitar a primeira classe pública, aparece diferente do que você mostrou:

O que posso fazer nesse caso?

Parece que é o modo de edição deste programa que automatiza algumas coisas. E se eu tento editar normal, seguindo seu código, dá erro. :\

 

[HermesPasser]

[member=426]Bruce Azkan[/member] Tu criou o projeto em Visual Basic.

 

[Bruce Azkan]

[member=426]Bruce Azkan[/member] Tu criou o projeto em Visual Basic.

Opaaaaaaaa! Obrigado, [member=1330]HermesPasser[/member] !
Acho que consegui prosseguir aqui. Se terminar hoje, posto na Sala de Aula

 

[Mayleone]

Oi, Bruce! Fico feliz que esteja seguindo as aulas!
Creio que seu problema tenha sido resolvido, correto? Pois então, só gostaria de dizer que este tutorial é voltado para os bens iniciantes mesmo, onde nenhuma fundamentação da programação orientada a objetos é posta em prática, deixando o código bem longo (mas necessário para fins didáticos) e repetitivo.
Quando terminar este tutorial, recomendo que veja este aqui: http://compilemosfacil.blogspot.com.br/2017/09/video-aulas-pratica.html
que é uma versão "melhorada" deste tutorial e que segue os conceitos de POO e vetores, ok?

Boa sorte nos estudos.

 

[Bruce Azkan]

Obrigado, professora May!
Dei uma rápida olhada nesse que você deixou o link e sinceramente tá bem mais completo mesmo, pelo menos no início xD

Postarei os resultados em breve o/