public override void Validate(string value)
{
base.Validate(value);
if (Color.Parse(value) == null)
{
throw new FormatException("Value cannot be parsed as a color.");
}
else if (Color.Parse(value).Length == 0 && NotBlank)
{
throw new FormatException("Value may not represent absence of color.");
}
}
bool ValidateColor(string key, string value)
{
if (Color.Parse(value) != null)
{
settings[key] = value;
return(true);
}
else
{
Log("Config.SetValue: Specified value for {0} could not be parsed. Using default ({1}).", LogType.Warning,
key, settings[key]);
return(false);
}
}
public override void Validate(string value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
base.Validate(value);
string parsedValue = Color.Parse(value);
if (parsedValue == null)
{
throw new FormatException("Value cannot be parsed as a color.");
}
else if (parsedValue.Length == 0 && NotBlank)
{
throw new FormatException("Value may not represent absence of color.");
}
}
static void ApplyKeyChange(ConfigKey key)
{
switch (key)
{
case ConfigKey.AnnouncementColor:
Color.Announcement = Color.Parse(key.GetString());
break;
case ConfigKey.AntispamInterval:
Player.AntispamInterval = key.GetInt();
break;
case ConfigKey.AntispamMessageCount:
Player.AntispamMessageCount = key.GetInt();
break;
case ConfigKey.DefaultBuildRank:
RankManager.DefaultBuildRank = Rank.Parse(key.GetString());
break;
case ConfigKey.DefaultRank:
RankManager.DefaultRank = Rank.Parse(key.GetString());
break;
case ConfigKey.BandwidthUseMode:
Player[] playerListCache = Server.Players;
if (playerListCache != null)
{
foreach (Player p in playerListCache)
{
if (p.BandwidthUseMode == BandwidthUseMode.Default)
{
// resets the use tweaks
p.BandwidthUseMode = BandwidthUseMode.Default;
}
}
}
break;
case ConfigKey.BlockDBAutoEnableRank:
RankManager.BlockDBAutoEnableRank = Rank.Parse(key.GetString());
if (BlockDB.IsEnabledGlobally)
{
World[] worldListCache = WorldManager.Worlds;
foreach (World world in worldListCache)
{
if (world.BlockDB.AutoToggleIfNeeded())
{
if (world.BlockDB.IsEnabled)
{
Logger.Log(LogType.SystemActivity,
"BlockDB is now auto-enabled on world {0}", world.Name);
}
else
{
Logger.Log(LogType.SystemActivity,
"BlockDB is now auto-disabled on world {0}", world.Name);
}
}
}
}
break;
case ConfigKey.BlockUpdateThrottling:
Server.BlockUpdateThrottling = key.GetInt();
break;
case ConfigKey.ConsoleName:
if (Player.Console != null)
{
Player.Console.Info.Name = key.GetString();
}
break;
case ConfigKey.HelpColor:
Color.Help = Color.Parse(key.GetString());
break;
case ConfigKey.IRCDelay:
IRC.SendDelay = key.GetInt();
break;
case ConfigKey.IRCMessageColor:
Color.IRC = Color.Parse(key.GetString());
break;
case ConfigKey.LogMode:
Logger.SplittingType = key.GetEnum <LogSplittingType>();
break;
case ConfigKey.MapPath:
if (!Paths.IgnoreMapPathConfigKey && GetString(ConfigKey.MapPath).Length > 0)
{
if (Paths.TestDirectory("MapPath", GetString(ConfigKey.MapPath), true))
{
Paths.MapPath = Path.GetFullPath(GetString(ConfigKey.MapPath));
}
}
break;
case ConfigKey.MaxUndo:
BuildingCommands.MaxUndoCount = key.GetInt();
break;
case ConfigKey.MeColor:
Color.Me = Color.Parse(key.GetString());
break;
case ConfigKey.NoPartialPositionUpdates:
if (key.Enabled())
{
Player.FullPositionUpdateInterval = 0;
}
else
{
Player.FullPositionUpdateInterval = Player.FullPositionUpdateIntervalDefault;
}
break;
case ConfigKey.PatrolledRank:
RankManager.PatrolledRank = Rank.Parse(key.GetString());
break;
case ConfigKey.PrivateMessageColor:
Color.PM = Color.Parse(key.GetString());
break;
case ConfigKey.RelayAllBlockUpdates:
Player.RelayAllUpdates = key.Enabled();
break;
case ConfigKey.SayColor:
Color.Say = Color.Parse(key.GetString());
break;
case ConfigKey.SystemMessageColor:
Color.Sys = Color.Parse(key.GetString());
break;
case ConfigKey.TickInterval:
Server.TicksPerSecond = 1000 / (float)key.GetInt();
break;
case ConfigKey.UploadBandwidth:
Server.MaxUploadSpeed = key.GetInt();
break;
case ConfigKey.WarningColor:
Color.Warning = Color.Parse(key.GetString());
break;
}
}
internal static void ApplyConfig()
{
Logger.SplittingType = (LogSplittingType)Enum.Parse(typeof(LogSplittingType), Settings[ConfigKey.LogMode], true);
Logger.MarkLogStart();
Player.RelayAllUpdates = GetBool(ConfigKey.RelayAllBlockUpdates);
if (GetBool(ConfigKey.NoPartialPositionUpdates))
{
Session.FullPositionUpdateInterval = 0;
}
else
{
Session.FullPositionUpdateInterval = Session.FullPositionUpdateIntervalDefault;
}
// chat colors
Color.Sys = Color.Parse(Settings[ConfigKey.SystemMessageColor]);
Color.Say = Color.Parse(Settings[ConfigKey.SayColor]);
Color.Help = Color.Parse(Settings[ConfigKey.HelpColor]);
Color.Announcement = Color.Parse(Settings[ConfigKey.AnnouncementColor]);
Color.PM = Color.Parse(Settings[ConfigKey.PrivateMessageColor]);
Color.IRC = Color.Parse(Settings[ConfigKey.IRCMessageColor]);
Color.Me = Color.Parse(Settings[ConfigKey.MeColor]);
Color.Warning = Color.Parse(Settings[ConfigKey.WarningColor]);
// default class
if (!ConfigKey.DefaultRank.IsBlank())
{
if (RankManager.ParseRank(Settings[ConfigKey.DefaultRank]) != null)
{
RankManager.DefaultRank = RankManager.ParseRank(Settings[ConfigKey.DefaultRank]);
}
else
{
RankManager.DefaultRank = RankManager.LowestRank;
Logger.Log("Config.ApplyConfig: Could not parse DefaultRank; assuming that the lowest rank ({0}) is the default.",
LogType.Warning, RankManager.DefaultRank.Name);
}
}
else
{
RankManager.DefaultRank = RankManager.LowestRank;
}
// antispam
Player.SpamChatCount = GetInt(ConfigKey.AntispamMessageCount);
Player.SpamChatTimer = GetInt(ConfigKey.AntispamInterval);
Player.AutoMuteDuration = TimeSpan.FromSeconds(GetInt(ConfigKey.AntispamMuteDuration));
// scheduler settings
Server.MaxUploadSpeed = GetInt(ConfigKey.UploadBandwidth);
Server.PacketsPerSecond = GetInt(ConfigKey.BlockUpdateThrottling);
Server.TicksPerSecond = 1000 / (float)GetInt(ConfigKey.TickInterval);
// rank to patrol
World.RankToPatrol = RankManager.ParseRank(ConfigKey.PatrolledRank.GetString());
// IRC delay
IRC.SendDelay = GetInt(ConfigKey.IRCDelay);
BuildingCommands.MaxUndoCount = GetInt(ConfigKey.MaxUndo);
if (!Paths.IgnoreMapPathConfigKey && GetString(ConfigKey.MapPath).Length > 0)
{
if (Paths.TestDirectory("MapPath", GetString(ConfigKey.MapPath), true))
{
Paths.MapPath = Path.GetFullPath(GetString(ConfigKey.MapPath));
Logger.Log("Maps are stored at: {0}", LogType.SystemActivity, Paths.MapPath);
}
}
AutoRankManager.CheckAutoRankSetting();
}
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);
}
