/// <summary>
/// Constructor.
/// </summary>
/// <param name="number"></param>
/// <param name="suit"></param>
public Card(CardEnum number, SuitEnum suit)
{
Number = number;
Suit = suit;
// Gets the value depending on the card number
switch (Number)
{
case (CardEnum.Two):
case (CardEnum.Three):
case (CardEnum.Four):
case (CardEnum.Five):
case (CardEnum.Six):
case (CardEnum.Seven):
case (CardEnum.Eight):
case (CardEnum.Nine):
case (CardEnum.Ten):
Value = (int)Number;
break;
case (CardEnum.J):
case (CardEnum.Q):
case (CardEnum.K):
Value = 10;
break;
case (CardEnum.Ace):
Value = 11;
break;
default:
Value = 0;
break;
}
}
/// <summary>
/// 连炸
/// </summary>
/// <param name="game_type"></param>
/// <param name="cards"></param>
/// <param name="result"></param>
/// <returns></returns>
public static bool CheckLineBomb(Games game_type, List <CardEnum> cards, out CombineResult result)
{
result = null;
var cards_clone = cards.Clone();
int cards_count = cards_clone.Count();
if (cards_count >= 12)
{
CardEnum min_card = cards_clone[0];
int joker_count = 0;
if (game_type.IsMetallic())
{
joker_count = cards_clone.RemoveAll(c => Jokers.Contains(c));
}
var card_groups = cards_clone.GroupBy(c => c).ToList();
List <int> bomb_count = new List <int>();
CardEnum next_card = cards_clone[0];
for (int i = 0; i < card_groups.Count; i++)
{
if (next_card == card_groups[i].First())
{
int group_count = card_groups[i].Count();
if (group_count >= 4)
{
next_card = NextCardNumber(next_card);
bomb_count.Add(group_count);
}
else if (joker_count >= 4 - group_count)
{
joker_count -= (4 - group_count);
next_card = NextCardNumber(next_card);
bomb_count.Add(4);
}
else
{
return(false);
}
}
else if (joker_count >= 4)
{
joker_count -= 4;
i -= 1;
next_card = NextCardNumber(next_card);
bomb_count.Add(4);
}
else
{
return(false);
}
}
result = new CombineResult(Combine.Bomb, (byte)GetLineBombStar(bomb_count, joker_count), min_card, (byte)cards_count);
return(true);
}
return(false);
}
public void Test_EvaluateAll7CardsCombinations()
{
_handTypeCounter.Reset();
CardEnum.Combin(StdDeck.Descriptor, 7, CardSet.Empty, CardSet.Empty, Compare7Cards);
_handTypeCounter.Verify(7);
_handTypeCounter.Print();
}
public static float[] Calculate(int[] hand, int handLength, int sdRound)
{
VerifyParameters(handLength, sdRound);
float[] hssd = new float[2];
hssd[0] = HandStrength.CalculateFast(hand, handLength);
if (handLength == 7)
{
// Nothing more to do on the river.
return(hssd);
}
int sdHandLength = HeHelper.RoundToHandSize[sdRound];
CardSet cs = StdDeck.Descriptor.GetCardSet(hand, 0, handLength);
Params p = new Params {
Hand = new int[sdHandLength]
};
for (int i = 0; i < handLength; ++i)
{
p.Hand[i] = hand[i];
}
p.Hs = hssd[0];
CardEnum.Combin <Params>(StdDeck.Descriptor, sdHandLength - handLength, p.Hand, handLength, p.Hand, handLength, OnDeal, p);
Debug.Assert(FloatingPoint.AreEqual(p.Hs, p.SumHs / p.Count, 0.00001));
hssd[1] = (float)Math.Sqrt(p.SumDiff / p.Count);
return(hssd);
}
/// <summary>
/// 炸弹
/// </summary>
/// <param name="cards"></param>
/// <param name="result"></param>
/// <returns></returns>
public static bool CheckBomb(Games game_type, List <CardEnum> cards, out CombineResult result)
{
result = null;
var cards_clone = cards.Clone();
if (cards_clone.Count < 4)
{
return(false);
}
if (game_type.IsMetallic() && cards_clone.Count() >= 12)
{
//大于12张牌，连炸可能性比较大，先判断连炸，不是判断普通炸
if (CheckLineBomb(game_type, cards_clone, out result))
{
return(true);
}
}
CardEnum base_card = cards_clone[0];
foreach (var card in cards_clone)
{
if (!(card == base_card || (game_type.IsMetallic() && Jokers.Contains(card))))
{
return(false);
}
}
result = new CombineResult(Combine.Bomb, (byte)cards_clone.Count, cards_clone[0], (byte)cards_clone.Count);
return(true);
}
public void Benchmark_2Players_GenericEnumeration()
{
// 1 Player has AcKd, 2 has 2h2s
_count = 0;
_player1 = StdDeck.Descriptor.GetCardSet("Ac Kd");
_player2 = StdDeck.Descriptor.GetCardSet("2h 2s");
CardSet dead = _player1 | _player2;
int REPETITIONS = 50;
_win = _lose = _tie = 0;
DateTime startTime = DateTime.Now;
for (int r = 0; r < REPETITIONS; ++r)
{
CardEnum.Combin(StdDeck.Descriptor, 5, CardSet.Empty, dead, Evaluate2Players);
}
double runTime = (DateTime.Now - startTime).TotalSeconds;
PrintResult(_count * 2, runTime, 0);
Assert.AreEqual(1712304 * REPETITIONS, _count);
Assert.AreEqual(799119 * REPETITIONS, _win);
Assert.AreEqual(903239 * REPETITIONS, _lose);
Assert.AreEqual(9946 * REPETITIONS, _tie);
}
// public CardPrefabrd kolegaAseksualny;
// public CardPrefabrd kolegaBiseksualny;
// public CardPrefabrd kolegaFemboy;
// public CardPrefabrd kolegaFurru;
// public CardPrefabrd kolegaGej;
// public CardPrefabrd kolegaNiebinarny;
public void generateCard(CardEnum type)
{
// switch(type)
// {
// case CardEnum.KOLEGA_ASEKSUALNY:
// generateCard(kolegaAseksualny);
// break;
//
// case CardEnum.KOLEGA_BISEKSUALNY:
// generateCard(kolegaBiseksualny);
// break;
//
// case CardEnum.KOLEGA_FEMBOY:
// generateCard(kolegaFemboy);
// break;
//
// case CardEnum.KOLEGA_FURRY:
// generateCard(kolegaFurru);
// break;
//
// case CardEnum.KOLEGA_GEJ:
// generateCard(kolegaGej);
// break;
//
// case CardEnum.KOLEGA_NIEBINARNY:
// generateCard(kolegaNiebinarny);
// break;
//
// }
}
public CombineResult(Combine combine, byte star, CardEnum min_card, byte card_num)
{
this.combine = combine;
this.star = star;
this.min_card = min_card;
this.card_num = card_num;
}
void Calculate()
{
foreach (Pocket p in _pockets)
{
_mPocket = new CardSet(
StdDeck.Descriptor.CardSets[(int)p._c1],
StdDeck.Descriptor.CardSets[(int)p._c2]);
List <double> evList = new List <double>(1225);
for (int c1 = StdDeck.Descriptor.Size - 1; c1 >= 0; --c1)
{
CardSet m1 = StdDeck.Descriptor.CardSets[c1];
if (m1.IsIntersectingWith(_mPocket))
{
continue;
}
for (int c2 = c1 - 1; c2 >= 0; --c2)
{
CardSet m2 = new CardSet(m1, StdDeck.Descriptor.CardSets[c2]);
if (m2.IsIntersectingWith(_mPocket))
{
continue;
}
_evCount = 0;
_mOther = m2;
CardEnum.Combin(StdDeck.Descriptor, 5, CardSet.Empty, _mPocket | m2, Evaluate);
double ev = 0.5 * _evCount / _boardsCount;
p._evDict.Add(m2, ev);
}
}
}
}
/// <summary>
/// This method returns the Card
/// </summary>
private static string ConvertCard(CardEnum card, ICardCountingSystem countingSystem)
{
// initial value
string cardValue = "";
// locals
Card redCard = null;
Card blackCard = null;
string redCardValue = "";
string blackCardValue = "";
// create a red and black card
redCard = new Card(SuitEnum.Hearts, card, countingSystem);
blackCard = new Card(SuitEnum.Spades, card, countingSystem);
redCardValue = GetCardValue(redCard, countingSystem);
blackCardValue = GetCardValue(blackCard, countingSystem);
// if the values are the same
if (redCardValue == blackCardValue)
{
// Set the value
cardValue = redCardValue.ToString();
}
else
{
// Set both values
cardValue = redCardValue.ToString() + @"/" + blackCardValue.ToString();
}
// return value
return(cardValue);
}
public void Benchmark_3Players_GenericEnumeration()
{
// 1st Player has KcKh, 2nd has 7s6s, 3rd has AcQc
_count = 0;
_player1 = StdDeck.Descriptor.GetCardSet("Kc Kh");
_player2 = StdDeck.Descriptor.GetCardSet("7s 6s");
_player3 = StdDeck.Descriptor.GetCardSet("Ac Qc");
CardSet dead = _player1 | _player2 | _player3;
int REPETITIONS = 20;
_win = _lose = _tie = 0;
DateTime startTime = DateTime.Now;
for (int r = 0; r < REPETITIONS; ++r)
{
CardEnum.Combin(StdDeck.Descriptor, 5, CardSet.Empty, dead, Evaluate3Players);
}
double runTime = (DateTime.Now - startTime).TotalSeconds;
PrintResult(_count * 3, runTime, 0);
Assert.AreEqual(1370754 * REPETITIONS, _count);
Assert.AreEqual(683919 * REPETITIONS, _win);
Assert.AreEqual(683386 * REPETITIONS, _lose);
Assert.AreEqual(3449 * REPETITIONS, _tie);
}
/// <summary>
/// Create a new instance of a Card object.
/// </summary>
/// <param name="suit"></param>
/// <param name="cardName"></param>
/// <param name="cardValueManager"></param>
public Card(SuitEnum suit, CardEnum cardName, ICardValueManager cardValueManager)
{
// Store the parameters
this.Suit = suit;
this.CardName = cardName;
this.CardValueManager = cardValueManager;
}
public void Test_Random()
{
int REPETITIONS = 100;
#if DEBUG
REPETITIONS = 8;
#endif
int seed = (int)DateTime.Now.Ticks;
Console.WriteLine("Random seed {0}", seed);
Random rand = new Random(seed);
_cardRng = new SequenceRng(seed);
_cardRng.SetSequence(StdDeck.Descriptor.FullDeckIndexes);
for (int r = 0; r < REPETITIONS; ++r)
{
_enumCount = r % 7;
int sharedCount = rand.Next(0, StdDeck.Descriptor.Size + 1 - _enumCount);
int deadCount = rand.Next(0, StdDeck.Descriptor.Size + 1 - sharedCount - _enumCount);
_cardRng.Shuffle(sharedCount + deadCount);
int rc = 0;
_shared = new CardSet();
for (int i = 0; i < sharedCount; ++i)
{
_shared |= StdDeck.Descriptor.CardSets[_cardRng.Sequence[rc++]];
}
_dead = new CardSet();
for (int i = 0; i < deadCount; ++i)
{
_dead |= StdDeck.Descriptor.CardSets[_cardRng.Sequence[rc++]];
}
Debug.Assert(rc == sharedCount + deadCount);
Debug.Assert(!_shared.IsIntersectingWith(_dead));
//Console.WriteLine("B: {0:x16} D:{1:x16}", board, dead);
_combinationsCount = 0;
_lastCs = 0;
CardEnum.Combin(StdDeck.Descriptor, _enumCount, _shared, _dead, VerifyCombination);
Assert.AreEqual(EnumAlgos.CountCombin(StdDeck.Descriptor.Size - sharedCount - deadCount, _enumCount), _combinationsCount);
_combinationsCount1 = 0;
_lastCs1 = 0;
CardEnum.Combin(StdDeck.Descriptor, _enumCount, _shared, _dead, VerifyCombinationParam, _combinationsCount);
Assert.AreEqual(EnumAlgos.CountCombin(StdDeck.Descriptor.Size - sharedCount - deadCount, _enumCount), _combinationsCount1);
_combinationsCount1 = 0;
_lastCs1 = 0;
int[] cards = new int[_enumCount + sharedCount].Fill(-1);
StdDeck.Descriptor.GetIndexesAscending(_shared).ToArray().CopyTo(cards, 0);
int[] deadIdx = StdDeck.Descriptor.GetIndexesAscending(_shared | _dead).ToArray();
CardEnum.Combin(StdDeck.Descriptor, _enumCount, cards, sharedCount, deadIdx, deadIdx.Length, VerifyCombinationParam, _combinationsCount);
Assert.AreEqual(EnumAlgos.CountCombin(StdDeck.Descriptor.Size - sharedCount - deadCount, _enumCount), _combinationsCount1);
}
Console.WriteLine("{0} repetitions done.", REPETITIONS);
}
public static float Calculate(CardSet board)
{
CalulateParam param = new CalulateParam();
int boardSize = board.CountCards();
int toDeal = 7 - boardSize;
CardEnum.Combin(StdDeck.Descriptor, toDeal, board, CardSet.Empty, OnDeal, param);
return((float)(param.Sum / EnumAlgos.CountCombin(52 - boardSize, toDeal)));
}
public void Test_ProofOfConcept()
{
ProofOfConceptParam param = new ProofOfConceptParam();
CardEnum.Combin(StdDeck.Descriptor, 2, CardSet.Empty, CardSet.Empty, OnCombinProofOfConcept, param);
double avHs = param.SumHs / param.Count;
Assert.AreEqual(0, param.SumDev, 0.0001);
Assert.AreEqual(0.5, avHs, 0.0001);
}
public void Test_CountCombinations_Idx()
{
int[] cards = new int[7];
for (int i = 0; i <= 6; ++i)
{
_combinationsCount1 = 0;
CardEnum.Combin(StdDeck.Descriptor, i, cards, 0, null, 0, CountCombinationsParam, 33);
Assert.AreEqual(EnumAlgos.CountCombin(52, i), _combinationsCount1);
}
}
double CalculateAverageHVO(int[] board)
{
CardSet boardCs = StdDeck.Descriptor.GetCardSet(board);
CalculateAverageHsParam param = new CalculateAverageHsParam();
int toDealCount = 7 - board.Length;
CardEnum.Combin(StdDeck.Descriptor, toDealCount, boardCs, CardSet.Empty, OnPocket, param);
Assert.AreEqual(EnumAlgos.CountCombin(52 - board.Length, toDealCount), param.Count);
return(param.Sum / param.Count);
}
public void Benchmark_All7Cards_GenericEnumerationParam()
{
_count = 0;
DateTime startTime = DateTime.Now;
CardEnum.Combin(StdDeck.Descriptor, 7, CardSet.Empty, CardSet.Empty, Evaluate7CardsParam, this);
double runTime = (DateTime.Now - startTime).TotalSeconds;
PrintResult(_count, runTime, _checksum);
}
/// <summary>
/// 连对
/// </summary>
/// <param name="cards"></param>
/// <param name="result"></param>
/// <returns></returns>
public static bool CheckLinePairs(Games game_type, List <CardEnum> cards, out CombineResult result)
{
result = null;
var cards_clone = cards.Clone();
if (cards_clone.Count >= 6 && cards_clone.Count % 2 == 0)
{
CardEnum min_card = cards_clone[0];
byte card_count = (byte)cards_clone.Count;
int joker_count = 0;
if (game_type.IsMetallic())
{
joker_count = cards_clone.RemoveAll(c => Jokers.Contains(c));
}
int count = cards_clone.Count;
CardEnum next_card = cards_clone[0];
for (int i = 0; i < cards_clone.Count; i += 2)
{
if (i < count && cards_clone[i] == next_card)
{
if (i + 1 < count && cards_clone[i + 1] == next_card)
{
next_card = NextCardNumber(next_card);
}
else if (joker_count >= 1)
{
--joker_count;
--i;
next_card = NextCardNumber(next_card);
}
else
{
return(false);
}
}
else if (joker_count >= 2)
{
joker_count -= 2;
i -= 2;
next_card = NextCardNumber(next_card);
}
else
{
return(false);
}
}
result = new CombineResult(Combine.LinePairs, 0, min_card, card_count);
return(true);
}
return(false);
}
private List <HandDistrEntry> CalculateHsDistribution(string boardS)
{
CardSet board = StdDeck.Descriptor.GetCardSet(boardS);
HandDistrParams param = new HandDistrParams {
Board = board, Distr = new List <HandDistrEntry>()
};
CardEnum.Combin(StdDeck.Descriptor, 2, CardSet.Empty, board, OnPocket, param);
param.Distr.Sort();
return(param.Distr);
}
public void Omaha()
{
Reset();
Console.WriteLine("Calculate number of chance nodes from 1 player perspective for Omaha");
CardEnum.Combin(StdDeck.Descriptor, 4, CardSet.Empty, CardSet.Empty, SuitIsomorphismPreflopOmaha);
Console.WriteLine("Preflop Chance Nodes: colored: {0}, color-isomorphic: {1} {2:0.##}%",
_pocketCount, _normPreflopCount, 100.0 * _normPreflopCount / _pocketCount);
Assert.AreEqual(EnumAlgos.CountCombin(52, 4), _pocketCount);
// Value verified in Wiki, etc.
Assert.AreEqual(16432, _normPreflopCount);
}
public Card(char rank, char suit)
{
CardValueEnum _rank = rankParseLookup[rank];
SuitEnum _suit = suitParseLookup[suit];
_card = (CardEnum)((int)_suit + (int)_rank);
if (_suit == SuitEnum.Unknown || _rank == CardValueEnum.Unknown)
{
throw new ArgumentException("Hand is not correctly formatted. Value: " + rank + " Suit: " + suit);
}
}
public Card(char rank, char suit)
{
var r = ParseRank(rank);
var s = ParseSuit(suit);
if (r == null || s == null)
{
throw new ArgumentException("Hand is not correctly formatted. Value: " + rank + " Suit: " + suit);
}
CardEnum = GetCardEnum(r.Value, s.Value);
}
public Card(char rank, char suit)
{
CardValueEnum _rank = rankParseLookup[rank];
SuitEnum _suit = suitParseLookup[suit];
_card = (CardEnum)((int)_suit + (int)_rank);
if (_suit == SuitEnum.Unknown || _rank == CardValueEnum.Unknown)
{
throw new ArgumentException("Hand is not correctly formatted. Value: " + rank + " Suit: " + suit);
}
}
/// <summary>
/// Constructor, accepting the typeOfCard, and generating the values for the profit-array.
/// </summary>
/// <param name="typeOfCard"> The type of card you want to create. </param>
internal BohnanzaCard(CardEnum typeOfCard)
{
_typeOfCard = typeOfCard;
switch (_typeOfCard)
{
case CardEnum.CoffeeBeans:
Profit = new int?[] { 4, 7, 10, 12 };
_totalNumberOfCards = 24;
break;
case CardEnum.WaxBeans:
Profit = new int?[] { 4, 7, 9, 11 };
_totalNumberOfCards = 22;
break;
case CardEnum.BlueBeans:
Profit = new int?[] { 4, 6, 8, 10 };
_totalNumberOfCards = 20;
break;
case CardEnum.ChilliBeans:
Profit = new int?[] { 3, 6, 8, 9 };
_totalNumberOfCards = 18;
break;
case CardEnum.StinkBeans:
Profit = new int?[] { 3, 5, 7, 8 };
_totalNumberOfCards = 16;
break;
case CardEnum.GreenBeans:
Profit = new int?[] { 3, 5, 6, 7 };
_totalNumberOfCards = 14;
break;
case CardEnum.SoyBeans:
Profit = new int?[] { 2, 4, 6, 7 };
_totalNumberOfCards = 12;
break;
case CardEnum.BlackEyedBeans:
Profit = new int?[] { 2, 4, 5, 6 };
_totalNumberOfCards = 10;
break;
case CardEnum.RedBeans:
Profit = new int?[] { 2, 3, 4, 5 };
_totalNumberOfCards = 8;
break;
case CardEnum.GardenBeans:
Profit = new int?[] { null, 2, 3, null };
_totalNumberOfCards = 6;
break;
case CardEnum.CocoaBeans:
Profit = new int?[] { null, 2, 3, 4 };
_totalNumberOfCards = 4;
break;
}
}
public void Test_CountCombinations_CardSet()
{
for (int i = 0; i <= 6; ++i)
{
_combinationsCount = 0;
CardEnum.Combin(StdDeck.Descriptor, i, CardSet.Empty, CardSet.Empty, CountCombinations);
Assert.AreEqual(EnumAlgos.CountCombin(52, i), _combinationsCount);
_combinationsCount1 = 0;
CardEnum.Combin(StdDeck.Descriptor, i, CardSet.Empty, CardSet.Empty, CountCombinationsParam, _combinationsCount);
Assert.AreEqual(EnumAlgos.CountCombin(52, i), _combinationsCount1);
}
}
public CardModel(CardSO Data, MainController mainController)
{
CardEnum = Data.CardEnum;
CardEnum.MainController = mainController;
CardEnum.SpawnPlace = GameObject.FindGameObjectWithTag("CardPosition").transform;
Card = GameObject.Instantiate(CardEnum.Prefab, CardEnum.SpawnPlace);
Card.transform.SetParent(CardEnum.SpawnPlace);
CardEnum.MainController.CardsModels.Add(Card.GetInstanceID(), this);
Sprite = Card.transform.Find("CardSprite").gameObject;
Sprite.GetComponent <Image>().sprite = CardEnum.Sprite;
HealthText = Card.transform.GetChild(1).transform.GetChild(1).transform.Find("HealthText").gameObject;
CardEnum.Health = Random.Range(1, 5);
HealthText.GetComponent <Text>().text = CardEnum.Health.ToString();
}
public Card(char rank, char suit)
{
_card = CardEnum._Unknown;
if (rankParseLookup[rank] == CardValueEnum.Unknown)
{
throw new ArgumentException("Rank is not correctly formatted. Should be 2-9, T, J, Q, K or A.");
}
if (suitParseLookup[suit] == SuitEnum.Unknown)
{
throw new ArgumentException("Suit is not correctly formatted. Should be c, d, h or s.");
}
_card = (CardEnum)((int)suitParseLookup[suit] + (int)rankParseLookup[rank]);
}
public void Test_CombinArray_CardSet()
{
CardSet[] arr = CardEnum.Combin(StdDeck.Descriptor, 2, CardSet.Empty, CardSet.Empty);
Assert.AreEqual(1326, arr.Length);
CardSet prev = arr[0];
Assert.AreEqual(2, prev.CountCards());
for (int i = 1; i < arr.Length; ++i)
{
CardSet cur = arr[i];
Assert.Less(prev.bits, cur.bits);
Assert.AreEqual(2, cur.CountCards());
prev = cur;
}
}
public void Benchmark_CountCombinations_Idx()
{
int count;
DateTime startTime;
double runTime;
int[] cards = new int[7];
count = 0;
startTime = DateTime.Now;
CardEnum.Combin(StdDeck.Descriptor, 7, cards, 0, null, 0, (int[] c, CardEnum_Test t) => { count++; }, this);
runTime = (DateTime.Now - startTime).TotalSeconds;
Console.WriteLine("Cardset (object parameter): {0:#,#} combinations, {1:0.0} s, {2:#,#} comb/s", count, runTime,
count / runTime);
}
public void Test_CountDistinctHandValues7()
{
for (int i = 0; i < (int)HandValue.Kind._Count + 1; ++i)
{
_uniqHandValues[i] = new HashSet <uint>();
}
CardEnum.Combin(StdDeck.Descriptor, 7, CardSet.Empty, CardSet.Empty, CountDistinctHandValues);
Console.WriteLine("Number of unique 7-card combinations:");
for (int i = 0; i < (int)HandValue.Kind._Count + 1; ++i)
{
Console.WriteLine("{0, 13}: {1,4}", ((HandValue.Kind)i).ToString(), _uniqHandValues[i].Count);
}
// Cross-verified with LutEvaluator7.
Assert.AreEqual(4824, _uniqHandValues[(int)HandValue.Kind._Count].Count);
}
/// <summary>
/// Precalculate and store tables. If the output already exists, will not overwrite.
/// <remarks>Long-running. </remarks>
/// </summary>
/// <param name="round">Round (0, 1 or 2).</param>
public static void Precalculate(int round)
{
DateTime startTime = DateTime.Now;
string lutPath = GetLutPath(round);
if (File.Exists(lutPath))
{
// Do not ovewriting an existing file to save time.
Console.WriteLine("LUT file {0} already exist, exiting. Delete the file to recalculate.", lutPath);
return;
}
int POCKETS_COUNT = (int)HePocketKind.__Count;
//POCKETS_COUNT = 1; // Test
PrecalculationContext context = new PrecalculationContext {
Round = round
};
int[] listSize = new int[] { 169, 1361802, 15111642 };
context.list = round < 2 ? (object)new List <Entry01>(listSize[round]) : (object)new List <Entry2>(listSize[round]);
Console.WriteLine("Calculating for round {0}: ", round);
int boardSize = HeHelper.RoundToHandSize[round] - 2;
for (int p = 0; p < POCKETS_COUNT; ++p)
{
context.pocketKind = (HePocketKind)p;
context.pocket = HePocket.KindToCardSet((HePocketKind)p);
context.pocketSei.Reset();
context.pocketSei.Convert(context.pocket);
Console.Write("{0} ", HePocket.KindToString((HePocketKind)p));
CardEnum.Combin(StdDeck.Descriptor, boardSize, CardSet.Empty, context.pocket, OnPrecalculateBoard, context);
}
Console.WriteLine();
Debug.Assert(EnumAlgos.CountCombin(50, boardSize) * POCKETS_COUNT == context.count);
if (round < 2)
{
WriteTable((List <Entry01>)context.list, lutPath);
}
else
{
WriteTable((List <Entry2>)context.list, lutPath);
}
Console.WriteLine("LUT file {0} written, calculated in {1:0.0} s", lutPath, (DateTime.Now - startTime).TotalSeconds);
}
/// <summary>
/// Constructor, accepting the typeOfCard, and generating the values for the profit-array.
/// </summary>
/// <param name="typeOfCard"> The type of card you want to create. </param>
internal AlCabohneCard(CardEnum typeOfCard)
{
_typeOfCard = typeOfCard;
switch (_typeOfCard)
{
case CardEnum.BlueBeans:
Profit = new int?[] { 4, 6, 8, 10 };
_totalNumberOfCards = 20;
break;
case CardEnum.PuffBeans:
Profit = new int?[] { 4, 7, 9, 11 };
_totalNumberOfCards = 16;
break;
case CardEnum.RunnerBeans:
Profit = new int?[] { 4, 6, 8, 10 };
_totalNumberOfCards = 13;
break;
case CardEnum.KidneyBeans:
Profit = new int?[] { 3, 6, 8, 9 };
_totalNumberOfCards = 19;
break;
case CardEnum.BroadBeans:
Profit = new int?[] { 3, 5, 7, 8 };
_totalNumberOfCards = 16;
break;
case CardEnum.FireBeans:
Profit = new int?[] { 3, 5, 6, 7 };
_totalNumberOfCards = 18;
break;
case CardEnum.FrenchBeans:
Profit = new int?[] { 2, 4, 6, 7 };
_totalNumberOfCards = 14;
break;
}
}
private Card(SuitEnum suit, CardValueEnum rank)
{
_card = (CardEnum)((int)suit + (int)rank);
}
