/// <summary>
/// This method is used when the user trhrows a card in the table
/// </summary>
/// <param name="clickedPoint">where the user clicked on the table</param>
/// <param name="thisPlayer">who is playing</param>
/// <param name="tableLimits">limits of the playing table</param>
/// <param name="selectedCard">which card is been trown</param>
/// <param name="cardSlots">spaces allowed to place cards</param>
/// <returns>returns true if a valid place on the playing table was clicked</returns>
public bool ProcessMesaClicked(
Point clickedPoint,
int thisPlayer,
Rectangle tableLimits,
Naipe selectedCard,
CardSlots cardSlots)
{
if (tableLimits.Contains(clickedPoint.X, clickedPoint.Y))
{
NaipesEnMesa.NaipesEnGrupo.Add(selectedCard);
Manos[thisPlayer].NaipesEnGrupo.Remove(selectedCard);
selectedCard.Selected = false;
oneInHandSelected = false;
for (int i = 0; i < 10; i++)
{
if (!cardSlots.UsedTableCardPosition[i])
{
selectedCard.SetCenter(cardSlots.TableCardPosition[i]);
cardSlots.UsedTableCardPosition[i] = true;
selectedCard.SlotAssigned = CardSlots.getGroupIndexCardsInTable(i);
break;
}
}
return(true);
}
return(false);
}
public Carta(uint numero, Naipe naipe)
{
if (numero <= 0 || numero > 14)
{
throw new Exception("O número da cartá é inválido.");
}
Numero = numero;
Naipe = naipe;
}
public bool Anadir(Naipe naipe)
{
if (Ndatos == Baraja.Length)
{
return(false);
}
Baraja[Ndatos++] = naipe;
return(true);
}
public void DeveGerarNaipe()
{
var naipeEsperado = new
{
Id = "C",
Nome = "COPAS",
Simbolo = "♥"
};
var naipeGerado = new Naipe(naipeEsperado.Id);
naipeEsperado.ToExpectedObject().ShouldMatch(naipeGerado);
}
/// <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);
}
/// <summary>
/// Verifica qual é a maior carta dentro todas as servidas na rodada,
/// considerando, apenas, as que servirem ao nipe, que está representado
/// pela variável NMao, que é um objeto do tipo Naipe {enum}!!!
/// </summary>
/// <param name="cartas_rodada">As 4 Cartas da rodada</param>
/// <param name="totais">Os valores de cada uma das cartas</param>
/// <param name="NMao">Naipe servido pelo jogador mão</param>
/// <returns></returns>
public Jogador GetVencedorDaRodada(Carta[] cartas_rodada, int[] totais, Naipe NMao, Jogador[] jogadores)
{
int maior = 0;
for (int i = 0; i < 4; i++)
{
if ((totais[i] > maior) && cartas_rodada[i].Naipe == (int)NMao)
{
maior = totais[i];
retVal = jogadores[i];
}
}
TotalizaRodada(retVal, cartas_rodada);
return(retVal);
}// Fim do Método GetVencedorDaRodada;
public void AnadirNaipesAleatorios(int cuantos)
{
int valor; //Desde 1 a 12
int palo;
for (int i = 0; i < cuantos; i++)
{
valor = rnd.Next(12) + 1;
if (valor == 8 || valor == 9)
{
valor = 10;
}
palo = rnd.Next(4);
Naipe naipe = new Naipe((Palos)palo, (Valor)valor);
Anadir(naipe);
}
}
private string GetTokenNaipe(Naipe n, IDictionary <Naipe, uint> NaipeMap)
{
if (NaipeMap.ContainsKey(n))
{
return(NaipeMap[n].ToString());
}
uint valorNaipe = 0;
if (NaipeMap.Count > 0)
{
valorNaipe = (NaipeMap.Last().Value + 1);
}
NaipeMap.Add(n, valorNaipe);
return(valorNaipe.ToString());
}
public Carta(int valor, Naipe naipe)
{
this.valor = valor;
this.naipe = naipe;
}
/// <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));
}
public Carta(Rank rank, Naipe suit)
{
Rank = rank;
Naipe = suit;
}
public Carta(string nome, Naipe naipe)
{
Nome = nome;
Naipe = naipe;
}
public void DeveGerarSimboloEsperado(string idNaipe, string simboloEsperado)
{
var naipeGerado = new Naipe(idNaipe);
Assert.Equal(simboloEsperado, naipeGerado.Simbolo);
}
/// <summary>
/// This method perfoms a Move, acording to the selected card on hand or the touched card on table
/// </summary>
/// <param name="selectedCardOnHand">Selected card on the hand of the player</param>
/// <param name="touchedCardsOnTable">Selected cards on the table</param>
/// <returns>Return True if a valid move was possible and performed</returns>
private bool ProcessMove(Naipe selectedCardOnHand, List <Naipe> touchedCardsOnTable)
{
int rankVal;
for (int i = 0; i < touchedCardsOnTable.Count; i++)
{
//If the ranks are the same:
if (selectedCardOnHand.Rank == touchedCardsOnTable[0].Rank)
{
if (i == 0)
{
CollectedFromTable.Add(selectedCardOnHand);
CollectedFromTable.Add(touchedCardsOnTable[0]);
}
if (i > 0)
{
rankVal = (int)touchedCardsOnTable[i].Rank;
if (rankVal >= 11)
{
rankVal -= 3;
}
if ((int)touchedCardsOnTable[i - 1].Rank + 1 == rankVal)
{
CollectedFromTable.Add(touchedCardsOnTable[i]);
}
else
{
return(false);
}
}
}
else if (
touchedCardsOnTable.Count >= 2 &&
(int)touchedCardsOnTable[0].Rank + 1 <= 7 &&
(int)touchedCardsOnTable[1].Rank + 1 <= 7 &&
(int)selectedCardOnHand.Rank + 1 == (int)touchedCardsOnTable[0].Rank + (int)touchedCardsOnTable[1].Rank + 2)
{
if (i == 0)
{
CollectedFromTable.Add(selectedCardOnHand);
CollectedFromTable.Add(touchedCardsOnTable[0]);
CollectedFromTable.Add(touchedCardsOnTable[1]);
}
if (i > 1)
{
rankVal = (int)touchedCardsOnTable[i].Rank;
if (rankVal >= 11)
{
rankVal -= 3;
}
if ((int)touchedCardsOnTable[i - 1].Rank + 1 == rankVal)
{
CollectedFromTable.Add(touchedCardsOnTable[i]);
}
else
{
return(false);
}
}
}
else
{
return(false);
}
}
return(true);
}
/// <summary>
/// Make a movement once the player has clicked the button Make Move
/// </summary>
/// <param name="thisPlayer">Which player is this</param>
/// <param name="thisTeam">Which team the player belongs to</param>
/// <param name="cardSlots">Slots or places to lay down cards in the game</param>
/// <returns>Returns True if a valid move was completed</returns>
public bool MakeMove(int thisPlayer, int thisTeam, CardSlots cardSlots)
{
List <Naipe> touchedCardsOnTable = new List <Naipe>();
Naipe selectedCardOnHand = new Naipe();
//Get a list of touched cards on table
foreach (Naipe card in NaipesEnMesa.NaipesEnGrupo)
{
if (card.Touched)
{
touchedCardsOnTable.Add(card);
}
}
//Get a list of the selected card on hand
foreach (Naipe card in Manos[thisPlayer].NaipesEnGrupo)
{
if (card.Selected)
{
selectedCardOnHand = card;
break;
}
}
//No matter if the move is complited, the selected card on hand will be unselected
foreach (Naipe card in Manos[thisPlayer].NaipesEnGrupo)
{
card.Selected = false;
card.MoveToOriginalPosition();
}
oneInHandSelected = false;
//No matter if the move is complited, the selected cards on the table will be unselected
foreach (Naipe card in NaipesEnMesa.NaipesEnGrupo)
{
card.Touched = false;
}
oneInMesaTouched = false;
//Sort the list of touched Table Cards
touchedCardsOnTable.Sort(new NaipesComparer());
//Execute this if the move is valid
if (ProcessMove(selectedCardOnHand, touchedCardsOnTable))
{
//Remove the selected card on hand and selected cards on table
Manos[thisPlayer].NaipesEnGrupo.Remove(selectedCardOnHand);
foreach (Naipe card in touchedCardsOnTable)
{
Pair <CardGroup, int> slot = card.SlotAssigned;
cardSlots.UsedTableCardPosition[slot.Second] = false;
NaipesEnMesa.NaipesEnGrupo.Remove(card);
}
//Move the cards to their new position (Carton)
selectedCardOnHand.SetCenter(cardSlots.CartonCardPosition[thisTeam, 0]);
selectedCardOnHand.SlotAssigned = CardSlots.getGroupIndexCartonCards(thisTeam, 0);
Carton[thisTeam].AnadirArriba(selectedCardOnHand);
foreach (Naipe card in touchedCardsOnTable)
{
card.SetCenter(cardSlots.CartonCardPosition[thisTeam, 0]);
card.SlotAssigned = CardSlots.getGroupIndexCartonCards(thisTeam, 0);
Carton[thisTeam].AnadirArriba(card);
}
return(true);
}
//Execute this if it was not a valid move
else
{
return(false);
}
}
public static void Main()
{
Naipe = Naipe.Copas;
WriteLine($"{(char)Naipe.Espada} {(char)Naipe.Paus} {(char)Naipe.Copas} {(char)Naipe.Ouro} {(char)Naipe}");
}
public Carta(Naipe naipe, Face face)
{
Naipe = naipe;
Face = face;
}
public Carta(Naipe naipe, int valor)
{
this.naipe = naipe;
this.valor = valor;
}
/// <summary>
/// Create a new Game
/// </summary>
/// <param name="numJugadores">Number of players</param>
/// <param name="thisPlayer">which player is playing this game</param>
public void newGame(int numJugadores, int thisPlayer)
{
if (numJugadores != 2 && numJugadores != 4)
{
throw new ArgumentOutOfRangeException();
}
this.numJugadores = numJugadores;
this.thisPlayer = thisPlayer;
if (numJugadores == 2)
{
thisTeam = thisPlayer;
}
else
{
thisTeam = thisPlayer % 2;
}
//choose who is goint to deal
dataPlayer = rnd.Next(0, numJugadores);
dataPlayer = 3;
playerPlaying = dataPlayer + 1;
if (playerPlaying >= numJugadores)
{
playerPlaying = 0;
}
// Begin game (shuffle and deal cards, choose which cards are face up. SIZE IS NOT ASSIGNED, determine if card is on game)
partida.IniciarPartida(numJugadores, thisPlayer, dataPlayer);
//assign slots to dealt cards
int indexPlayer = thisPlayer;
for (int i = 0; i < numJugadores; i++)
{
for (int j = 0; j < 5; j++)
{
Naipe card = partida.Manos[indexPlayer].NaipesEnGrupo[j];
card.CardSize = cardSlots.CardSize;
if (i == 1 || i == 3)
{
card.Rotated = true;
}
if (numJugadores == 4)
{
card.SetCenter(cardSlots.PlayerCardPosition[i, j]);
card.SlotAssigned = CardSlots.getGroupIndexHand(i, j);
cardSlots.UsedPlayerCardPosition[i, j] = true;
}
else
{
card.SetCenter(cardSlots.PlayerCardPosition[i * 2, j]);
cardSlots.UsedPlayerCardPosition[i * 2, j] = true;
}
}
indexPlayer++;
if (indexPlayer >= numJugadores)
{
indexPlayer = 0;
}
}
//asign slots to cards to deal
foreach (Naipe card in partida.Mazo.NaipesEnGrupo)
{
card.CardSize = cardSlots.CardSize;
card.Rotated = true;
card.SetCenter(cardSlots.ToDealCardPosition[0]);
cardSlots.UsedToDealCardPosition[0] = true;
}
//asing size to score cards (perros)
foreach (Naipe card in partida.Perros.NaipesEnGrupo)
{
card.CardSize = cardSlots.CardSize;
}
//this is for TESTING
Naipe card1 = new Naipe(CardRank.Dos, CardPalo.Brillo);
partida.NaipesEnMesa.NaipesEnGrupo.Add(card1);
card1.CardSize = cardSlots.CardSize;
card1.OnGame = true;
card1.FaceUp = true;
for (int i = 0; i < 10; i++)
{
if (!cardSlots.UsedTableCardPosition[i])
{
card1.SetCenter(cardSlots.TableCardPosition[i]);
cardSlots.UsedTableCardPosition[i] = true;
card1.SlotAssigned = CardSlots.getGroupIndexCardsInTable(i);
break;
}
}
Naipe card2 = new Naipe(CardRank.Tres, CardPalo.Brillo);
partida.NaipesEnMesa.NaipesEnGrupo.Add(card2);
card2.CardSize = cardSlots.CardSize;
card2.OnGame = true;
card2.FaceUp = true;
for (int i = 0; i < 10; i++)
{
if (!cardSlots.UsedTableCardPosition[i])
{
card2.SetCenter(cardSlots.TableCardPosition[i]);
cardSlots.UsedTableCardPosition[i] = true;
card2.SlotAssigned = CardSlots.getGroupIndexCardsInTable(i);
break;
}
}
partida.Manos[0].NaipesEnGrupo[0].Rank = CardRank.Cinco;
//end of TESTING
gameState = GameState.Playing;
handState = HandState.NormalPlay;
}
// sobrecarga de construtor; distinção é feita pela qtde argumentos, tipo arg
public CartaDoBaralho(string figura, Naipe naipe)
{
Figura = figura;
Naipe = naipe;
}
public CartaDoBaralho(int numero, Naipe naipe)
{
Numero = numero;
Naipe = naipe;
}
public Carta(Face face, Naipe naipe)
{
Face = face;
Naipe = naipe;
}
public Carta(Rank rank, Naipe suit)
{
Rank = rank;
Naipe = suit;
}
