public override GameCard[] DealHoles()
{
var set = new GameCard[2];
set[0] = m_Deck.Pop();
set[1] = m_Deck.Pop();
return set;
}
public void initialize()
{
// to be adapted to GUI
for (int i=0; i<size; i++){
int id = Random.Range(100, 116);
gamePanel[i] = new GameCard(id, i, false);
gamePanel[++i] = new GameCard(id, i, false);
}
print("initialize finished");
}
public void AddToBoard (GameCard card) {
board.Add(card);
}
public void GivePlayerCard(GameCard cardToGive)
{
playerDeck.unactiveDeck.Add(cardToGive.relatedCard);
}
public void AttackHand(HandController defender, GameCard attackCard)
{
gameCards.Remove(attackCard);
defender.RecieveAttack(attackCard);
}
public Result IsGameCardInserted(out bool isInserted)
{
isInserted = GameCard.IsGameCardInserted();
return(Result.Success);
}
private void FourOfAKindCheck(GameCard playerFirstCard, GameCard playerSecondCard, GameCard[] cardsOnTable, IPlayer player)
{
var allcards = new GameCard[cardsOnTable.Length + 2];
allcards[0] = playerFirstCard;
allcards[1] = playerSecondCard;
for (int i = 2, counter = 0; i < allcards.Length; i++, counter++)
{
allcards[i] = cardsOnTable[counter];
}
for (int i = 2; i < 15; i++)
{
var cardsGroupedByRank = allcards.Where(c => c.Rank == i);
if (cardsGroupedByRank.Count() == 4)
{
var firstCard = cardsGroupedByRank.First();
player.PokerHandMultiplier = 7;
player.CardPower = firstCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
}
}
public void onNewHandCard( GameCard c, int slotIndex )
{
CardUI card = newHandCard ( c.code, buildSlots[slotIndex].transform.position );
card.handColumn = numHandColumns-1;
adjustColumn (numHandColumns-1, true);
}
private void TwoPairCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
int firstCardPairCount = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
int secondCardPairCount = cardsOnTable.Count(card => secondCard.Rank == card.Rank);
if (firstCardPairCount > 1 || secondCardPairCount > 1)
{
return;
}
if (firstCardPairCount == 1 && secondCardPairCount == 1 && firstCard.Rank == secondCard.Rank)
{
return;
}
int pairsOnTable = 0;
int highestTablePairRank = 0;
for (int startCardIndex = 0; startCardIndex < cardsOnTable.Length - 1; startCardIndex++)
{
int pairCount = 0;
for (int endCardIndex = cardsOnTable.Length - 1; endCardIndex > 0; endCardIndex--)
{
if (endCardIndex == startCardIndex)
{
continue;
}
if (cardsOnTable[startCardIndex].Rank != cardsOnTable[endCardIndex].Rank)
{
continue;
}
pairCount++;
if (highestTablePairRank < cardsOnTable[startCardIndex].Rank)
{
highestTablePairRank = cardsOnTable[startCardIndex].Rank;
}
}
if (pairCount > 1)
{
return;
}
if (pairCount == 1)
{
pairsOnTable++;
}
}
switch (pairsOnTable)
{
case 0:
if (firstCardPairCount == 1 && secondCardPairCount == 1)
{
player.PokerHandMultiplier = 2;
player.CardPower = firstCard.Rank * 2 + secondCard.Rank * 2 + player.PokerHandMultiplier * 100;
}
break;
case 1:
if (firstCard.Rank == secondCard.Rank)
{
player.PokerHandMultiplier = 2;
player.CardPower = firstCard.Rank * 2 + highestTablePairRank * 2 + player.PokerHandMultiplier * 100;
}
else if (firstCardPairCount == 1 && secondCardPairCount != 1)
{
player.PokerHandMultiplier = 2;
player.CardPower = firstCard.Rank * 2 + highestTablePairRank * 2 + player.PokerHandMultiplier * 100;
}
else if (secondCardPairCount == 1 && firstCardPairCount != 1)
{
player.PokerHandMultiplier = 2;
player.CardPower = secondCard.Rank * 2 + highestTablePairRank * 2 + player.PokerHandMultiplier * 100;
}
else if (secondCardPairCount == 1 && firstCardPairCount == 1)
{
int highestRank;
int secondHighestRank;
if (firstCard.Rank > secondCard.Rank)
{
highestRank = firstCard.Rank;
secondHighestRank = secondCard.Rank;
}
else
{
highestRank = secondCard.Rank;
secondHighestRank = firstCard.Rank;
}
if (secondHighestRank < highestTablePairRank)
{
secondHighestRank = highestTablePairRank;
}
player.PokerHandMultiplier = 2;
player.CardPower = highestRank * 2 + secondHighestRank * 2 + player.PokerHandMultiplier * 100;
}
break;
case 2:
if (firstCard.Rank == secondCard.Rank)
{
int highestCardHandOrTable = Math.Max(highestTablePairRank, Math.Max(firstCard.Rank, secondCard.Rank));
player.PokerHandMultiplier = 2;
player.CardPower = highestCardHandOrTable * 4 + player.PokerHandMultiplier * 100;
}
else if (firstCardPairCount == 1)
{
int highestCardHandOrTable = firstCard.Rank > highestTablePairRank ? firstCard.Rank : highestTablePairRank;
player.PokerHandMultiplier = 2;
player.CardPower = highestCardHandOrTable * 4 + player.PokerHandMultiplier * 100;
}
else if (secondCardPairCount == 1)
{
int highestCardHandOrTable = secondCard.Rank > highestTablePairRank ? secondCard.Rank : highestTablePairRank;
player.PokerHandMultiplier = 2;
player.CardPower = highestCardHandOrTable * 4 + player.PokerHandMultiplier * 100;
}
else
{
player.PokerHandMultiplier = 2;
player.CardPower = highestTablePairRank * 4 + player.PokerHandMultiplier * 100;
}
break;
}
}
public int GetCardIndex(GameCard card)
{
return(GetCardIndex(card.uid));
}
private void StraightCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
int firstCardPairs = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
int secondCardPairs = cardsOnTable.Count(card => secondCard.Rank == card.Rank);
List<int> allCards = new List<int>();
if (firstCardPairs == 0)
{
if (firstCard.Rank == 14)
{
allCards.Add(firstCard.Rank);
allCards.Add(1);
}
else
{
allCards.Add(firstCard.Rank);
}
}
if (secondCardPairs == 0)
{
if (secondCard.Rank == 14)
{
allCards.Add(secondCard.Rank);
allCards.Add(1);
}
else
{
allCards.Add(firstCard.Rank);
}
}
if (cardsOnTable.Any(card => card.Rank == 14))
{
allCards.Add(1);
}
allCards.AddRange(cardsOnTable.Select(card => card.Rank));
allCards.Sort();
int countConsecutives = 0;
int highestCardRankInStreight = 0;
for (int startCard = 0; startCard < allCards.Count - 1; startCard++)
{
if (allCards[startCard] + 1 == allCards[startCard + 1])
{
countConsecutives++;
if (countConsecutives >= 5)
{
highestCardRankInStreight = allCards[startCard + 1];
}
}
}
if (countConsecutives < 5)
{
return;
}
player.PokerHandMultiplier = 4;
player.CardPower = highestCardRankInStreight * 4 + player.PokerHandMultiplier * 100;
}
private void ThreeOfAKindCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
int firstCardThreeOfAKindCount = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
int secondCardThreeOfAKindCount = cardsOnTable.Count(card => secondCard.Rank == card.Rank);
if (firstCardThreeOfAKindCount > 2 || secondCardThreeOfAKindCount > 2)
{
return;
}
if (firstCardThreeOfAKindCount == 2 && secondCardThreeOfAKindCount == 2 && firstCard.Rank == secondCard.Rank)
{
return;
}
GameCard highestCard = this.GetHighestCardInHand(firstCard, secondCard);
if (firstCardThreeOfAKindCount == 2 || secondCardThreeOfAKindCount == 2)
{
player.PokerHandMultiplier = 3;
if (firstCardThreeOfAKindCount == 2 && secondCardThreeOfAKindCount != 2)
{
player.CardPower = firstCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
else if (firstCardThreeOfAKindCount != 2 && secondCardThreeOfAKindCount == 2)
{
player.CardPower = secondCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
else
{
player.CardPower = highestCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
}
if (firstCardThreeOfAKindCount == 1 &&
secondCardThreeOfAKindCount == 1 &&
firstCard.Rank == secondCard.Rank)
{
player.PokerHandMultiplier = 3;
player.CardPower = firstCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
var tableCardsTreeOfAKind = cardsOnTable
.GroupBy(card => card.Rank)
.Select(group => new { Rank = @group.Key, Count = @group.Count() })
.OrderByDescending(group => @group.Count)
.First();
if (tableCardsTreeOfAKind.Count != 3)
{
return;
}
if (firstCardThreeOfAKindCount == 1 &&
secondCardThreeOfAKindCount == 1 &&
firstCard.Rank == secondCard.Rank)
{
int highestCardHandOrTable = tableCardsTreeOfAKind.Rank > firstCard.Rank ? tableCardsTreeOfAKind.Rank : firstCard.Rank;
player.PokerHandMultiplier = 3;
player.CardPower = highestCardHandOrTable * 4 + player.PokerHandMultiplier * 100;
}
if (firstCardThreeOfAKindCount == 0 &&
secondCardThreeOfAKindCount == 0)
{
player.PokerHandMultiplier = 3;
player.CardPower = tableCardsTreeOfAKind.Rank * 4 + player.PokerHandMultiplier * 100;
}
}
private void CheckForFlush(GameCard firstCard, GameCard secondCard, GameCard[] cardsOfSameSuitOnTable, IPlayer player)
{
var allcardsOnTableAndPlayers = new GameCard[cardsOfSameSuitOnTable.Length + 2];
allcardsOnTableAndPlayers[0] = firstCard;
allcardsOnTableAndPlayers[1] = secondCard;
var highestCardFromTable = cardsOfSameSuitOnTable.OrderByDescending(c => c.Rank).First();
for (int i = 2, counter = 0; i < allcardsOnTableAndPlayers.Length; i++, counter++)
{
allcardsOnTableAndPlayers[i] = cardsOfSameSuitOnTable[counter];
}
var maxCardValue = allcardsOnTableAndPlayers.OrderByDescending(c => c.Rank).First();
if (cardsOfSameSuitOnTable.Length == 3)
{
// check if the 3 cards on the table with the same suit are the same suit with the player's cards
// takes the most high card by rank and multiplies *500
if (firstCard.Suit == secondCard.Suit && firstCard.Suit == highestCardFromTable.Suit)
{
player.PokerHandMultiplier = 5;
player.CardPower = maxCardValue.Rank + player.PokerHandMultiplier * 100;
}
// check if one of the player cards match by suit with the cards on the table
}
else if (cardsOfSameSuitOnTable.Length == 4 &&
(firstCard.Suit == highestCardFromTable.Suit || secondCard.Suit == highestCardFromTable.Suit))
{
if (firstCard.Suit == highestCardFromTable.Suit)
{
var highCardByRank = firstCard.Suit > highestCardFromTable.Suit ? firstCard : highestCardFromTable;
player.PokerHandMultiplier = 5;
player.CardPower = highCardByRank.Rank + player.PokerHandMultiplier * 100;
}
if (secondCard.Suit == highestCardFromTable.Suit && secondCard.Rank > firstCard.Rank)
{
var highCardByRank = secondCard.Suit > highestCardFromTable.Suit ? secondCard : highestCardFromTable;
player.PokerHandMultiplier = 5;
player.CardPower = highCardByRank.Rank + player.PokerHandMultiplier * 100;
}
}
//check if player's cards match by suit with card on table if so takes the strongest by power and finds CardPower
//else takes the strongerst card from the table
else if (cardsOfSameSuitOnTable.Length == 5)
{
if (firstCard.Suit == highestCardFromTable.Suit || secondCard.Suit == highestCardFromTable.Suit)
{
if (firstCard.Suit == highestCardFromTable.Suit)
{
var highCardByRank = firstCard.Suit > highestCardFromTable.Suit ? firstCard : highestCardFromTable;
player.PokerHandMultiplier = 5;
player.CardPower = highCardByRank.Rank + player.PokerHandMultiplier * 100;
}
if (secondCard.Suit == highestCardFromTable.Suit && secondCard.Rank > firstCard.Rank)
{
var highCardByRank = secondCard.Suit > highestCardFromTable.Suit ? secondCard : highestCardFromTable;
player.PokerHandMultiplier = 5;
player.CardPower = highCardByRank.Rank + player.PokerHandMultiplier * 100;
}
}
else
{
player.PokerHandMultiplier = 5;
player.CardPower = maxCardValue.Rank + player.PokerHandMultiplier * 100;
}
}
}
private void FlushCheck(GameCard playerFirstCard, GameCard playerSecondCard, GameCard[] cardsOnTable, IPlayer player)
{
var cardsOfClubs = cardsOnTable.Where(o => o.Suit == CardSuit.Clubs).ToArray();
var cardsOfDiamonds = cardsOnTable.Where(o => o.Suit == CardSuit.Diamonds).ToArray();
var cardsOfHearts = cardsOnTable.Where(o => o.Suit == CardSuit.Hearts).ToArray();
var cardsOfSpades = cardsOnTable.Where(o => o.Suit == CardSuit.Spades).ToArray();
if (cardsOfClubs.Length >= 3)
{
this.CheckForFlush(playerFirstCard, playerSecondCard, cardsOfClubs, player);
}
if (cardsOfDiamonds.Length >= 3)
{
this.CheckForFlush(playerFirstCard, playerSecondCard, cardsOfDiamonds, player);
}
if (cardsOfHearts.Length >= 3)
{
this.CheckForFlush(playerFirstCard, playerSecondCard, cardsOfHearts, player);
}
if (cardsOfSpades.Length >= 3)
{
this.CheckForFlush(playerFirstCard, playerSecondCard, cardsOfSpades, player);
}
}
private void FullHouseCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
List<GameCard> allCards = new List<GameCard>();
allCards.Add(firstCard);
allCards.Add(secondCard);
allCards.AddRange(cardsOnTable);
var tableCardsGrouped = allCards
.GroupBy(card => card.Rank)
.Select(group => new
{
Rank = @group.Key,
Count = @group.Count()
})
.OrderByDescending(group => @group.Count)
.ThenByDescending(rank => rank.Rank);
bool foundTreeOfAKind = false;
int foundTreeOfAKindRank = 0;
bool foundTwoOfAKind = false;
int foundTwoOfAKindRank = 0;
foreach (var cardGroup in tableCardsGrouped)
{
if (cardGroup.Count == 3)
{
foundTreeOfAKind = true;
foundTreeOfAKindRank = cardGroup.Rank;
}
if (cardGroup.Count == 2)
{
foundTwoOfAKind = true;
foundTwoOfAKindRank = cardGroup.Rank;
break;
}
}
if (!foundTreeOfAKind || !foundTwoOfAKind)
{
return;
}
player.PokerHandMultiplier = 6;
player.CardPower = foundTreeOfAKindRank + foundTwoOfAKindRank / 10 + player.PokerHandMultiplier * 100;
}
public void RecieveAttack(GameCard attackCard)
{
StartCoroutine(coRecieveAttack(attackCard));
}
private void PairCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
int firstCardPairCount = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
int secondCardPairCount = cardsOnTable.Count(card => secondCard.Rank == card.Rank);
int pairsOnTableCount = cardsOnTable
.GroupBy(card => card.Rank)
.Select(group => new { Count = @group.Count() })
.Count(group => @group.Count == 2);
if ((firstCardPairCount == 1 ^ secondCardPairCount == 1) &&
firstCard.Rank == secondCard.Rank)
{
if (pairsOnTableCount != 1)
{
return;
}
}
if (firstCardPairCount == 1)
{
player.PokerHandMultiplier = 0;
player.CardPower = firstCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
if (secondCardPairCount == 1)
{
player.PokerHandMultiplier = 0;
player.CardPower = secondCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
var pairOnTableRank = cardsOnTable
.GroupBy(card => card.Rank)
.Select(group => new
{
Rank = @group.Key,
Count = @group.Count()
})
.Where(group => @group.Count == 1)
.Select(newGroup => newGroup.Rank)
.First();
player.PokerHandMultiplier = 0;
player.CardPower = pairOnTableRank * 4 + player.PokerHandMultiplier * 100;
}
public void Reset()
{
decks = new List <GameCardDeck>();
cardQueue = new Queue();
currentCard = null;
}
private void PairFromHandCheck(GameCard firstCard, GameCard secondCard, IEnumerable<GameCard> cardsOnTable, IPlayer player)
{
if (firstCard.Rank != secondCard.Rank)
{
return;
}
int tableCardPairCount = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
if (tableCardPairCount > 0)
{
return;
}
player.PokerHandMultiplier = 1;
player.CardPower = firstCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
public AfterCardSubArmor(GameCard target, int num, GameCard source)
{
Target = target;
Num = num;
Source = source;
}
private void HighCardCheck(GameCard firstCard, GameCard secondCard, IPlayer player)
{
GameCard highestCard = this.GetHighestCardInHand(firstCard, secondCard);
player.PokerHandMultiplier = -1;
player.CardPower = highestCard.Rank;
}
public void RecieveAttack(GameCard card)
{
combatZone.AddAttackCard(card);
}
private GameCard GetHighestCardInHand(GameCard firstCard, GameCard secondCard)
{
GameCard highestCard = firstCard.Rank > secondCard.Rank ? firstCard : secondCard;
return highestCard;
}
public void RecieveAttack(GameCard attackCard)
{
StartCoroutine(coRecieveAttack(attackCard));
}
/// <summary>
/// 카드를 생성;
/// </summary>
/// <returns></returns>
public void InitCards()
{
for (int i = 0; i < CardTotal; i++)
{
Cards[i] = new GameCard();
Cards[i].GeneratePoint();
}
}
public static GameCard[] getAllCards() {
GameCard[] cards = new GameCard[allCards.Count];
allCards.Values.CopyTo( cards, 0 );
return cards;
}
public AfterCardBoost(GameCard target, int num, GameCard source)
{
Target = target;
Num = num;
Source = source;
}
public void RecieveAttack(GameCard card)
{
combatZone.AddAttackCard(card);
}
private void OnCastCard(ActionCompletedEvent <CastCardCommand> evt)
{
GameCard card = evt.Action.CastedCard;
removeCard(card);
}
public void RemoveFromBoard (GameCard card) {
board.Remove(card);
}
public void GetCardsImages(GameCard[] gameDealtCards)
{
for (int i = 0; i < gameDealtCards.Length; i++)
{
this.form.DealtCardsFrontImage[i] = Image.FromFile(gameDealtCards[i].CardFrontImageUri);
}
}
public void AttackHand(HandController defender, GameCard attackCard)
{
gameCards.Remove(attackCard);
defender.RecieveAttack(attackCard);
}
public AfterCardSwap(GameCard handCard)
{
HandCard = handCard;
}
IEnumerator coRecieveAttack(GameCard attackCard)
{
//attackCard
yield return(new WaitForSeconds(.25f));
}
protected override void PlayAIDelayed(GamePlayer player)
{
GameCard card = player.Cards.First();
int x = 0;
int y = 0;
Dictionary <int, int> resultsRow = new Dictionary <int, int>();
Dictionary <int, int> resultsColumn = new Dictionary <int, int>();
resultsColumn.Add(0, 0);
resultsColumn.Add(1, 0);
resultsColumn.Add(2, 0);
resultsColumn.Add(3, 0);
resultsColumn.Add(4, 0);
foreach (GameRow row in Board.Rows)
{
int sumA = 0;
foreach (GameCell cell in row.Cells.Where(c => c.IsFull()))
{
sumA += cell.Card.Value;
resultsColumn[row.Cells.IndexOf(cell)] += cell.Card.Value;
}
resultsRow.Add(Board.Rows.IndexOf(row), sumA);
}
if (card.Value <= 3 && player.Id == PlayerA.Id || card.Value > 3 && player.Id == PlayerB.Id)
{
foreach (KeyValuePair <int, int> i in resultsRow.OrderByDescending(i => i.Value))
{
if (!Board.Rows[i.Key].IsFull())
{
x = i.Key;
break;
}
}
foreach (GameCell cell in Board.Rows[x].Cells)
{
if (!cell.IsFull())
{
break;
}
y++;
}
}
else
{
foreach (KeyValuePair <int, int> i in resultsColumn.OrderByDescending(i => i.Value))
{
if (!Board.Columns[i.Key].IsFull())
{
y = i.Key;
break;
}
}
foreach (GameRow row in Board.Rows)
{
if (!row.Cells[y].IsFull())
{
break;
}
x++;
}
}
Play(player.Id, card.Id, x, y);
}
public GameCard GetCard(GameCard card)
{
return(GetCard(card.uid));
}
public static IUItoGame newGame( GameCard[] startHand, IGametoUI ui )
{
return new BoardManager(startHand, ui);
}
public void SetCard(GameCard gameCard)
{
cards.Add(gameCard);
}
private BoardManager( GameCard[] startHand, IGametoUI ui )
{
hand = new List<GameCard> ();
foreach (GameCard c in startHand) {
if( c == null ) Debug.Log( "null card!" );
hand.Add (c);
}
this.ui = ui;
}
public GetGameCard(GameCard gameCard)
{
Suit = gameCard.Suit;
Rank = gameCard.Rank;
}
public AfterCardCharm(GameCard target, GameCard source)
{
Target = target;
Source = source;
}
public void createHandCard( GameCard card, int slotIndex )
{
hand.Add(card);
ui.onNewHandCard(card, slotIndex);
}
public List <GameCard> CheckCards3choix(GameCard c, List <Carte> paires, int tour)
{
gameCard3choix = new List <GameCard>();
Debug.Log("Pli 3 choix!");
if (J1_humain_plays)
{
J1_humain.AjouterPlis(c.Proprietes);
J1_humain.AjouterPlis(paires[0]);
J1_humain.AjouterPlis(paires[1]);
J1_humain.AjouterPlis(paires[2]);
if (tour == 1)
{
jeuHumain.Remove(c.Proprietes);
}
}
else
{
J2_IA.AjouterPlis(c.Proprietes);
J2_IA.AjouterPlis(paires[0]);
J2_IA.AjouterPlis(paires[1]);
J2_IA.AjouterPlis(paires[2]);
if (tour == 1)
{
jeuIA.Remove(c.Proprietes);
}
}
defosse.Remove(paires[0]);
defosse.Remove(paires[1]);
defosse.Remove(paires[2]);
foreach (GameCard e in cards) //on trouve les GameCard qui correspondent aux 3 cartes trouvées
{
for (int i = 0; i < 3; i++)
{
if (e.Proprietes.Id == paires[i].Id)
{
gameCard3choix.Add(e);
}
}
}
for (int j = 0; j < 12; j++) //on parcoure defosseGameCard pour lui enlever les 3 GameCard trouvées
{
for (int k = 0; k < 3; k++) //on trouve les GameCard qui correspondent aux defosseGameCard
{
if (defosseGameCard[j] != null)
{
if (gameCard3choix[k].Proprietes.Id == defosseGameCard[j].Proprietes.Id)
{
coordDefosse[j] = Vector3.zero;
defosseGameCard[j] = null;
}
}
}
}
paires.Clear();
return(gameCard3choix);
}
public GameCard checkCards(GameCard c, int tour) //Parcoure la défosse pour savoir on peut faire une paire avec la carte du Joueur ou la carte de la Pioche (tour 1 pour le joueur, tour 2 pour la pioche)
{
cartesRangees = J1_humain.PlisLumiere.Count + J1_humain.PlisRuban.Count + J1_humain.PlisAnimal.Count + J1_humain.PlisPlante.Count + J2_IA.PlisLumiere.Count + J2_IA.PlisRuban.Count + J2_IA.PlisAnimal.Count + J2_IA.PlisPlante.Count;
Pli2Plantes = false;
Pli3Choix = false;
Pli2Choix = false;
Pli3Plantes = false;
choixPaireClick = false;
int cpt = 0;
List <Carte> paires;
paires = new List <Carte>();
foreach (Carte d in defosse) //on regarde si y a une paire possible
{
if (c.Proprietes.Mois == d.Mois)
{
paires.Add(d);
cpt++;
}
}
if (cpt == 0) //Si y a pas de paires possibles
{
defosse.Add(c.Proprietes); //On rajoute la carte actuelle à la défosse
if (tour == 1)
{
if (J1_humain_plays)
{
jeuHumain.Remove(c.Proprietes);
}
else
{
jeuIA.Remove(c.Proprietes);
}
}
return(null);
}
else if ((cpt == 1)) //Si il y a une paire possible
{
if (J1_humain_plays)
{
J1_humain.AjouterPlis(c.Proprietes); //on rajoute la carte aux plis du joueur
J1_humain.AjouterPlis(paires[0]); //on rajoute la carte paire aux plis du joueur
if (tour == 1)
{
jeuHumain.Remove(c.Proprietes); //Si on est au tour du joueur, on enlève la carte jouée de son jeu
}
}
else
{
J2_IA.AjouterPlis(c.Proprietes);
J2_IA.AjouterPlis(paires[0]);
if (tour == 1)
{
jeuIA.Remove(c.Proprietes);
}
}
defosse.Remove(paires[0]); //on retire la carte paire de la défosse
if ((c.Proprietes is Plante) && (paires[0] is Plante)) //si c'est une paire avec deux plantes, il faut gérer l'affichage différemment (voir RangerCartes)
{
Pli2Plantes = true;
}
foreach (GameCard e in cards) //on va trouver la GameCard qui correspond à notre carte paire
{
if (e.Proprietes.Id == paires[0].Id)
{
for (int i = 0; i < 12; i++)
{
if (defosseGameCard[i] != null)
{
if (e.Proprietes.Id == defosseGameCard[i].Proprietes.Id)
{
coordDefosse[i] = Vector3.zero; //puisqu'on enlève une carte de la défosse, son emplacement devient libre
defosseGameCard[i] = null;
paires.Clear();
return(e);
}
}
}
}
}
}
else if (cpt == 2)
{
Debug.Log("On est passé ici");
Pli2Choix = true;
}
else if (cpt == 3)
{
gameCard3choix = CheckCards3choix(c, paires, tour); //on récupère la liste avec les 3 cartes possibles
//Il faut maintenant gérér le problème de Pli2Plantes : il faut savoir quelle plante a été posée dans quelle ordre
if (c.Proprietes.Mois == Mois.Decembre) //Pour le mois de décembre il y a 3 plantes
{
Pli3Plantes = true;
if (!(c.Proprietes is Plante))
{
Pli3ChoixTourPlante1 = 2;
Pli3ChoixTourPlante2 = 3;
Pli3ChoixTourPlante3 = 4;
}
else if (!(gameCard3choix[0].Proprietes is Plante))
{
Pli3ChoixTourPlante1 = 1;
Pli3ChoixTourPlante2 = 3;
Pli3ChoixTourPlante3 = 4;
}
else if (!(gameCard3choix[1].Proprietes is Plante))
{
Pli3ChoixTourPlante1 = 1;
Pli3ChoixTourPlante2 = 2;
Pli3ChoixTourPlante3 = 4;
}
else if (!(gameCard3choix[2].Proprietes is Plante))
{
Pli3ChoixTourPlante1 = 1;
Pli3ChoixTourPlante2 = 2;
Pli3ChoixTourPlante3 = 3;
}
}
else
{
if (c.Proprietes.Mois != Mois.Novembre)
{
Pli2Plantes = true;
}
if (c.Proprietes is Plante)
{
Pli3ChoixTourPlante1 = 1;
if (gameCard3choix[0].Proprietes is Plante)
{
Pli3ChoixTourPlante2 = 2;
}
else if (gameCard3choix[1].Proprietes is Plante)
{
Pli3ChoixTourPlante2 = 3;
}
else
{
Pli3ChoixTourPlante2 = 4;
}
}
else if (gameCard3choix[0].Proprietes is Plante)
{
Pli3ChoixTourPlante1 = 2;
if (gameCard3choix[1].Proprietes is Plante)
{
Pli3ChoixTourPlante2 = 3;
}
else
{
Pli3ChoixTourPlante2 = 4;
}
}
else if (gameCard3choix[1].Proprietes is Plante)
{
Pli3ChoixTourPlante1 = 3;
Pli3ChoixTourPlante2 = 4;
}
}
Pli3Choix = true;
GameCard.isRangee3 = false;
GameCard.isRangee4 = false;
return(gameCard3choix[0]); //on retourne la premiere carte des 3 pour en faire la paire, et on rangera les 2 autres depuis la classe GameCard
}
return(c); //inutile
}
public IEnumerator CheckCards2choix(GameCard c, int tour)
{
Debug.Log("PLI 2 CHOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOIX");
Debug.Log(tour);
pauseJeu2Choix = true;
cartesRangees = J1_humain.PlisLumiere.Count + J1_humain.PlisRuban.Count + J1_humain.PlisAnimal.Count + J1_humain.PlisPlante.Count + J2_IA.PlisLumiere.Count + J2_IA.PlisRuban.Count + J2_IA.PlisAnimal.Count + J2_IA.PlisPlante.Count;
Pli2Plantes = false;
Pli3Choix = false;
Pli2Choix = false;
Pli3Plantes = false;
choixPaireClick = false;
int cpt = 0;
List <Carte> paires;
paires = new List <Carte>();
foreach (Carte d in defosse)
{ //on regarde si y a une paire possible
if (c.Proprietes.Mois == d.Mois)
{
paires.Add(d);
cpt++;
}
}
if ((J1_humain_plays == false) || (MenuManager.typeJeu == 2))
{
if (MenuManager.typeJeu == 1)
{
J2_IA.AjouterPlis(c.Proprietes);
if (tour == 1)
{
J2_IA.AjouterPlis(IA.carte_defosse);
jeuIA.Remove(c.Proprietes);
}
else
{
J2_IA.AjouterPlis(paires[0]);
}
}
else
{
if (J1_humain_plays)
{
J1_humain.AjouterPlis(c.Proprietes);
if (tour == 1)
{
J1_humain.AjouterPlis(IA.carte_defosse);
jeuHumain.Remove(c.Proprietes);
}
else
{
J1_humain.AjouterPlis(paires[0]);
}
}
else
{
J2_IA.AjouterPlis(c.Proprietes);
if (tour == 1)
{
J2_IA.AjouterPlis(IA.carte_defosse);
jeuIA.Remove(c.Proprietes);
}
else
{
J2_IA.AjouterPlis(paires[0]);
}
}
}
if (tour == 1)
{
defosse.Remove(IA.carte_defosse);
}
else
{
defosse.Remove(paires[0]);
}
if (tour == 1)
{
foreach (GameCard e in cards)
{ //on va trouver la GameCard qui correspond à notre carte paire
if (pauseJeu2Choix == true)
{
if (e.Proprietes.Id == IA.carte_defosse.Id)
{
for (int i = 0; i < 12; i++)
{
if (defosseGameCard[i] != null)
{
if (e.Proprietes.Id == defosseGameCard[i].Proprietes.Id)
{
coordDefosse[i] = Vector3.zero; //puisqu'on enlève une carte de la défosse, son emplacement devient libre
defosseGameCard[i] = null;
paires.Clear();
gameCard2choix = e;
pauseJeu2Choix = false;
}
}
}
}
}
}
}
else
{
foreach (GameCard e in cards)
{ //on va trouver la GameCard qui correspond à notre carte paire
if (pauseJeu2Choix == true)
{
if (e.Proprietes.Id == paires[0].Id)
{
for (int i = 0; i < 12; i++)
{
if (defosseGameCard[i] != null)
{
if (e.Proprietes.Id == defosseGameCard[i].Proprietes.Id)
{
coordDefosse[i] = Vector3.zero; //puisqu'on enlève une carte de la défosse, son emplacement devient libre
defosseGameCard[i] = null;
paires.Clear();
gameCard2choix = e;
pauseJeu2Choix = false;
}
}
}
}
}
}
}
}
else
{
foreach (GameCard e in cards)
{
if (e.Proprietes.Id == paires[0].Id)
{
e.GetComponent <Button>().enabled = true;
e.GetComponent <Button>().interactable = true;
}
else if (e.Proprietes.Id == paires[1].Id)
{
e.GetComponent <Button>().enabled = true;
e.GetComponent <Button>().interactable = true;
}
}
choixPaireClick = true;
yield return(new WaitWhile(() => choixPaireClick));
J1_humain.AjouterPlis(c.Proprietes); //on rajoute la carte aux plis du joueur
if (tour == 1)
{
jeuHumain.Remove(c.Proprietes);
}
foreach (GameCard e in cards)
{
if (e.Proprietes.Id == paires[0].Id)
{
e.GetComponent <Button>().interactable = false;
e.GetComponent <Button>().enabled = false;
}
else if (e.Proprietes.Id == paires[1].Id)
{
e.GetComponent <Button>().interactable = false;
e.GetComponent <Button>().enabled = false;
}
}
foreach (Carte f in cartesVitrine)
{
if (f.Id == GameCard.paire2choix.Proprietes.Id)
{
J1_humain.AjouterPlis(f);
defosse.Remove(f);
for (int i = 0; i < 12; i++)
{
if (defosseGameCard[i] != null)
{
if (GameCard.paire2choix.Proprietes.Id == defosseGameCard[i].Proprietes.Id)
{
coordDefosse[i] = Vector3.zero; //puisqu'on enlève une carte de la défosse, son emplacement devient libre
defosseGameCard[i] = null;
paires.Clear();
gameCard2choix = GameCard.paire2choix;
pauseJeu2Choix = false;
}
}
}
}
}
}
}
void CardSelected(GameCard card)
{
//myHand
Debug.Log("PlayerBrain Card Selected: " + card.name);
defender.RecieveAttack(card);
}
public AfterCardReveal(GameCard target, GameCard source)
{
Target = target;
Source = source;
}
public void startGame()
{
StopAllCoroutines ();
nextButton.endFlash ();
resetButton.endFlash ();
//Get rid of all currently existing cards
if( handCards != null )
foreach (CardUI card in handCards)
Destroy (card.gameObject);
selectedCard = null;
selectedSlot = -1;
//Get rid of effects, including board cards
foreach (GameObject obj in GameObject.FindGameObjectsWithTag("effect")) {
Destroy (obj);
}
animsRunning = 0;
//Set up energy meter
meterScript.setCurrent (0);
levelBest = PlayerPrefs.GetInt( currentLevel.hand ); //Gets 0 if the key doesn't exist
int goal = ( levelBest > currentLevel.energyGoal && currentLevel.bonusGoal != -1 )
? currentLevel.bonusGoal : currentLevel.energyGoal ;
meterScript.setMax( goal );
meterScript.maxEnergyText.text = "" + goal;
meterScript.setFlagHeight (currentLevel.energyGoal);
meterScript.trophyImage.SetActive (currentLevel.bonusGoal != -1 && levelBest >= currentLevel.bonusGoal);
meterScript.flagImage.SetActive (levelBest >= currentLevel.energyGoal);
meterScript.setGhost (levelBest);
Color c = getMeterFillColor (levelBest);
c = new Color (c.r, c.g, c.b, 100f/255);
meterScript.meterFillGhost.color = c;
meterScript.meterFill.color = meterScript.normalFillColor;
//Set slots to default state
for (int i = 0; i < BoardManager.MAX_UNITS; ++i)
setSlotColor (i, slotActiveColor);
//Determine the starting hand
string[] handCodes;
handCodes = currentLevel.hand.Split ();
//Create the hand cards
handCards = new List<CardUI> ();
foreach (string code in handCodes) {
newHandCard (code, handSpawnPos.position);
}
StartCoroutine (setHandPositions ());
//Display level messages
if (currentLevel.messages != null)
msgManager.messageBox (currentLevel.messageTitle, currentLevel.messages);
else
msgManager.close ();
//Create the Board Manager
GameCard[] cards = new GameCard[handCodes.Length];
for (int i=0; i<handCodes.Length; ++i) {
cards[i] = GameCard.findByCode(handCodes[i]);
}
theGame = BoardManager.newGame(cards, this);
}
public static void Angriff(ref GameCard attacker)
{
AttackerCard = attacker;
}
IEnumerator coRecieveAttack(GameCard attackCard)
{
//attackCard
yield return new WaitForSeconds(.25f);
}
public static void Verteidigung(ref GameCard defender)
{
}
public void SetCards(GameCard c1, GameCard c2)
{
picCard1.Card = c1;
picCard2.Card = c2;
}
void CardSelected(GameCard card)
{
//myHand
Debug.Log("PlayerBrain Card Selected: " + card.name);
defender.RecieveAttack(card);
}
/// <summary>
/// Sets the cards on the table
/// </summary>
public void SetCards(GameCard c1, GameCard c2, GameCard c3, GameCard c4, GameCard c5)
{
Cards = new[] { c1, c2, c3, c4, c5 };
}
public NoneEffect(IGwentServerGame game, GameCard card) : base(game, card)
{
}
