예제 #1
0
        public static NameResultMessage ValidatePlayerName(string name, int minLength, int maxLength, bool allowLetters,
                                                           bool allowDigits, bool noExceptionsAtStart, int maxExceptions, char[] exceptions, string[] disallowedWords,
                                                           string[] startDisallowed, string[] disallowedAnywhere)
        {
            NameResultMessage result = Validate(name, minLength, maxLength, allowLetters, allowDigits,
                                                noExceptionsAtStart, maxExceptions, exceptions, disallowedWords, startDisallowed, disallowedAnywhere);

            string lowername = name.Trim().ToLower();

            if (result == NameResultMessage.Allowed)
            {
                var mobs = new List <Mobile>(World.Mobiles.Values);
                foreach (Mobile m in mobs)
                {
                    if (
                        m is PlayerMobile
                        /*&& AccessLevelToggler.GetRawAccessLevel( (PlayerMobile)m ) == AccessLevel.Player*/ &&
                        !String.IsNullOrEmpty(m.RawName) && m.RawName.Trim().ToLower() == lowername)
                    {
                        result = NameResultMessage.AlreadyExists;
                    }
                }
            }

            return(result);
        }
예제 #2
0
        public NameChangeGump(Mobile from, NameResultMessage result, string name) : base(150, 100)
        {
            m_From = from;

            from.CloseGump(typeof(NameChangeGump));
            from.Hidden    = true;
            from.CantWalk  = true;
            from.Blessed   = true;
            from.Squelched = true;

            Closable   = false;
            Disposable = false;
            Dragable   = false;
            Resizable  = false;

            AddPage(0);

            AddBackground(0, 0, 400, 350, 0x24A4);               //9270
            //AddAlphaRegion( 13, 13, 473, 49 );
            //AddAlphaRegion( 13, 68, 473, 244 );

            AddHtml(10, 35, 400, 20, Color(Center("Unique & Appropriate Name Required"), 0x111111), false, false);

            string message = String.Format("Thank you for playing {0}. Please choose a unique player name with the following constraints:", ShardInfo.DisplayName);

            AddHtml(35, 70, 350, 60, Color(message, 0x7E1E00), false, false);

            AddHtml(35, 130, 350, 20, Color("* Name must be between 2 and 16 characters.", 0x666666), false, false);
            AddHtml(35, 155, 350, 20, Color("* Name must not include numbers.", 0x666666), false, false);
            AddHtml(35, 180, 350, 20, Color("* Name may include, but not start with, one (1) symbol.", 0x666666), false, false);
            AddHtml(35, 205, 350, 20, Color("* All player names are verified for appropriateness.", 0x666666), false, false);

            AddTextField(50, 245, 250, 20, 1);
            AddButton(320, 244, 0xFB7, 0xFB8, 2, GumpButtonType.Reply, 0);

            if (result != NameResultMessage.Allowed)
            {
                string error = String.Empty;

                switch (result)
                {
                default:
                case NameResultMessage.NotAllowed: error = String.Format("The name {0} is not allowed.", name); break;

                case NameResultMessage.InvalidCharacter: error = String.Format("The name {0} contains invalid characters.", name); break;

                case NameResultMessage.TooFewCharacters:
                case NameResultMessage.TooManyCharacters: error = "The name must be between 2 and 16 characters."; break;

                case NameResultMessage.AlreadyExists: error = String.Format("A player with the name {0} already exists.", name); break;
                }

                AddHtml(55, 270, 350, 40, Color(String.Format("Error: {0}", error), 0xFF0000), false, false);
            }
        }
예제 #3
0
        private static void OnLogin(LoginEventArgs e)
        {
            PlayerMobile mob = e.Mobile as PlayerMobile;

            if (AccessLevelToggler.GetRawAccessLevel(mob) == AccessLevel.Player)                 //Incase [staff was used
            {
                NameResultMessage result = NameVerification.Validate(mob.RawName, 2, 16, true, false, true, 1, NameVerification.SpaceDashPeriodQuote);
                if (result != NameResultMessage.Allowed)
                {
                    mob.SendGump(new NameChangeGump(mob));
                }
            }
        }
예제 #4
0
		public NameChangeGump( Mobile from, NameResultMessage result, string name ) : base( 150, 100 )
		{
			m_From = from;

			from.CloseGump( typeof( NameChangeGump ) );
			from.Hidden = true;
			from.CantWalk = true;
			from.Blessed = true;
			from.Squelched = true;

			Closable = false;
			Disposable = false;
			Dragable = false;
			Resizable = false;

			AddPage(0);

			AddBackground( 0, 0, 400, 350, 0x24A4 ); //9270
			//AddAlphaRegion( 13, 13, 473, 49 );
			//AddAlphaRegion( 13, 68, 473, 244 );

			AddHtml( 10, 35, 400, 20, Color( Center("Unique & Appropriate Name Required"), 0x111111 ), false, false );

			string message = String.Format( "Thank you for playing {0}. Please choose a unique player name with the following constraints:", ShardInfo.DisplayName );

			AddHtml( 35, 70, 350, 60, Color(  message, 0x7E1E00 ), false, false );

			AddHtml( 35, 130, 350, 20, Color( "* Name must be between 2 and 16 characters.", 0x666666 ), false, false );
			AddHtml( 35, 155, 350, 20, Color( "* Name must not include numbers.", 0x666666 ), false, false );
			AddHtml( 35, 180, 350, 20, Color( "* Name may include, but not start with, one (1) symbol.", 0x666666 ), false, false );
			AddHtml( 35, 205, 350, 20, Color( "* All player names are verified for appropriateness.", 0x666666 ), false, false );

			AddTextField( 50, 245, 250, 20, 1 );
			AddButton( 320, 244, 0xFB7, 0xFB8, 2, GumpButtonType.Reply, 0 );

			if ( result != NameResultMessage.Allowed )
			{
				string error = String.Empty;

				switch ( result )
				{
					default:
					case NameResultMessage.NotAllowed: error = String.Format( "The name {0} is not allowed.", name ); break;
					case NameResultMessage.InvalidCharacter: error = String.Format( "The name {0} contains invalid characters.", name ); break;
					case NameResultMessage.TooFewCharacters: case NameResultMessage.TooManyCharacters: error = "The name must be between 2 and 16 characters."; break;
					case NameResultMessage.AlreadyExists: error = String.Format( "A player with the name {0} already exists.", name ); break;
				}

				AddHtml( 55, 270, 350, 40, Color( String.Format( "Error: {0}", error ), 0xFF0000 ), false, false );
			}
		}
예제 #5
0
        private static void SetName(Mobile m, string name)
        {
            name = name.Trim();

            if (m.Account.AccessLevel == AccessLevel.Player)
            {
                NameResultMessage result = NameVerification.ValidatePlayerName(
                    name, 2, 16, true, false, true, 1, NameVerification.SpaceDashPeriodQuote);

                m.Name = result != NameResultMessage.Allowed ? String.Format("Citizen {0}", Utility.Random(10000, 99999)) : name;
            }
            else
            {
                m.Name = name;
            }

            //return result;
        }
예제 #6
0
        public override void OnResponse(NetState sender, RelayInfo info)
        {
            int val = info.ButtonID;

            if (val == 2)
            {
                TextRelay first = info.GetTextEntry(1);
                string    name  = first != null?first.Text.Trim() : String.Empty;

                string lowername = name != null?name.ToLower() : String.Empty;

                NameResultMessage result = NameVerification.ValidatePlayerName(lowername, 2, 16, true, false, true, 1, NameVerification.SpaceDashPeriodQuote);

                if (result == NameResultMessage.Allowed)
                {
                    AllowName(name);
                }
                else
                {
                    m_From.SendGump(new NameChangeGump(m_From, result, name));
                }
            }
        }
예제 #7
0
        public static bool EventSink_ValidatePlayerName(ValidatePlayerNameEventArgs e)
        {
            NetState state     = e.State;
            string   name      = e.Name;
            string   lowername = name.ToLower();

            NameResultMessage result = NameVerification.ValidatePlayerName(lowername, 2, 16, true, false, true, 1, NameVerification.SpaceDashPeriodQuote);

            switch (result)
            {
            default:
            case NameResultMessage.NotAllowed: SendErrorOnCharacterCreation(state, String.Format("The name {0} is not allowed.", name)); return(false);

            case NameResultMessage.InvalidCharacter: SendErrorOnCharacterCreation(state, String.Format("The name {0} contains invalid characters.", name)); return(false);

            case NameResultMessage.TooFewCharacters:
            case NameResultMessage.TooManyCharacters: SendErrorOnCharacterCreation(state, "The name must be between 2-16 characters."); return(false);

            case NameResultMessage.AlreadyExists: SendErrorOnCharacterCreation(state, String.Format("A player with the name {0} already exists.", name)); return(false);

            case NameResultMessage.Allowed: return(true);
            }
        }
        public override void OnResponse(Mobile from, string text)
        {
            if (m_Item == null || m_Item.Deleted || !m_Item.IsChildOf(from.Backpack))
            {
                from.SendLocalizedMessage(1042001);
            }
            else
            {
                text = text.Trim();
                if (text == from.RawName)
                {
                    from.SendMessage("Please choose a unique name.");
                }
                else
                {
                    NameResultMessage result = NameVerification.ValidatePlayerName(text, 2, 16, true, false, true, 1, NameVerification.SpaceDashPeriodQuote);
                    if (result == NameResultMessage.Allowed)
                    {
                        from.Name = text;
                        m_Item.Delete();
                    }
                    else
                    {
                        switch (result)
                        {
                        case NameResultMessage.InvalidCharacter: from.SendMessage("The chosen name has an invalid character."); break;

                        case NameResultMessage.TooFewCharacters:
                        case NameResultMessage.TooManyCharacters: from.SendMessage("Names must contain 2-16 alphabetic characters."); break;

                        case NameResultMessage.AlreadyExists:
                        case NameResultMessage.NotAllowed: from.SendMessage("This name is not available or not allowed."); break;
                        }
                    }
                }
            }
        }
예제 #9
0
        protected NameResultMessage VerifyName(PlayerMobile m, string name, bool message)
        {
            if (m == null || m.Deleted)
            {
                return(NameResultMessage.NotAllowed);
            }

            if (String.IsNullOrWhiteSpace(name))
            {
                if (message)
                {
                    m.SendMessage("The name you chose is too short.");
                }

                return(NameResultMessage.TooFewCharacters);
            }

            string kw;

            if (AntiAdverts.Detect(name, out kw))
            {
                if (message)
                {
                    m.SendMessage("The name you chose is not allowed.");
                }

                return(NameResultMessage.NotAllowed);
            }

            NameResultMessage res = NameVerification.ValidatePlayerName(
                name,
                1,
                16,
                true,
                false,
                true,
                0,
                NameVerification.Empty,
                NameVerification.DisallowedWords,
                NameVerification.StartDisallowed,
                NameVerification.DisallowedAnywhere);

            switch (res)
            {
            case NameResultMessage.InvalidCharacter:
            {
                if (message)
                {
                    m.SendMessage("The name you chose contains invalid characters.");
                }
            }
                return(res);

            case NameResultMessage.NotAllowed:
            {
                if (message)
                {
                    m.SendMessage("The name you chose is not allowed.");
                }
            }
                return(res);

            case NameResultMessage.TooFewCharacters:
            {
                if (message)
                {
                    m.SendMessage("The name you chose is too short.");
                }
            }
                return(res);

            case NameResultMessage.TooManyCharacters:
            {
                if (message)
                {
                    m.SendMessage("The name you chose is too long.");
                }
            }
                return(res);
            }

            if (ProfanityProtection.DisallowedWords.Any(t => name.IndexOf(t, StringComparison.OrdinalIgnoreCase) != -1))
            {
                // That name isn't very polite.
                m.SendLocalizedMessage(1072622);

                return(NameResultMessage.NotAllowed);
            }

            return(NameResultMessage.Allowed);
        }