}// Fim do Método btnNewGame_Click;
public void Iniciar()
{
///<sumary>As próximas 9 linhas estão aqui, pois
/// é necessário que estes objetos sejam renovados
/// a cada nopa partida. Por isso não estão no construtor!
///</summary>
CartasDoJogador01 = new CartasNaMao();
CartasDoJogador02 = new CartasNaMao();
CartasDoJogador03 = new CartasNaMao();
CartasDoJogador04 = new CartasNaMao();
/// ----------------------------------------------/.
baralho = new Baralho();
jogador_01 = new Jogador("USER01");
jogador_02 = new Jogador("USER02");
jogador_03 = new Jogador("USER03");
jogador_04 = new Jogador("USER04");
/// ----------------------------------------/.
estrategia.ZerarContadores();
baralho.Embaralhar();
DistribuirCartas();
CartasDoJogador01.Sort();
Procurar2Paus();
ControlTag(true);
PreencheMao();
} // Fim do Método Iniciar;
/// <summary>
/// Toda vez que uma rodada é iniciada este método tenta
/// encontrar uma carta do mesmo nipe para acompanhar a jogada!
/// </summary>
/// <param name="cartas">Cartas do jogador da vex</param>
/// <param name="nipeMao">Nipe da Carta do mão</param>
/// <param name="NumCartas">Número de Cartas na mão do jogador</param>
/// <returns></returns>
public Carta BuscaCartaMesmoNaipe(CartasNaMao cartas, Naipe nipeMao, int NumCartas)
{
for (int i = 0; i < NumCartas; i++)
{
if (nipeMao == (Naipe)cartas[i].Naipe)
{
Contador.indexAtual = i;
return(cartas[Contador.indexAtual]);
}
}
Contador.indexAtual = 0;
return(cartas[0]);
} // Fim do método BuscaCartaMesmoNaipe;
/// <summary>
/// Método que retorna a carta de menor valor,
/// dado o naipe que é recebido como parâmetro!
/// </summary>
/// <param name="seuJogo"> Cartas que, neste instante, estão na sua mão </param>
/// <param name="naipe"> Naipe a servir </param>
/// <returns> Retorna um objeto carta </returns>
private Carta GetSuaMenorCartaDoNaipe(CartasNaMao seuJogo, Naipe naipe)
{
Carta retval = null; int Menor = 14;
for (int i = 0; i < seuJogo.GetNumCartas(); i++)
{
if ((seuJogo[i].Valor < Menor) && (Naipe)seuJogo[i].Naipe == naipe)
{
retval = seuJogo[i];
}
}
return(retval);
}
public Carta GetTheCards(string nome_da_carta, CartasNaMao seuJogo)
{
Carta retval = null;
for (int i = 0; i < seuJogo.GetNumCartas(); i++)
{
if (seuJogo[i].ToString() == nome_da_carta)
{
retval = seuJogo[i];
}
}
return(retval);
}
public bool TemACarta(string nome_da_carta, CartasNaMao seuJogo)
{
bool retval = false;
for (int i = 0; i < seuJogo.GetNumCartas(); i++)
{
if (seuJogo[i].ToString() == nome_da_carta)
{
retval = true;
}
}
return(retval);
}
} //Fim do Método Click_Img;
void NovaRodada(Jogador mao, bool copasAberta, CartasNaMao cartasDoVencedor)
{
picCartadaPc01.Visible = false;
picCartadaPc02.Visible = false;
picCartadaPc03.Visible = false;
picCartadaPc04.Visible = false;
// Se o mão for eu, não é para
// haver jogada automática!
if (mao.Nome != "USER01")
{
Jogada(mao, cartasDoVencedor[0], 0, 0, 0); // Depois mudar isso de acordo com o jogador
//que for o mão!
}
}
} // Fim da Classe Procurar2Paus();
bool FindFirstCards(CartasNaMao cartas, Jogador jogador)
{
bool achou = false;
for (int i = 0; i < cartas.GetNumCartas(); i++)
{
if (cartas[i].Valor == 2 && cartas[i].Naipe == (int)Naipe.Paus)
{
achou = true;
Contador.NipeMao = Naipe.Paus;
Contador.mao = jogador;
if (jogador.ToString() != "USER01")
{
Jogada(jogador, cartas[i], i, 0, 0);
}
else
{
tmEsperaDeJogador01.Enabled = true;
}
}
}
return(achou);
}// Fim do método FindFirstCards;
/// <summary>
/// Em fase de projeto!
/// Este método vai substituir o método
/// BuscaCartaMesmoNaipe()
/// </summary>
/// <param name="seuJogo"> O jogo que, no instante, está na sua mão </param>
/// <param name="cartasDaRodada"> As cartas que, no instante, estão na mesa </param>
/// <returns> Retorna um objeto do tipo Carta </returns>
public Carta GetMelhorCarta(CartasNaMao seuJogo, Carta[] cartasDaRodada, Naipe naipe_mao,
Jogador jogador_mao, Jogador jogador_vez)
{
Carta retval = null;
/// REVISAR SEMPRE ESTE SUMMARY, POIS EL SÓ DEVE SER APAGADO DEPOIS DE PRONTO!
/// OBS: DEIXAR A REGION FECHADA E POUSAR O MOUSE PARA LER. ABRIR PARA REVISAR!!!
#region :: Summary com detalhes da Implementação do método!
///<summary>
/// ** Carta mão != (copas && espadas);
/// 01 - Avalia se tem o naipe para servir;
/// 02 - Caso negativo, verificar se é a primeira rodada;
/// 03 - Caso negativo, verificar se está com dama de espadas;
/// 04 - Caso positivo embarcar dama de espadas;
/// 04 - Caso negativo, verificar se copas está aberta;
/// 05 - Caso positivo, servir copas;
/// 06 - No caso de embarcar copas servir sempre o maior valor na sua mão;
/// 07 - No caso de não ter o naipe mão, mas também não ter nem copas e nem a dama de espadas,
/// Escolher um naipe e embarcar o maior valor desse naipe;
/// ** - Você é o mão e não é a primeira rodada;
/// 01 - Escolha um naipe != Espadas && Copas;
/// 02 - Se houver pelo menos 5 cartas do mesmo naipe ainda a ser jogada, sem contar as suas,
/// obviamente, Você deve sair com a maior carta deste naipe
/// ** - Caso a carta mão seja espadas:
/// 01 - Verifica se a dama de espadas já saiu;
/// 02 - caso positivo, ****
/// ** - caso a carta mão seja copas;
/// 01 - se vc for o último jogador da rodada avalie dois casos;
/// 02 - se você não tem como servir uma carta menor para fugir de pegar esta rodada,
/// então sirva a maior que vc tiver de copas
///</summary>
#endregion
//Escolhe Naipe;
switch (naipe_mao)
{
case Naipe.Paus:
// Verifica se "você(PCn)" é o mão!
//=-=-=-=-=-=-=-=-=-=-=-=-=/.
//Obs.: Não é necessária a verificação
//de NumRodada, pois se fosse a primeira
//Seria disparado no método Procura2Paus();
if (jogador_mao.Nome == jogador_vez.Nome)
{
//Verifica se vc tem copas e tem o
//dois de copas e copas está aberta!?
//(NO FUTURO AVALIAR SE TEM A "MENOR" CARTA DE COPAS)
if ((seuJogo.GetNumCopas() > 0) && (TemACarta("Dois de Copas", seuJogo)) && (Contador.copasAbertas))
{
retval = GetTheCards("Dois de Copas", seuJogo);
}
else
{
//Esta implementação deve ser OTIMIZADA,
//no sentido de buscar a melhor carta <> 2copas
retval = GetAnyCards(seuJogo);
}
}
else
{
//Verifica se tem Paus na Mão,
//caso em que terá que servir!!
if (seuJogo.GetNumPaus() > 0)
{
//Desenvolver: (Vc tem paus! Deverá jogar paus!!!)
retval = GetMelhorOpcaoServir(new Naipe[] { Naipe.Paus }, seuJogo,
cartasDaRodada, naipe_mao, jogador_mao);
}
else
{
//Não tem paus para servir.
//Verifica se estamos na 1ª rodada, caso em que não poderão
//ser embarcadas copas e nem a dama de espadas!!!
if (Contador.numRodada <= 1)
{
//Vc vai embarcar, mas não pode ser copas
//e nem a dama de espadas, visto que está na primeira rodada!
retval = GetMelhorOpcaoEmbarcar(new Naipe[] { Naipe.Espadas, Naipe.Ouros }, seuJogo,
cartasDaRodada, naipe_mao, jogador_mao);
}
else
{
//Não tem paus para servir. Avalia se já foi
//aberta copas. Além disso, também avalia se vc tem copas,
// caso contrário essa abordagem seria inútil!
//Obs.: NESTA ABORDAGEM (IF), DAMOS PREFERÊNCIA
//À COPAS EM DETRIMENTO DA DAMA DE ESPADAS,
//QUE TEM SUA IMPLEMENTAÇÃO NA CRÍTICA DO "ELSE".
if (Contador.copasAbertas && seuJogo.GetNumCopas() > 0)
{
//Vc vai jogar copas!
retval = GetMelhorOpcaoEmbarcar(new Naipe[] { Naipe.Copas }, seuJogo,
cartasDaRodada, naipe_mao, jogador_mao);
}
else
{
// Verifica se vc está com a miquilina.
// Para manter padrão, verificar se miquilina saiu.
// NÃO seria necessário, visto que vc avalia se ESTÁ com ela ou não!
if ((!Contador.miquilinaSaiu) && seuJogo.EstaComMiquilina())
{
//Seta retval com dama de espadas!
for (int i = 0; i < seuJogo.GetNumCartas(); i++)
{
if (seuJogo[i].Valor == 12 && (seuJogo[i].Naipe == (int)(Naipe.Espadas)))
{
retval = seuJogo[i];
}
}
}
else
{
//Vc não tem paus, mas tb não pode jogar copas e nem a miquilina!
retval = GetMelhorOpcaoEmbarcar(new Naipe[] { Naipe.Espadas, Naipe.Ouros }, seuJogo,
cartasDaRodada, naipe_mao, jogador_mao);
}
} // if (Contador.copasAbertas && seuJogo.GetNumCopas() > 0)
} // if ( Contador.numRodada <= 1 )
} // if ( seuJogo.GetNumPaus() > 0 )
} // if ( jogador_mao.Nome == vez.Nome )
break;
case Naipe.Ouros:
break;
case Naipe.Espadas:
break;
case Naipe.Copas:
break;
default:
// Não faz nada, pois nunca deveremos chegar até aqui!
break;
}
return(retval);
}
//IMPLEMENTAR!!!!
/// <summary>
/// Método que retorna a "melhor" carta do mesmo naipe do mão!
/// Ele recebe, de uma "classe anônima", um array com os naipes possíveis para embarcar.
/// Obs: Este método não pode retornar a Dama de Espadas (Miquilina).
/// <param name="naipes_possiveis"> Array de naipes possíveis para embarcarr </param>
/// <param name="seuJogo"> O jogo que, no instante, o jogador tem na mão! </param>
/// <param name="cartasDaRodada"> Cartas que, no instante, estão na mesa! </param>
/// <param name="naipe_mao"> Naipe puxado pelo jogador mao </param>
/// <param name="jogador_mao"> jogador que tem o dever de iniciar a jogada! </param>
/// <returns> Objeto do tipo Carta, que na avaliação da inteligência do jogo é a melhor! </returns><summary>
public Carta GetMelhorOpcaoEmbarcar(Naipe[] naipes_possiveis, CartasNaMao seuJogo,
Carta[] cartasDaRodada, Naipe naipe_mao, Jogador jogador_mao)
{
/// Obs: Este método não pode retornar a Dama de Espadas (Miquilina).
return(new Carta(2, 12));
}
//IMPLEMENTAR!!!
/// <summary>
/// Método que retorna a "melhor" carta do mesmo naipe do mão!
/// Ele recebe, de uma "classe anônima" um array com os naipes possíveis para servir!
/// <param name="naipes_possiveis"> Array de naipes possíveis para servir </param>
/// <param name="seuJogo"> O jogo que, no instante, o jogador tem na mão! </param>
/// <param name="cartasDaRodada"> Cartas que, no instante, estão na mesa! </param>
/// <param name="naipe_mao"> Naipe puxado pelo jogador mao </param>
/// <param name="jogador_mao"> jogador que tem o dever de iniciar a jogada! </param>
/// <returns> Objeto do tipo Carta, que na avaliação da inteligência do jogo é a melhor! </returns><summary>
public Carta GetMelhorOpcaoServir(Naipe[] naipes_possiveis, CartasNaMao seuJogo,
Carta[] cartasDaRodada, Naipe naipe_mao, Jogador jogador_mao)
{
// Desenvolver!!! RETORNAR MELHOR CARTA PARA SERVIR!
return(new Carta(2, 12));
}
///IMPLEMENTAR!!!
///
public Carta GetAnyCards(CartasNaMao seuJogo)
{
// Desenvolver!!! RETORNAR A MELHOR CARTA NO MOMENTO!
return(new Carta(2, 12));
}
