Partilhar via


Tutorial: Adicionar variáveis de referência e um controle de temporizador ao aplicativo WinForms do jogo da memória

Nesta série de quatro tutoriais, você cria um jogo da memória em que o jogador encontra pares de ícones ocultos.

O programa Jogo da Memória precisa rastrear quais controles de rótulo o jogador escolhe. Depois que um jogador escolhe o primeiro rótulo, o programa deve mostrar o ícone. Depois que o segundo rótulo é escolhido, o programa deve exibir ambos os ícones por um breve momento. 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 rótulo.
  • Adicionar um temporizador.

Pré-requisitos

Este tutorial se baseia em tutoriais anteriores, Criar um aplicativo de jogo da memória e Adicionar ícones ao seu jogo da memória. 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 seu formulário usando o código a seguir.

    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;
    

Importante

Use o controle da linguagem de programação no canto superior direito desta página para exibir os snippets de código C# ou do Visual Basic.

Programming language control for Microsoft Learn

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 o C# ou Nothing para o Visual Basic.

  1. Modifique o manipulador de eventos Click 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 a substitua pela instrução if a seguir.

    /// <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 é exibido. Escolha o próximo controle de rótulo e observe que nada acontece.

    Screenshot shows the Matching Game showing one icon.

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

O programa já está rastreando o primeiro rótulo escolhido pelo jogador. A referência firstClicked não é null no C# nem Nothing no Visual Basic. Quando a instrução if detecta que firstClicked não é igual a null nem 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.

    Screenshot shows the timer icon below the form.

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

  3. Defina a propriedade Intervalo como 750, que é igual a 750 milissegundos.

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

  4. Escolha o ícone de controle do temporizador e pressione Enter ou clique duas vezes no temporizador. O IDE adiciona um manipulador de eventos Tick vazio. Substitua o código pelo código seguinte.

    /// <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 de Tick realiza três tarefas:

  • Chamando o método Stop(), ele verifica se o temporizador não está em execução.
  • Ele usa duas variáveis de referência, firstClicked e secondClicked, para tornar invisíveis novamente os ícones dos dois rótulos que jogador escolheu.
  • Ele redefine as variáveis de referência firstClicked e secondClicked como null no C# e Nothing no Visual Basic.
  1. Vá para o editor de código e adicione o código no início e no fim do método do manipulador de eventos label1_Click(). 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 no início do método verifica se o temporizador foi iniciado verificando o valor da propriedade Habilitado. 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 no fim do método define a variável de referência secondClicked para rastrear o segundo controle de Rótulo. Em seguida, ele define a cor do ícone do rótulo como preta 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 do 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 jogador escolher outro par de ícones.

Observação

Se você copiar e colar o bloco de código label1_Click() em vez de inserir o código manualmente, não se esqueça de substituir o código label1_Click() existente. Caso contrário, você terá um bloco de código duplicado.

  1. Salve e execute seu programa. Selecione um quadrado e o ícone ficará visível. Escolha outro quadrado. O ícone aparece rapidamente e, em seguida, ambos 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.