private async void Deal()
{
ComputerThoughts = "You dare challenge I? I can calculate more moves in a second than you can possibly imagine!";
if (dealFinishied)
{
dealFinishied = false;
var deck = Cards.Shuffle(Cards.FullDeck);
foreach (var card in deck)
{
RemainingDeck.Add(card);
await Task.Delay(1);
}
for (int i = 0; i < 10; i++)
{
ComputerCards.Add(DrawTopCardFromDeck());
await Task.Delay(30);
HumanCards.Add(DrawTopCardFromDeck());
await Task.Delay(30);
}
Discards.Add(DrawTopCardFromDeck());
dealFinishied = true;
}
}
private void DiscardCardFromHand(Cards.Card p)
{
if (!humanDiscard && humanDraw)
{
HumanCards.Remove(p);
Discards.Add(p);
removePossibleCard(p);
humanDiscard = true;
startGame = true;
playerTurn = false;
}
else
{
if (!startGame)
{
RaiseNotification("You must draw a card first", "Invalid Action");
}
else
{
if (!playerTurn)
{
RaiseNotification("You already discard a card", "Invalid Action");
}
else
{
RaiseNotification("You must draw a card first", "Invalid Action");
}
}
}
}
private async void Deal()
{
var deck = Cards.Shuffle(Cards.FullDeck);
foreach (var card in deck)
{
PossibleDeck.Add(card); // Possible list of card
RemainingDeck.Add(card);
await Task.Delay(1);
}
for (int i = 0; i < 10; i++)
{
Cards.Card computerCard = DrawTopCardFromDeck();
ComputerCards.Add(computerCard);
// Remove the list of card on computer hand, as it is seen
removePossibleCard(computerCard);
await Task.Delay(30);
HumanCards.Add(DrawTopCardFromDeck());
await Task.Delay(30);
}
Discards.Add(DrawTopCardFromDeck());
// Remove the discard from possible deck
removePossibleCard(Discards[Discards.Count - 1]);
ScoreToWin = "Score To Win : " + winingScore.ToString();
scoreLabel(firstWinnerScore, secondWinnerScore);
}
public void Dahai(int index, bool isRiichi)
{
if (index != 13)
{
index = Hand.Tehai.IndexOf(Hand.SortedTehai[index]);
}
if (isRiichi)
{
//if (Shanten.CalculateShanten(Hand.AllTiles) != 0) return;
RiichiMode = true;
isDaburuRiichi_ = Discards.Count == 0;
}
Discards.Add(Hand.Dahai(index).Value);
if (wall_.RemainCount == 0)
{
IsRyukyoku = true;
}
else
{
Tsumo(new HandConfig(options: rules_,
isTsumo: true,
isRiichi: RiichiMode,
isIppatsu: isRiichi,
isDaburuRiichi: RiichiMode && isDaburuRiichi_,
playerWind: Constants.EAST,
roundWind: Constants.EAST));
}
}
private void CleanUpCards()
{
HumanCards.Clear();
ComputerCards.Clear();
RemainingDeck.Clear();
Discards.Clear();
Deal();
}
private void TakeCardFromDiscardPile(Cards.Card p)
{
if (humanTurn)
{
Discards.Remove(p);
HumanCards.Add(p);
}
}
private void DiscardCardFromHand(Cards.Card p)
{
if (HumanCards.Count > 10 && humanTurn)
{
HumanCards.Remove(p);
Discards.Add(p);
humanTurn = false;
}
}
private void TakeCardFromDiscardPile(Cards.Card p)
{
if (!takenFromDeckOrDiscardPile)
{
Discards.Remove(p);
HumanCards.Add(p);
takenFromDeckOrDiscardPile = true;
canNowDiscard = true;
}
}
private void ComputerPlayerTurn()
{
Cards.Card card = DrawTopCardFromDeck();
ComputerCards.Add(card);
ComputerCards.Remove(card);
Discards.Add(card);
computerStage = false;
pickUpStage = true;
}
private void ComputerTurn()
{
var takeDiscard = ComputerPlayer.ComputerPickupDiscard(ComputerCards, Discards[Discards.Count - 1], RemainingDeck);
if (takeDiscard)
{
var discardCard = Discards[Discards.Count - 1];
Discards.Remove(discardCard);
ComputerCards.Add(discardCard);
}
else
{
Cards.Card remainingDeckCards = RemainingDeck[RemainingDeck.Count - 1];
RemainingDeck.Remove(remainingDeckCards);
ComputerCards.Add(remainingDeckCards);
}
var compMove = ComputerPlayer.ComputerMove(ComputerCards);
ComputerCards.Remove(compMove.Item2.Value);
Discards.Add(compMove.Item2.Value);
var scores = GinRummy.Score(ComputerCards, HumanCards);
if (compMove.Item1.IsGin)
{
compScore += scores;
if (humanScore < 100 && compScore < 100)
{
RaiseNotification("Human Score: " + humanScore + ". Computer Score: " + compScore, "Scores So Far");
CleanUpCards();
}
}
else if (compMove.Item1.IsKnock)
{
if (scores > 0)
{
compScore += scores;
if (humanScore < 100 && compScore < 100)
{
RaiseNotification("Human Score: " + humanScore + ". Computer Score: " + compScore, "Scores So Far");
CleanUpCards();
}
}
else
{
humanScore += Math.Abs(scores);
if (humanScore < 100 && compScore < 100)
{
RaiseNotification("Human Score: " + humanScore + ". Computer Score: " + compScore, "Scores So Far");
CleanUpCards();
}
}
}
}
async private void ArtificialPlayer()
{
if (takenFromDeckOrDiscardPile)
{
while (true)
{
ComputerThoughts = "Calculating your impending doom ...";
foreach (var card in ComputerCards)
{
computerSeen.Remove(card);
}
GinRummy.sortByRankAndSuit(ComputerCards);
var x = ComputerPlayer.averageAllOfThePossibleDeadwoods(computerSeen, ComputerCards);
var pickupFromDeckOrDiscard = await Task.Run(() => ComputerPlayer.ComputerPickupDiscard(ComputerCards, Discards.First(), computerSeen));
if (pickupFromDeckOrDiscard) // picking up from the deck
{
ComputerThoughts = "You can not comprehend how much I know the top of the deck will benefit me, fool!";
ComputerCards.Add(DrawTopCardFromDeck());
await Task.Delay(5000);
var cardToAddToDiscard = ComputerPlayer.ComputerMove(ComputerCards);
ComputerCards.Remove(cardToAddToDiscard.Item2.Value);
Discards.Add(cardToAddToDiscard.Item2.Value);
}
else // picking up from the discard
{
ComputerThoughts = "Ahh this card will do very nicely, my thanks for allowing me to have it, fool!";
await Task.Delay(2000);
var topOfDiscard = Discards[Discards.Count - 1];
ComputerCards.Add(topOfDiscard);
Discards.Remove(topOfDiscard);
await Task.Delay(5000);
var cardToAddToDiscard = ComputerPlayer.ComputerMove(ComputerCards);
ComputerCards.Remove(cardToAddToDiscard.Item2.Value);
Discards.Add(cardToAddToDiscard.Item2.Value);
}
ComputerThoughts = "I now end my turn. Your move, human." + GinRummy.Deadwood(ComputerCards);
break;
}
canNowDiscard = false;
takenFromDeckOrDiscardPile = false;
}
}
private void nextRound()
{
CheckForEndGame();
takenFromDeckOrDiscardPile = false;
canNowDiscard = false;
HumanCards.Clear();
ComputerCards.Clear();
RemainingDeck.Clear();
Discards.Clear();
Deal();
}
public override bool CanMoveToAnotherPile(int whichOne)
{
if (Discards !.HasCard(whichOne) == false)
{
throw new BasicBlankException($"Must have at least one card on {whichOne}");
}
var oldCard = Discards.GetLastCard(whichOne);
var newCard = Discards.GetLastCard(PreviousSelected);
return((int)oldCard.Value + newCard.Value == EnumCardValueList.Jack);
}
public T DrawCard()
{
if (!DrawPile.Any())
{
DrawPile = new Queue <T>(Discards.Shuffle().ToArray());
Discards.Clear();
}
var card = DrawPile.Dequeue();
HandCards.Add(card);
return(card);
}
private void DiscardCardFromHand(Cards.Card p)
{
if (canNowDiscard)
{
HumanCards.Remove(p);
Discards.Add(p);
canNowDiscard = false;
computerSeen.Remove(p);
ArtificialPlayer();
}
}
private void TakeCardFromDiscardPile(Cards.Card p)
{
if (!humanDraw)
{
Discards.Remove(p);
HumanCards.Add(p);
humanDraw = true;
}
else
{
RaiseNotification("You already take a card", "Invalid Action");
}
}
private void TakeCardFromDiscardPile(Cards.Card p)
{
if (pickUpStage)
{
Discards.Remove(p);
HumanCards.Add(p);
pickUpStage = false;
discardStage = true;
}
else
{
RaiseNotification("Not in Pick-Up Stage", "Title");
}
}
public override bool CanAddSingleCard(int whichOne, SolitaireCard thisCard)
{
if (Discards !.HasCard(whichOne) == false)
{
return(true);
}
var oldCard = Discards.GetLastCard(whichOne);
if (thisCard.Suit != oldCard.Suit)
{
return(false);
}
return(oldCard.Value - 1 == thisCard.Value);
}
private void DiscardCardFromHand(Cards.Card p)
{
if (discardStage)
{
HumanCards.Remove(p);
Discards.Add(p);
discardStage = false;
computerStage = true;
ComputerPlayerTurn();
}
else
{
RaiseNotification("Not in Discard Stage", "Title");
}
}
public override bool CanAddSingleCard(int whichOne, SolitaireCard thisCard)
{
if (Discards !.HasCard(whichOne) == false)
{
return(true);
}
if (whichOne == 2)
{
return(false);
}
var oldCard = Discards.GetLastCard(whichOne);
if (oldCard.Value - 1 == thisCard.Value)
{
return(true);
}
return(oldCard.Value == EnumCardValueList.LowAce && thisCard.Value == EnumCardValueList.King); //because round corner.
}
// Function to reset the game for next rounds
// The game will continue if none of player has exceeded
// maximum score to win
private void resetGame()
{
Discards.Clear();
HumanCards.Clear();
ComputerCards.Clear();
RemainingDeck.Clear();
PossibleDeck.Clear();
startGame = false;
playerTurn = true;
humanDraw = false;
humanDiscard = false;
if (firstWinnerScore >= winingScore || secondWinnerScore >= winingScore)
{
scoreReset();
}
Deal();
}
public override bool CanMoveToAnotherPile(int whichOne)
{
if (PreviousSelected == -1)
{
throw new BasicBlankException("There is no pile even selected");
}
if (Discards !.HasCard(whichOne) == false)
{
return(false); //can only fill an empty spot with a card from the deck
}
var oldCard = Discards.GetLastCard(whichOne);
var newCard = Discards.GetLastCard(PreviousSelected);
if (newCard.Suit != oldCard.Suit)
{
return(false);
}
return(oldCard.Value - 1 == newCard.Value);
}
public override void MoveSingleCard(int whichOne)
{
if (GlobalClass.MainMod !.DeckPile !.IsEndOfDeck() == true)
{
throw new BasicBlankException("Can't be at the end of the deck. If so; alot of rethinking is required");
}
var thisCard = GlobalClass.MainMod.DeckPile.DrawCard();
Discards !.RemoveCardFromPile(PreviousSelected);
Discards.RemoveCardFromPile(whichOne);
Discards.PileList !.ForEach(thisPile => thisPile.IsSelected = false); //try this way.
Discards.AddCardToPile(PreviousSelected, thisCard);
if (GlobalClass.MainMod.DeckPile.IsEndOfDeck())
{
throw new BasicBlankException("Can't be at the end of the deck for the second card.");
}
thisCard = GlobalClass.MainMod.DeckPile.DrawCard();
Discards.AddCardToPile(whichOne, thisCard);
PreviousSelected = -1;
}
private void ComputerDiscardCardFromHand()
{
if (humanDiscard)
{
ComputerPlayer.Move move = ComputerPlayer.ComputerMove(ComputerCards).Item1;
Cards.Card discard = ComputerPlayer.ComputerMove(ComputerCards).Item2.Value;
Discards.Add(discard);
ComputerCards.Remove(discard);
humanDiscard = false;
playerTurn = true;
if (move == ComputerPlayer.Move.Gin)
{
endGame();
}
else if (move == ComputerPlayer.Move.Knock)
{
endGame();
}
}
}
private async void Deal()
{
var deck = Cards.Shuffle(Cards.FullDeck);
foreach (var card in deck)
{
RemainingDeck.Add(card);
await Task.Delay(1);
}
for (int i = 0; i < 10; i++)
{
ComputerCards.Add(DrawTopCardFromDeck());
await Task.Delay(30);
HumanCards.Add(DrawTopCardFromDeck());
await Task.Delay(30);
}
Discards.Add(DrawTopCardFromDeck());
}
public override bool CanMoveToAnotherPile(int whichOne)
{
if (whichOne == 2)
{
return(false);
}
if (Discards !.HasCard(whichOne) == false)
{
return(PreviousSelected == 2);
}
if (PreviousSelected == 2)
{
return(false);
}
var oldCard = Discards.GetLastCard(whichOne);
var newCard = Discards.GetLastCard(PreviousSelected);
if (oldCard.Value - 1 == newCard.Value)
{
return(true);
}
return(oldCard.Value == EnumCardValueList.LowAce && newCard.Value == EnumCardValueList.King); //because round corner.
}
private void ComputerTakeCardFromDiscardPile()
{
Cards.Card topDiscard = Discards[Discards.Count - 1];
if (humanDraw)
{
bool computerPickUp = ComputerPlayer.ComputerPickupDiscard(ComputerCards, topDiscard, PossibleDeck);
if (computerPickUp)
{
ComputerCards.Add(topDiscard);
Discards.Remove(topDiscard);
humanDraw = false;
ComputerDiscardCardFromHand();
}
else
{
var topHiddenCard = RemainingDeck[RemainingDeck.Count - 1];
ComputerCards.Add(topHiddenCard);
PossibleDeck.Remove(topHiddenCard);
RemainingDeck.Remove(topHiddenCard);
humanDraw = false;
ComputerDiscardCardFromHand();
}
}
}
public void DiscardMultible(params T[] cards)
{
HandCards.RemoveAll(c => cards.Contains(c));
Discards.AddRange(cards);
}
public void DiscardHand()
{
Discards.AddRange(HandCards.ToArray());
HandCards.Clear();
}
public void Discard(T card)
{
HandCards.Remove(card);
Discards.Add(card);
}
