fCraft.Config.DefineClass C# (CSharp) Method

DefineClass() private method

private DefineClass ( System.Xml.Linq.XElement el ) : bool
el System.Xml.Linq.XElement
return bool
        bool DefineClass( XElement el ) {
            PlayerClass playerClass = new PlayerClass();

            // read required attributes
            XAttribute attr = el.Attribute( "name" );
            if( attr == null ) {
                Log( "Config.DefineClass: Class definition with no name was ignored.", LogType.Warning );
                return false;
            }
            if( !PlayerClass.IsValidClassName( attr.Value.Trim() ) ) {
                Log( "Config.DefineClass: Invalid name specified for class \"{0}\". Class name can only contain letters, digits, and underscores.",
                     LogType.Warning, playerClass.name );
                return false;
            }
            playerClass.name = attr.Value.Trim();

            if( classes.classes.ContainsKey( playerClass.name ) ) {
                Log( "Config.DefineClass: Duplicate class definition for \"{0}\" was ignored.", LogType.Warning, playerClass.name );
                return true;
            }

            
            if( (attr = el.Attribute( "rank" )) == null ) {
                Log( "Config.DefineClass: No rank specified for {0}. Class definition was ignored.", LogType.Warning, playerClass.name );
                return false;
            }
            if( !Byte.TryParse( attr.Value, out playerClass.rank ) ) {
                Log( "Config.DefineClass: Cannot parse rank for {0}. Class definition was ignored.", LogType.Warning, playerClass.name );
                return false;
            }

            attr = el.Attribute( "color" );
            if( attr == null || Color.Parse( attr.Value ) == null ) {
                playerClass.color = "";
            } else {
                playerClass.color = Color.Parse( attr.Value );
            }

            // read optional attributes
            if( (attr = el.Attribute( "prefix" )) != null ) {
                if( PlayerClass.IsValidPrefix( attr.Value ) ) {
                    playerClass.prefix = attr.Value;
                } else {
                    Log( "Config.DefineClass: Invalid prefix specified for {0}.", LogType.Warning, playerClass.name );
                    playerClass.prefix = "";
                }
            }

            if( (attr = el.Attribute( "spamKickAt" )) != null ) {
                if( !Int32.TryParse( attr.Value, out playerClass.spamKickThreshold ) ) {
                    Log( "Config.DefineClass: Could not parse the value for spamKickAt for {0}. Assuming 0 (never).", LogType.Warning, playerClass.name );
                    playerClass.spamKickThreshold = 0;
                }
            } else {
                playerClass.spamKickThreshold = 0;
            }

            if( (attr = el.Attribute( "spamBanAt" )) != null ) {
                if( !Int32.TryParse( attr.Value, out playerClass.spamBanThreshold ) ) {
                    Log( "Config.DefineClass: Could not parse the value for spamBanAt for {0}. Assuming 0 (never).", LogType.Warning, playerClass.name );
                    playerClass.spamBanThreshold = 0;
                }
            } else {
                playerClass.spamBanThreshold = 0;
            }

            if( (attr = el.Attribute( "idleKickAfter" )) != null ) {
                if( !Int32.TryParse( attr.Value, out playerClass.idleKickTimer ) ) {
                    Log( "Config.DefineClass: Could not parse the value for idleKickAfter for {0}. Assuming 0 (never).", LogType.Warning, playerClass.name );
                    playerClass.idleKickTimer = 0;
                }
            } else {
                playerClass.idleKickTimer = 0;
            }

            if( (attr = el.Attribute( "reserveSlot" )) != null ) {
                if( !Boolean.TryParse( attr.Value, out playerClass.reservedSlot ) ) {
                    Log( "Config.DefineClass: Could not parse the value for reserveSlot for {0}. Assuming \"false\".", LogType.Warning, playerClass.name );
                    playerClass.reservedSlot = false;
                }
            } else {
                playerClass.reservedSlot = false;
            }

            // read permissions
            XElement temp;
            for( int i = 0; i < Enum.GetValues(typeof(Permissions)).Length; i++ ) {
                string permission = ((Permissions)i).ToString();
                if( (temp=el.Element( permission )) != null ) {
                    playerClass.permissions[i] = true;
                    if( i == (int)Permissions.Promote ) {
                        if( (attr = temp.Attribute( "max" )) != null ) {
                            playerClass.maxPromoteVal = attr.Value;
                        } else {
                            playerClass.maxPromoteVal = "";
                        }
                    } else if( i == (int)Permissions.Demote ) {
                        if( (attr = temp.Attribute( "max" )) != null ) {
                            playerClass.maxDemoteVal = attr.Value;
                        } else {
                            playerClass.maxDemoteVal = "";
                        }
                    } else if( i == (int)Permissions.Kick ) {
                        if( (attr = temp.Attribute( "max" )) != null ) {
                            playerClass.maxKickVal = attr.Value;
                        } else {
                            playerClass.maxKickVal = "";
                        }
                    } else if( i == (int)Permissions.Ban ) {
                        if( (attr = temp.Attribute( "max" )) != null ) {
                            playerClass.maxBanVal = attr.Value;
                        } else {
                            playerClass.maxBanVal = "";
                        }
                    }
                }
            }

            // check for consistency in ban permissions
            if( !playerClass.Can( Permissions.Ban ) &&
                (playerClass.Can( Permissions.BanAll ) || playerClass.Can( Permissions.BanIP )) ) {
                Log( "Class \"{0}\" is allowed to BanIP and/or BanAll but not allowed to Ban.\n" +
                    "Assuming that all ban permissions were ment to be off.", LogType.Warning, playerClass.name );
                playerClass.permissions[(int)Permissions.BanIP] = false;
                playerClass.permissions[(int)Permissions.BanAll] = false;
            }

            classes.AddClass( playerClass );
            return true;
        }