HoldemHand.Hand.Hands C# (CSharp) Method

Hands() public static method

Enables a foreach command to enumerate all possible ncard hands.
public static Hands ( int numberOfCards ) : IEnumerable
numberOfCards int the number of cards in the mask (must be between 1 and 7)
return IEnumerable
        public static IEnumerable<ulong> Hands(int numberOfCards)
        {
            int a, b, c, d, e, f, g;
            ulong _card1, _n2, _n3, _n4, _n5, _n6;

            #if DEBUG
            // We only support 0-7 cards
            if (numberOfCards < 0 || numberOfCards > 7)
                throw new ArgumentOutOfRangeException("numberOfCards");
            #endif

            switch (numberOfCards)
            {
                case 7:
                    for (a = 0; a < CardMasksTableSize-6; a++)
                    {
                        _card1 = CardMasksTable[a];
                        for (b = a + 1; b < CardMasksTableSize-5; b++)
                        {
                            _n2 = _card1 | CardMasksTable[b];
                            for (c = b + 1; c < CardMasksTableSize-4; c++)
                            {
                                _n3 = _n2 | CardMasksTable[c];
                                for (d = c + 1; d < CardMasksTableSize-3; d++)
                                {
                                    _n4 = _n3 | CardMasksTable[d];
                                    for (e = d + 1; e < CardMasksTableSize-2; e++)
                                    {
                                        _n5 = _n4 | CardMasksTable[e];
                                        for (f = e + 1; f < CardMasksTableSize-1; f++)
                                        {
                                            _n6 = _n5 | CardMasksTable[f];
                                            for (g = f + 1; g < CardMasksTableSize; g++)
                                            {
                                                yield return _n6 | CardMasksTable[g];
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    break;
                case 6:
                    for (a = 0; a < CardMasksTableSize-5; a++)
                    {
                        _card1 = CardMasksTable[a];
                        for (b = a + 1; b < CardMasksTableSize-4; b++)
                        {
                            _n2 = _card1 | CardMasksTable[b];
                            for (c = b + 1; c < CardMasksTableSize-3; c++)
                            {
                                _n3 = _n2 | CardMasksTable[c];
                                for (d = c + 1; d < CardMasksTableSize-2; d++)
                                {
                                    _n4 = _n3 | CardMasksTable[d];
                                    for (e = d + 1; e < CardMasksTableSize-1; e++)
                                    {
                                        _n5 = _n4 | CardMasksTable[e];
                                        for (f = e + 1; f < CardMasksTableSize; f++)
                                        {
                                            yield return _n5 | CardMasksTable[f];
                                        }
                                    }
                                }
                            }
                        }
                    }
                    break;
                case 5:
                    for (a = 0; a < CardMasksTableSize-4; a++)
                    {
                        _card1 = CardMasksTable[a];
                        for (b = a + 1; b < CardMasksTableSize-3; b++)
                        {
                            _n2 = _card1 | CardMasksTable[b];
                            for (c = b + 1; c < CardMasksTableSize-2; c++)
                            {
                                _n3 = _n2 | CardMasksTable[c];
                                for (d = c + 1; d < CardMasksTableSize-1; d++)
                                {
                                    _n4 = _n3 | CardMasksTable[d];
                                    for (e = d + 1; e < CardMasksTableSize; e++)
                                    {
                                        yield return _n4 | CardMasksTable[e];
                                    }
                                }
                            }
                        }
                    }
                    break;
                case 4:
                    for (a = 0; a < CardMasksTableSize-3; a++)
                    {
                        _card1 = CardMasksTable[a];
                        for (b = a + 1; b < CardMasksTableSize-2; b++)
                        {
                            _n2 = _card1 | CardMasksTable[b];
                            for (c = b + 1; c < CardMasksTableSize-1; c++)
                            {
                                _n3 = _n2 | CardMasksTable[c];
                                for (d = c + 1; d < CardMasksTableSize; d++)
                                {
                                    yield return _n3 | CardMasksTable[d];
                                }
                            }
                        }
                    }
                    break;
                case 3:
                    for (a = 0; a < CardMasksTableSize-2; a++)
                    {
                        _card1 = CardMasksTable[a];
                        for (b = a + 1; b < CardMasksTableSize-1; b++)
                        {
                            _n2 = _card1 | CardMasksTable[b];
                            for (c = b + 1; c < CardMasksTableSize; c++ )
                            {
                                yield return _n2 | CardMasksTable[c];
                            }
                        }
                    }
                    break;
                case 2:
                    for (a = 0; a < TwoCardMaskTableSize; a++)
                    {
                        yield return TwoCardMaskTable[a];
                    }
                    break;
                case 1:
                    for (a = 0; a < CardMasksTableSize; a++)
                    {
                        yield return CardMasksTable[a];
                    }
                    break;
                default:
                    Debug.Assert(false);
                    yield return 0UL;
                    break;
            }
        }

Same methods

Hand::Hands ( ulong shared, ulong dead, int numberOfCards ) : IEnumerable