Compartilhar via


Tutorial: Adicionar variáveis de referência e um controle de temporizador ao aplicativo WinForms do jogo correspondente

Nesta série de quatro tutoriais, você cria um jogo de combinação, em que o jogador combina pares de ícones ocultos.

O programa Jogo da Memória precisa rastrear quais controles de rótulo o jogador escolhe. Depois que um player escolher o primeiro rótulo, o programa deverá mostrar o ícone. Depois que o segundo rótulo for escolhido, o programa deverá exibir os dois ícones por um breve período. Em seguida, oculta os dois ícones.

Seu programa controla qual rótulo você escolheu em primeiro e segundo lugar usando variáveis de referência. Um temporizador oculta os ícones e controla por quanto tempo mostrar os ícones

  • Adicionar referências de etiqueta.
  • Adicione um temporizador.

Pré-requisitos

Este tutorial se baseia em tutoriais anteriores, Criar um aplicativo de jogo correspondente e Adicionar ícones ao seu jogo correspondente. Conclua esses tutoriais primeiro.

Adicionar referências de rótulo

Nesta seção, você adicionará duas variáveis de referência ao código. Elas controlam ou referenciam objetos Rótulo.

  1. Adicione referências de rótulo ao formulário usando o código a seguir em Form1.cs ou Form1.vb.

    public partial class Form1 : Form
    {
        // firstClicked points to the first Label control 
        // that the player clicks, but it will be null 
        // if the player hasn't clicked a label yet
        Label firstClicked = null;
    
        // secondClicked points to the second Label control 
        // that the player clicks
        Label secondClicked = null;
    

Se você estiver usando o C#, coloque o código após a chave da abertura e logo após a declaração de classe (public partial class Form1 : Form). Se você estiver usando o Visual Basic, coloque o código logo após a declaração de classe (Public Class Form1).

Essas instruções não fazem com que os controles de rótulo apareçam no formulário, pois a palavra-chave new não existe. Quando o programa é iniciado, firstClicked e secondClicked são definidos como null para C# ou Nothing para Visual Basic.

  1. Modifique o manipulador de eventos Click em Form1.cs ou Form1.vb para usar a nova variável de referência firstClicked. Remova a última instrução no método do manipulador de eventos label1_Click() (clickedLabel.ForeColor = Color.Black;) e substitua-a pela instrução if da seguinte maneira.

    /// <summary>
    /// Every label's Click event is handled by this event handler
    /// </summary>
    /// <param name="sender">The label that was clicked</param>
    /// <param name="e"></param>
    private void label1_Click(object sender, EventArgs e)
    {
        Label clickedLabel = sender as Label;
    
        if (clickedLabel != null)
        {
            // If the clicked label is black, the player clicked
            // an icon that's already been revealed --
            // ignore the click
            if (clickedLabel.ForeColor == Color.Black)
                return;
    
            // If firstClicked is null, this is the first icon 
            // in the pair that the player clicked,
            // so set firstClicked to the label that the player 
            // clicked, change its color to black, and return
            if (firstClicked == null)
            {
                firstClicked = clickedLabel;
                firstClicked.ForeColor = Color.Black;
    
                return;
            }
        }
    }
    

  1. Salve e execute seu programa. Escolha um dos controles de rótulo e seu ícone será exibido. Escolha o próximo controle de rótulo e observe que nada acontece.

    A captura de tela mostra o Jogo da memória mostrando um ícone.

    Somente o primeiro ícone escolhido é exibido. Os outros ícones são invisíveis.

O programa já está monitorando o primeiro rótulo que o jogador escolheu. O firstClicked de referência não é null em C# ou Nothing no Visual Basic. Quando a instrução if constata que firstClicked não é igual a null ou Nothing, ela executa as instruções.

Adicionar um temporizador

O aplicativo de jogo da memória usa um controle Timer. Um temporizador aguarda e, em seguida, dispara um evento, conhecido como um tique. Um temporizador pode iniciar uma ação ou repetir uma ação regularmente.

Em seu programa, o temporizador permite que um jogador escolha dois ícones. Se os ícones não corresponderem, ele ocultará os dois ícones novamente após um curto período de tempo.

  1. Selecione a guia Caixa de Ferramentas, na categoria Componentes, clique duas vezes ou arraste o componente Temporizador para o formulário. O ícone do temporizador, chamado timer1, aparece em um espaço abaixo do formulário.

    Captura de tela mostra o ícone do temporizador abaixo do formulário.

  2. Selecione o ícone Timer1 para selecionar o temporizador. Na janela Propriedades, selecione o botão Propriedades para exibir as propriedades.

  3. Defina a propriedade Interval como 750, que é de 750 milissegundos.

    A propriedade Intervalo informa ao temporizador quanto tempo ele deve aguardar entre os tiques, momento em que dispara o evento Tick. Seu programa chama o método Start() para iniciar o temporizador depois que o player escolher o segundo rótulo.

  4. Escolha o ícone de controle do temporizador e pressione Enterou clique duas vezes no temporizador. O IDE adiciona um manipulador de eventos Tick vazio a Form1.cs ou Form1.vb. Substitua o código pelo código a seguir.

    /// <summary>
    /// This timer is started when the player clicks 
    /// two icons that don't match,
    /// so it counts three quarters of a second 
    /// and then turns itself off and hides both icons
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void timer1_Tick(object sender, EventArgs e)
    {
        // Stop the timer
        timer1.Stop();
    
        // Hide both icons
        firstClicked.ForeColor = firstClicked.BackColor;
        secondClicked.ForeColor = secondClicked.BackColor;
    
        // Reset firstClicked and secondClicked 
        // so the next time a label is
        // clicked, the program knows it's the first click
        firstClicked = null;
        secondClicked = null;
    }
    

O manipulador de eventos Tick faz três coisas:

  • Ele garante que o temporizador não esteja em execução chamando o método Stop().
  • Ele usa duas variáveis de referência, firstClicked e secondClicked, para tornar os ícones dos dois rótulos que o player escolheu invisíveis novamente.
  • Ele redefine as variáveis de referência firstClicked e secondClicked para null em C# e Nothing no Visual Basic.
  1. Vá para o editor de código e adicione código à parte superior e inferior do método de manipulador de eventos label1_Click() em Form1.cs ou Form1.vb. Esse código verificará se o temporizador está habilitado, definirá a variável de referência secondClicked e iniciará o temporizador. O método do manipulador de eventos label1_Click() agora tem a seguinte aparência:

    /// <summary>
    /// Every label's Click event is handled by this event handler
    /// </summary>
    /// <param name="sender">The label that was clicked</param>
    /// <param name="e"></param>
    private void label1_Click(object sender, EventArgs e)
    {
        // The timer is only on after two non-matching 
        // icons have been shown to the player, 
        // so ignore any clicks if the timer is running
        if (timer1.Enabled == true)
            return;
    
        Label clickedLabel = sender as Label;
    
        if (clickedLabel != null)
        {
            // If the clicked label is black, the player clicked
            // an icon that's already been revealed --
            // ignore the click
            if (clickedLabel.ForeColor == Color.Black)
                return;
    
            // If firstClicked is null, this is the first icon
            // in the pair that the player clicked, 
            // so set firstClicked to the label that the player 
            // clicked, change its color to black, and return
            if (firstClicked == null)
            {
                firstClicked = clickedLabel;
                firstClicked.ForeColor = Color.Black;
                return;
            }
    
            // If the player gets this far, the timer isn't
            // running and firstClicked isn't null,
            // so this must be the second icon the player clicked
            // Set its color to black
            secondClicked = clickedLabel;
            secondClicked.ForeColor = Color.Black;
    
            // If the player gets this far, the player 
            // clicked two different icons, so start the 
            // timer (which will wait three quarters of 
            // a second, and then hide the icons)
            timer1.Start();
        }
    }
    

  • O código na parte superior do método verifica se o temporizador foi iniciado verificando o valor da propriedade Enabled. Se o jogador escolher o primeiro e o segundo controles de Rótulo e o temporizador for iniciado, a escolha de um terceiro rótulo não terá nenhum efeito.
  • O código na parte inferior do método define a variável de referência secondClicked para acompanhar o segundo controle Label. Em seguida, ele define a cor do ícone de rótulo como preto para torná-la visível. Em seguida, ele inicia o temporizador no modo de um único disparo, de modo que ele aguarda 750 milissegundos e dispara um único tique. O manipulador de eventos tick do temporizador oculta os dois ícones e redefine as variáveis de referência firstClicked e secondClicked. O formulário está pronto para o player escolher outro par de ícones.

Nota

Se você copiar e colar o bloco de código label1_Click() em vez de inserir o código manualmente, substitua o código label1_Click() existente. Caso contrário, você acabará com um bloco de código duplicado.

  1. Salve e execute seu programa. Selecione um quadrado e o ícone fica visível. Escolha outro quadrado. O ícone é exibido brevemente e os dois ícones desaparecem.

Agora seu programa rastreia o primeiro e o segundo ícones que você escolhe. Ele usa o temporizador para pausar antes de fazer os ícones desaparecerem.

Próximas etapas

Avance para o próximo tutorial para saber como concluir o Jogo da Memória.