/// <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); }
/// <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); }