// Card constructor using enumerated types.
       public Card (Suits suit, Rank rank)
       {
           this.suit = suit;
           this.rank = rank;
           description = this.ToString().ToLower().Replace(" ", "_");
 
       }

 public PokerHand(string cards)
 {
     var pokerCards = cards.Split(' ').Select(cardValue => new PokerCard(cardValue)).ToList();
     pokerCards.Sort();
     var groups = from card in pokerCards group card by card.Denomination;
     switch (groups.Count())
     {
         case 4:
             Rank = Rank.Pair;
             break;
         case 3:
             Rank = Rank.TwoPairs;
             break;
         case 2:
             Rank = Rank.FullHouse;
             break;
         case 5:
             Rank = Rank.Straight;
             for (int i = 1; i < pokerCards.Count; i++)
             {
                 if (pokerCards[i].Denomination - pokerCards[i - 1].Denomination != 1)
                 {
                     Rank = Rank.UNKNOWN;
                     break;
                 }
             }
             break;
         default:
             Rank = Rank.UNKNOWN;
             break;
     }
 }

 public Bullet(Texture2D texture, Rank rank, Vector2 position, float direction)
 {
     this.position = position;
     this.direction = direction;
     this.texture = texture;
     this.rank = rank;
 }

 static int GetLimitIndex( Rank rank, Permission permission ) {
     if( rank.HasLimitSet( permission ) ) {
         return rank.GetLimit( permission ).Index + 1;
     } else {
         return 0;
     }
 }

 public MonteCarloModel(int rankCount, Rank[] ranks)
 {
     MyDistribution = new Distribution();
     MyDistribution.RankCount = rankCount;
     MyDistribution.Ranks = ranks;
     Run();
 }

        public void UpdateRankingForSpecificUser(aspnet_User user, int uid)
        {
            int NoAccepted = uvareq.GetUvaUserSolvedProblems(uid);
            Rank userRank;

            try
            {
                if ( user.Rank != null)
                {
                    user.Rank.Solved = NoAccepted;
                }
                else
                {

                    userRank = new Rank()
                    {
                        IdUser = user.UserId,
                        UvaUserName = user.UserName,
                        Solved = NoAccepted
                    };

                    modx.Ranks.InsertOnSubmit(userRank);

                }

                modx.SubmitChanges();
            }
            catch (NullReferenceException ex)
            {

            }
            //test if null then same solved
        }

 /// <summary>
 /// Determines whether [has] [the specified rank].
 /// </summary>
 /// <param name="rank">The rank.</param>
 /// <param name="suit">The suit.</param>
 /// <returns>
 ///   <c>true</c> if [has] [the specified rank]; otherwise, <c>false</c>.
 /// </returns>
 public bool Has(Rank rank, Suit suit)
 {
     if (GetCard(rank, suit) != null)
         return true;
     else
         return false;
 }

 public static World FindMainWorld(Rank rank) {
     World rankMain = rank.MainWorld;
     if (rankMain != null) {
         return rankMain;
     }
     return MainWorld;
 }

        private bool Follows(Rank lower, Rank higher)
        {
            //Special case, 2 follows ace
            if (lower == Rank.ACE && higher == Rank.DEUCE)
                return true;

            return (int)lower + 1 == (int)higher;
        }

 public Card(Rank rank, Suit suit)
     : this()
 {
     if (suit == Suit.None)
         throw new ArgumentException("Suit cannot be none", "suit");
     this.Rank = rank;
     this.Suit = suit;
 }

 public Member(String name, Rank rank = Rank.Member, int groupId = -1)
 {
     Random rand = new Random();
     this.ID = rand.Next();
     this.VillageName = name;
     this.Rank = rank;
     this.GroupId = groupId;
 }

 public MonteCarloModel(int rankCount, Rank[] ranks, double mean, double std_dev)
 {
     _mean = mean;
     _std_dev = std_dev;
     MyDistribution = new Distribution(new SimulationData(), 0);
     MyDistribution.Ranks = ranks;
     Run();
 }

 /// <summary> Adds a new PlayerInfo entry for a player who has never been online, by name. </summary>
 /// <returns> A newly-created PlayerInfo entry. </returns>
 public PlayerInfo AddUnrecognizedPlayer( string name, Rank startingRank, RankChangeType rankChangeType ) {
     if( name == null ) throw new ArgumentNullException( "name" );
     if( startingRank == null ) throw new ArgumentNullException( "startingRank" );
     int id = GetNextID();
     PlayerInfo info = new PlayerInfo( id, name, startingRank, rankChangeType, false );
     trie.Add( name, info );
     return info;
 }

 /// <summary> Adds a new PlayerInfo entry for an actual, logged-in player. </summary>
 /// <returns> A newly-created PlayerInfo entry. </returns>
 public PlayerInfo AddPlayer( string name, Rank startingRank, RankChangeType rankChangeType, IPAddress address ) {
     if( name == null ) throw new ArgumentNullException( "name" );
     if( address == null ) throw new ArgumentNullException( "address" );
     int id = GetNextID();
     PlayerInfo info = new PlayerInfo( id, name, startingRank, rankChangeType, address );
     trie.Add( name, info );
     return info;
 }

 public DigimonTemp(string nameRus, string nameEng, string sourceCode, string resultCode, Rank rank)
 {
     NameRus = nameRus;
     NameEng = nameEng;
     SourceCode = sourceCode;
     ResultCode = resultCode;
     Rank = rank;
 }

 public static string RankColor(Rank rank)
 {
     if (colors.ContainsKey(rank)) {
         return colors[rank];
     } else {
         return Color.Black;
     }
 }

 public Digimon(string nameRus, string nameEng, Rank rank, Type type, Speciality speciality)
 {
     NameEng = nameEng;
     NameRus = nameRus;
     Rank = rank;
     Type = type;
     Speciality = speciality;
 }

 public PlayerRankChangedEvent(DateTime dateTime, Galaxy galaxy, string name, Rank oldRank, Rank newRank)
     : base(dateTime, galaxy)
 {
     OldRank = oldRank;
     NewRank = newRank;
     if (oldRank == newRank) throw new ArgumentException("Ranks must differ for player rank changed event");
     PlayerName = name;
 }

 private void cSubstitute_SelectedIndexChanged( object sender, EventArgs e ) {
     if( cSubstitute.SelectedIndex < 0 ) return;
     foreach( Rank rank in RankManager.Ranks ) {
         if( cSubstitute.SelectedItem.ToString() != rank.ToComboBoxOption() ) continue;
         substituteRank = rank;
         bDelete.Enabled = true;
         break;
     }
 }

 public static IEnumerable<Player> RankedBelow( this IEnumerable<Player> source, Rank maxRank ) {
     if( source == null ) throw new ArgumentNullException( "source" );
     if( maxRank == null ) throw new ArgumentNullException( "maxRank" );
     foreach( Player player in source ) {
         if( player.Info.Rank < maxRank ) {
             yield return player;
         }
     }
 }