// This constructor is used to create dummy players (such as Console and /dummy)
 // It will soon be replaced by a generic Entity class
 internal Player( World world, string name ) {
     if( name == null ) throw new ArgumentNullException( "name" );
     World = world;
     Info = new PlayerInfo( name, RankManager.HighestRank, true, RankChangeType.AutoPromoted );
     spamBlockLog = new Queue<DateTime>( Info.Rank.AntiGriefBlocks );
     ResetAllBinds();
 }

 public void Create( BoundingBox bounds, PlayerInfo createdBy ) {
     if( bounds == null ) throw new ArgumentNullException( "bounds" );
     if( createdBy == null ) throw new ArgumentNullException( "createdBy" );
     CreatedDate = DateTime.UtcNow;
     Bounds = bounds;
     CreatedBy = createdBy;
 }

 // This constructor is used to create dummy players (such as Console and /dummy)
 // It will soon be replaced by a generic Entity class
 internal Player( World _world, string _name )
 {
     world = _world;
     name = _name;
     nick = name;
     info = new PlayerInfo( _name, ClassList.highestClass );
 }

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

 // Normal constructor
 internal Player( World _world, string _name, Session _session, Position _pos ) {
     world = _world;
     name = _name;
     nick = name;
     session = _session;
     pos = _pos;
     info = world.db.FindPlayerInfo( this );
 }

 public bool CanRevoke( PlayerInfo player ) {
     PermissionLimits limits = GetLimit( player );
     if( limits == null ) {
         return false;
     } else {
         return limits.CanRevoke;
     }
 }

 internal static PlayerInfo AddSuperPlayer( ReservedPlayerID id, [NotNull] string name, [NotNull] Rank rank ) {
     if( name == null ) throw new ArgumentNullException( "name" );
     CheckIfLoaded();
     PlayerInfo newInfo = new PlayerInfo( (int)id, name, rank, RankChangeType.AutoPromoted, true ) {
         RaisePropertyChangedEvents = true
     };
     return newInfo;
 }

 // Throws a PlayerOpException if reason is required but missing.
 internal static void CheckKickReason( [CanBeNull] string reason, [NotNull] Player player, PlayerInfo targetInfo ) {
     if( player == null ) throw new ArgumentNullException( "player" );
     if( ConfigKey.RequireKickReason.Enabled() && String.IsNullOrEmpty( reason ) ) {
         const string msg = "Please specify a kick reason.";
         const string colorMsg = "&S" + msg;
         throw new PlayerOpException( player, targetInfo, PlayerOpExceptionCode.ReasonRequired, msg, colorMsg );
     }
 }

 PermissionLimits GetPlayerLimit( PlayerInfo player ) {
     PermissionLimits limiter;
     if( playerInclusions.TryGetValue( player.Name, out limiter ) ) {
         return limiter;
     } else if( Parent != null ) {
         return Parent.GetPlayerLimit( player );
     } else {
         return null;
     }
 }

 public bool Can( PlayerInfo player, int quantity ) {
     if( ( Node.Flags & PermissionFlags.NeedsQuantity ) == 0 ) {
         throw new PermissionCheckException( "Quantity limit is not applicable to " + Node.Name );
     }
     PermissionLimits limits = GetLimit( player );
     if( limits == null ) {
         return false;
     } else {
         return ( limits.MaxQuantity <= quantity );
     }
 }

 //Function to format and return a player's score entry. Returns null if no score found
 public static String GetPlayerScoreEntry( PlayerInfo player )
 {
     string toReturn = null;
     foreach ( String s in PlayerKillScores ) {
         if ( s.Contains( '$' ) ) {
             if ( s.Split( '$' )[0] == player.Name ) {
                 toReturn = s;
             }
         }
     }
     return toReturn;
 }

 public PlayerOpException( [NotNull] Player player, PlayerInfo target,
                           PlayerOpExceptionCode errorCode,
                           [NotNull] string message, [NotNull] string messageColored )
     : base( message ) {
     if( player == null ) throw new ArgumentNullException( "player" );
     if( message == null ) throw new ArgumentNullException( "message" );
     if( messageColored == null ) throw new ArgumentNullException( "messageColored" );
     Player = player;
     Target = target;
     ErrorCode = errorCode;
     MessageColored = messageColored;
 }

 // Throws a PlayerOpException if reason is required but missing.
 internal static void CheckRankChangeReason( [CanBeNull] string reason, [NotNull] Player player, PlayerInfo targetInfo, bool promoting ) {
     if( player == null ) throw new ArgumentNullException( "player" );
     if( ConfigKey.RequireRankChangeReason.Enabled() && String.IsNullOrEmpty( reason ) ) {
         string msg;
         if( promoting ) {
             msg = "Please specify a promotion reason.";
         } else {
             msg = "Please specify a demotion reason.";
         }
         string colorMsg = "&S" + msg;
         throw new PlayerOpException( player, targetInfo, PlayerOpExceptionCode.ReasonRequired, msg, colorMsg );
     }
 }

 public PlayerInfo FindPlayerInfo( Player player ) {
     if( player == null ) return null;
     
     locker.EnterWriteLock();
     PlayerInfo info = tree.Get( player.name );
     if( info == null ) {
         info = new PlayerInfo( world, player );
         tree.Add( player.name, info );
         list.Add( info );
     }
     locker.ExitWriteLock();
     return info;
 }

        public static bool FindPlayerInfo( string name, out PlayerInfo info )
        {
            if( name == null ) {
                info = null;
                return false;
            }

            bool noDupe;
            locker.EnterWriteLock();
            noDupe = tree.Get( name, out info );
            locker.ExitWriteLock();

            return noDupe;
        }

 // returns the PREVIOUS state of the player
 public PermissionOverride Include( PlayerInfo info ) {
     if( info == null ) throw new ArgumentNullException( "info" );
     lock( playerPermissionListLock ) {
         if( includedPlayers.ContainsValue( info ) ) {
             UpdatePlayerListCache();
             return PermissionOverride.Allow;
         } else if( excludedPlayers.ContainsValue( info ) ) {
             excludedPlayers.Remove( info.Name.ToLower() );
             UpdatePlayerListCache();
             return PermissionOverride.Deny;
         } else {
             includedPlayers.Add( info.Name.ToLower(), info );
             UpdatePlayerListCache();
             return PermissionOverride.None;
         }
     }
 }

 // Adds a name to the tree.
 public bool Add( string name, PlayerInfo payload ) {
     StringNode temp = root;
     int code;
     for( int i = 0; i < name.Length; i++ ) {
         code = CharCode( name[i] );
         if( temp.children[code] == null ) {
             temp.children[code] = new StringNode();
         }
         if( temp.tag == EMPTY ) {
             temp.tag = (byte)code;
         } else {
             temp.tag = MULTI;
         }
         temp = temp.children[code];
     }
     if( temp.payload != null )
         return false;
     temp.payload = payload;
     count++;
     return true;
 }

        public static PlayerInfo AddFakeEntry( string name, RankChangeType rankChangeType ) {
            if( name == null ) throw new ArgumentNullException( "name" );

            PlayerInfo info;
            lock( AddLocker ) {
                info = Trie.Get( name );
                if( info != null ) throw new ArgumentException( "A PlayerDB entry already exists for this name." );

                var e = new PlayerInfoCreatingEventArgs( name, IPAddress.None, RankManager.DefaultRank, true );
                Server.RaisePlayerInfoCreatingEvent( e );
                if( e.Cancel ) throw new OperationCanceledException( "Cancelled by a plugin." );

                info = new PlayerInfo( name, e.StartingRank, false, rankChangeType );

                List.Add( info );
                Trie.Add( info.Name, info );
                UpdateCache();
            }
            Server.RaisePlayerInfoCreatedEvent( info, false );
            return info;
        }

        // Searches for players starting with namePart.
        //     Returns false if more than one name matched.
        //     Returns true and sets info to null if no names matched.
        public bool Get( string namePart, out PlayerInfo info ) {
            StringNode temp = root;
            int code;
            for( int i = 0; i < namePart.Length; i++ ) {
                code = CharCode( namePart[i] );
                if( temp.children[code] == null ) {
                    info = null;
                    return true; // early detection of no matches
                }
                temp = temp.children[code];
            }

            if( temp.payload != null ) {
                info = temp.payload;
                return true; // exact match
            } else if( temp.tag == MULTI ) {
                info = null;
                return false; // multiple matches
            }
            for( ; temp.tag < MULTI; temp = temp.children[temp.tag] ) ;
            info = temp.payload;
            return true; // one autocompleted match
        }