/// <summary>
 ///  Este método distribui as cartas entre os quatro jogadores:
 /// User e os PC's. Isto depois das mesmas terem sido embaralhadas!!!
 /// </summary>
 private void DistribuirCartas()
 {
     for (int i = 1; i <= 13; i++)
     {
         CartasDoJogador01.Add(baralho.DarCarta());
         CartasDoJogador02.Add(baralho.DarCarta());
         CartasDoJogador03.Add(baralho.DarCarta());
         CartasDoJogador04.Add(baralho.DarCarta());
     }
 }      // DistribuirCartas;
        }      // Fim do Método ControlTag;

        /// <summary>
        /// Método que registra a jogada de um determinado
        /// jogador. Ele dispara o evento OnAlguemJogou, que
        /// controla quem deve jogar depois, quem é o mão, entre outras coisas!
        /// </summary>
        /// <param name="jogador">Jogador da jogada</param>
        /// <param name="carta">Carta jogada</param>
        /// <param name="index">Index que determina a posição da carta em CartasNaMao</param>
        void Jogada(Jogador jogador, Carta carta, int index, int pTop, int pLeft)
        {
            Contador.cartaJogada = carta;
            Contador.totalCartasNaRodada++;
            switch (carta.Naipe)
            {
            case 1: Contador.numPausQueSaiu++; break;

            case 2: Contador.numOurosQueSaiu++; break;

            case 3: Contador.numEspadasQueSaiu++; break;

            case 4:
                Contador.numCopasQueSaiu++;
                Contador.copasAbertas = true;
                break;
            }
            if (carta.Valor == 12 && carta.Naipe == 3)
            {
                Contador.numCopasQueSaiu += 13;
                Contador.miquilinaSaiu    = true;
            }
            if (Contador.totalCartasNaRodada == 1)
            {
                Contador.NipeMao = (Naipe)carta.Naipe;
            }
            switch (jogador.Nome)
            {
            case "USER01":
                CartasDoJogador01.Remove(index);
                estrategia.MoveCarta(picCartadaPc01, carta, pTop, pLeft, 211, 431);
                Contador.totalJogador01  += carta.Valor;
                Contador.cartaDoJogador01 = carta;
                OnAlguemJogou(objJogador.jogador01, new EventArgs());
                break;

            case "USER02":
                CartasDoJogador02.Remove(index);
                estrategia.MoveCarta(picCartadaPc02, carta, 111, 12, 184, 359);    // Otimizar parâm. top e left
                Contador.totalJogador02  += carta.Valor;
                Contador.cartaDoJogador02 = carta;
                OnAlguemJogou(objJogador.jogador02, new EventArgs());
                break;

            case "USER03":
                CartasDoJogador03.Remove(index);
                estrategia.MoveCarta(picCartadaPc03, carta, 48, 220, 108, 405);    // Otimizar parâm. top e left
                Contador.totalJogador03  += carta.Valor;
                Contador.cartaDoJogador03 = carta;
                OnAlguemJogou(objJogador.jogador03, new EventArgs());
                break;

            case "USER04":
                CartasDoJogador04.Remove(index);
                estrategia.MoveCarta(picCartadaPc04, carta, 99, 781, 148, 456);    // Otimizar parâm. top e left
                Contador.totalJogador04  += carta.Valor;
                Contador.cartaDoJogador04 = carta;
                OnAlguemJogou(objJogador.jogador04, new EventArgs());
                break;
            }
        }// Fim do método Rodada!!!