private int ScorePairs(List <CardView> list, ScoreCollection scoreStory, HandType handType)
{
List <List <CardView> > listlist = GetPairCards(list);
int score = 0;
foreach (List <CardView> cards in listlist)
{
int cardCount = cards.Count;
StatName name = StatName.Ignored;
if (cardCount == 2)
{
name = (handType == HandType.Regular) ? StatName.HandPairs : StatName.CribPairs;
score += 2;
}
else if (cardCount == 3)
{
name = (handType == HandType.Regular) ? StatName.Hand3OfAKind : StatName.Crib3OfAKind;
score += 6;
}
else if (cardCount == 4)
{
score += 12;
name = (handType == HandType.Regular) ? StatName.Hand4OfAKind : StatName.Crib4OfAKind;
}
scoreStory.Scores.Add(new ScoreInstance(name, 1, score, CardListToIntList(cards)));
}
return(score);
}
public ScoreCollection UpdateScoreForCrib(PlayerType type, long scoredelta)
{
Player p = GetPlayer(type);
ScoreCollection ss = new ScoreCollection();
ss.ScoreType = ScoreType.Crib;
ss.Accepted = false;
if (p != null && p.HasCrib)
{
int score = p.Crib.ScoreHand(_deck.SharedCard, ss, HandType.Crib);
if (p.Type == PlayerType.Computer)
{
scoredelta = score;
}
if (score == scoredelta)
{
ss.Accepted = true;
p.Score += score;
}
}
if (ss.Accepted)
{
ToggleDeal();
}
else
{
MainPage.LogTrace.TraceMessageAsync(String.Format("Warning: Crib backScore not accepted! Deal not toggled."));
}
return(ss);
}
/// <summary>
/// the score is set to what is in the Total field, not the ActualScore field
/// </summary>
/// <param name="type"></param>
/// <param name="handType"></param>
/// <param name="scoredelta"></param>
/// <param name="difficulty"></param>
/// <param name="muggins"></param>
/// <returns></returns>
public ScoreCollection UpdateScore(PlayerType type, HandType handType, long scoredelta, GameDifficulty difficulty)
{
ScoreCollection score = new ScoreCollection();
if (handType == HandType.Crib)
{
score.ScoreType = ScoreType.Crib;;
score = UpdateScoreForCrib(type, scoredelta);
}
else
{
Player p = GetPlayer(type);
score.ScoreType = ScoreType.Hand;
if (p != null)
{
int s = p.Hand.ScoreHand(_deck.SharedCard, score, handType);
if (p.Type == PlayerType.Computer)
{
scoredelta = s;
}
if (s == scoredelta)
{
score.Accepted = true;
p.Score += score.Total;
}
}
}
return(score);
}
int ScoreFifteens(List <CardView> list, ScoreCollection scoreStory, HandType handType)
{
int score = 0;
List <List <CardView> > listlist = ScoreFifteensInternal(list);
foreach (List <CardView> cards in listlist)
{
StatName name = (handType == HandType.Regular) ? StatName.Hand15s : StatName.Crib15s;
scoreStory.Scores.Add(new ScoreInstance(name, 1, 2, CardListToIntList(cards)));
score += 2;
}
return(score);
}
public int GetScore(PlayerType type, HandType handType)
{
Player p = GetPlayer(type);
ScoreCollection score = new ScoreCollection();
if (handType == HandType.Regular)
{
score.ScoreType = ScoreType.Hand;
return(p.Hand.ScoreHand(_deck.SharedCard, score, handType));
}
score.ScoreType = ScoreType.Crib;
return(p.Crib.ScoreHand(_deck.SharedCard, score, handType));
}
/// <summary>
/// a web request comes into the service to play a card during counting phase.
///
/// we
/// 1. Verify it is the right turn
/// 2. Verify the card is in the hand
/// 3. Count the card
/// 4. remove the card
/// 5. set the turn state
/// 6. return the state of the count
///
/// Whoever should go next should be definitively set
/// </summary>
/// <param name="PlayerId"></param>
/// <param name="card"></param>
/// <returns></returns>
public CountingState PlayCard(Player player, CardView card, GameDifficulty diffuculty)
{
if (_state.TurnPlayer != player)
{
throw new Exception("Not your turn!");
}
List <CardView> cards = _playerHand;
if (player.Type == PlayerType.Computer)
{
cards = _computerHand;
}
if (cards.Contains(card))
{
ScoreCollection score = null;
if (CountCard(card, out score) != -1)
{
_state.ScoreStory = score;
_state.LastScore = score.Total;
cards.Remove(card);
if (!HasCardsToPlay)
{
_state.LastScore++; // point for last card
score.Scores.Add(new ScoreInstance(StatName.CountingLastCard, 1, 1, card.Index));
score.Total++;
}
score.ActualScore = score.Total;
}
}
UpdateTurnState();
MainPage.LogTrace.TraceMessageAsync(String.Format("In PlayCard. Player:{0} Score:{1} Adding:{2} CardPlayed:{3}", player.Type, player.Score, _state.LastScore, card.Data.Name));
player.Score += _state.LastScore;
return(_state);
}
public List <CardView> PickCribCards(List <CardView> hand, CardView sharedCard, bool myCrib, GameDifficulty diffuculty)
{
Combinations <CardView> combinations = new Combinations <CardView>(hand, 4);
List <CardView> maxCrib = null;
double maxScore = -1000.0;
foreach (List <CardView> cards in combinations)
{
if (sharedCard != null)
{
cards.Add(sharedCard);
}
ScoreCollection scoreStory = new ScoreCollection();
double score = (double)ScoreCards(cards, scoreStory, HandType.Regular);
List <CardView> crib = GetCrib(hand, cards);
double expectedValue = 0.0;
if (diffuculty == GameDifficulty.Hard)
{
if (myCrib)
{
expectedValue = CribbageStats.dropTableToMyCrib[crib[0].Rank - 1, crib[1].Rank - 1];
score += expectedValue;
}
else
{
expectedValue = CribbageStats.dropTableToYouCrib[crib[0].Rank - 1, crib[1].Rank - 1];
score -= expectedValue;
}
}
if (score > maxScore)
{
maxScore = score;
maxCrib = crib;
}
}
return(maxCrib);
}
public int ScoreCards(List <CardView> list, ScoreCollection scoreStory, HandType handType)
{
int score = 0;
score += ScoreNibs(list, scoreStory, handType); // this is the only one where it matters which particular card is shared
//
// DON't SORT BEFORE NIBS!!!
list.Sort(CardView.CompareCardsByRank);
score += ScoreFifteens(list, scoreStory, handType);
score += ScorePairs(list, scoreStory, handType);
score += ScoreRuns(list, scoreStory, handType);
score += ScoreFlush(list, scoreStory, handType);
scoreStory.Total = score;
scoreStory.ActualScore = score;
return(score);
}
private int ScoreNibs(List <CardView> list, ScoreCollection scoreStory, HandType handType)
{
if (list.Count == 4) // shared card, not passed in, we can't tell if we have nibs
{
return(0);
}
for (int i = 0; i < 4; i++)
{
if (list[i].Rank == 11) //Jack -- 1 indexed
{
if (list[i].Suit == list[4].Suit)
{
StatName name = (handType == HandType.Regular) ? StatName.HandJackOfTheSameSuit : StatName.CribJackOfTheSameSuit;
scoreStory.Scores.Add(new ScoreInstance(name, 1, 1, list[i].Index));
return(1);
}
}
}
return(0);
}
public int ScoreHand(CardView sharedCard, ScoreCollection scoreStory, HandType handType)
{
int score = 0;
List <CardView> list = new List <CardView>(_cards);
list.Add(sharedCard);
score = ScoreCards(list, scoreStory, handType);
string trace = "Cards: ";
foreach (CardView c in _cards)
{
trace += c.Data.Name.ToString() + " ";
}
trace += "Shared: " + sharedCard.Data.Name.ToString();
trace += " Score: " + score;
MainPage.LogTrace.TraceMessageAsync(trace);
return(score);
}
/// <summary>
/// by the time we've gotten here, we've verified that Card is valid
/// </summary>
/// <param name="card"></param>
private int CountCard(CardView card, out ScoreCollection score)
{
int nScore = 0;
score = new ScoreCollection();
score.ScoreType = ScoreType.Count;
if (card.Value + _state.Count > 31)
{
throw new Exception("The total count must be less than 31. Play a different card");
}
List <int> cardIndeces = new List <int>();
if (card.Value + _state.Count == 15)
{
cardIndeces = Hand.CardListToIntList(_countedCards);
cardIndeces.Add(card.Index);
nScore += 2;
score.Scores.Add(new ScoreInstance(StatName.CountingHit15, 1, 2, cardIndeces));
cardIndeces.Clear();
}
if (card.Value + _state.Count == 31)
{
nScore += 2;
score.Scores.Add(new ScoreInstance(StatName.CountingHit31, 1, 2, card.Index));
cardIndeces.Clear();
}
_countedCards.Insert(0, card);
int run = FindARun(_countedCards);
StatName statName = StatName.Ignored;
if (run > 0)
{
switch (run)
{
case 3:
statName = StatName.Counting3CardRun;
break;
case 4:
statName = StatName.Counting4CardRun;
break;
case 5:
statName = StatName.Counting5CardRun;
break;
case 6:
statName = StatName.Counting6CardRun;
break;
case 7:
statName = StatName.Counting7CardRun;
break;
default:
MainPage.LogTrace.TraceMessageAsync(String.Format("ERROR: Bug in CountCard looking for run length! run: {0}", run));
break;
}
score.Scores.Add(new ScoreInstance(statName, run, run, Hand.CardListToIntList(_countedCards, run)));
}
nScore += run;
int pairs = FindPairs(_countedCards);
if (pairs > 0)
{
switch (pairs) // this is points from pairs, not pairs count
{
case 2:
cardIndeces = Hand.CardListToIntList(_countedCards, 2);
statName = StatName.CountingPair;
break;
case 6:
cardIndeces = Hand.CardListToIntList(_countedCards, 3);
statName = StatName.Counting3OfAKind;
break;
case 12:
cardIndeces = Hand.CardListToIntList(_countedCards, 4);
statName = StatName.Counting4OfAKind;
break;
default:
MainPage.LogTrace.TraceMessageAsync(String.Format("ERROR: Bug in CountCard looking for pairs! pairs:{0}", pairs));
break;
}
score.Scores.Add(new ScoreInstance(statName, 1, pairs, cardIndeces));
}
nScore += pairs;
_state.Count += card.Value;
_state.LastScore = nScore;
_state.CardsCounted++;
score.Total = nScore;
return(nScore);
}
//
// just call ScoreRuns to get ths list..
private int ScoreRuns(List <CardView> list, ScoreCollection scoreStory, HandType handType)
{
List <List <CardView> > cardLists = DemuxPairs(list);
List <List <CardView> > runs = new List <List <CardView> >();
List <ScoreInstance> scores = new List <ScoreInstance>();
foreach (List <CardView> cards in cardLists)
{
List <CardView> l = GetRuns(cards);
if (l != null)
{
runs.Add(l);
}
}
//
// eliminate duplicate lists - this happens if you have a hand that looks like 5, 5, 7, 8, 9 where the pair is not in the run
if (runs.Count == 2)
{
if (runs[0].Count == runs[1].Count) // same length
{
bool same = false;
for (int i = 0; i < runs[0].Count; i++)
{
if (runs[0][i] != runs[1][i])
{
same = false;
break;
}
same = true;
}
if (same)
{
runs.RemoveAt(1);
}
}
}
//
// runs now how the list of cards that have runs in them
int score = 0;
{
foreach (List <CardView> cards in runs)
{
if (cards.Count > 2)
{
StatName name = StatName.Ignored;
switch (cards.Count)
{
case 3:
name = (handType == HandType.Regular) ? StatName.Hand3CardRun : StatName.Crib3CardRun;
break;
case 4:
name = (handType == HandType.Regular) ? StatName.Hand4CardRun : StatName.Crib4CardRun;
break;
case 5:
name = (handType == HandType.Regular) ? StatName.Hand5CardRun : StatName.Crib5CardRun;
break;
default:
MainPage.LogTrace.TraceMessageAsync(String.Format("ERRROR: invalid Maxrun. id:2109347809. maxrun: {0}", cards.Count));
break;
}
score += cards.Count;
scoreStory.Scores.Add(new ScoreInstance(name, 1, cards.Count, CardListToIntList(cards)));
}
}
}
return(score);
}
private int ScoreFlush(List <CardView> list, ScoreCollection scoreStory, HandType handType)
{
List <int>[] cards = new List <int> [4];
for (int i = 0; i < 4; i++)
{
cards[i] = new List <int>();
}
foreach (CardView c in list)
{
switch (c.Suit)
{
case Suit.Clubs:
cards[0].Add(c.Index);
break;
case Suit.Hearts:
cards[1].Add(c.Index);
break;
case Suit.Diamonds:
cards[2].Add(c.Index);
break;
case Suit.Spades:
cards[3].Add(c.Index);
break;
}
}
int minCardsForFlush = 4;
if (handType == HandType.Crib)
{
minCardsForFlush++;
}
int score = 0;
for (int i = 0; i < 4; i++)
{
if (cards[i].Count >= minCardsForFlush)
{
StatName name = StatName.Ignored;
switch (cards[i].Count)
{
case 4:
name = StatName.Hand4CardFlush; // no 4 card flush in crib
break;
case 5:
name = (handType == HandType.Regular) ? StatName.Hand5CardFlush : StatName.Crib5CardFlush;
break;
default:
MainPage.LogTrace.TraceMessageAsync(String.Format("ERROR: flushcount wrong. count:{0}", cards[i].Count));
break;
}
score = cards[i].Count;
scoreStory.Scores.Add(new ScoreInstance(name, 1, cards[i].Count, cards[i]));
break;
}
}
return(score);
}
