static void MassRankHandler(Player player, CommandReader cmd)
{
string fromRankName = cmd.Next();
string toRankName = cmd.Next();
string reason = cmd.NextAll();
if (fromRankName == null || toRankName == null)
{
CdMassRank.PrintUsage(player);
return;
}
Rank fromRank = RankManager.FindRank(fromRankName);
if (fromRank == null)
{
player.MessageNoRank(fromRankName);
return;
}
Rank toRank = RankManager.FindRank(toRankName);
if (toRank == null)
{
player.MessageNoRank(toRankName);
return;
}
if (fromRank == toRank)
{
player.Message("Ranks must be different");
return;
}
int playerCount;
using (PlayerDB.GetReadLock()) {
playerCount = PlayerDB.List.Count(t => t.Rank == fromRank);
}
string verb = (fromRank > toRank ? "demot" : "promot");
if (!cmd.IsConfirmed)
{
player.Confirm(cmd, "MassRank: {0}e {1} players?", verb.UppercaseFirst(), playerCount);
return;
}
player.Message("MassRank: {0}ing {1} players...",
verb, playerCount);
int affected = PlayerDB.MassRankChange(player, fromRank, toRank, reason);
player.Message("MassRank: done, {0} records affected.", affected);
}
static void ZoneEditHandler( Player player, Command cmd )
{
bool changesWereMade = false;
string zoneName = cmd.Next();
if( zoneName == null ) {
player.Message( "No zone name specified. See &H/Help ZEdit" );
return;
}
Zone zone = player.WorldMap.Zones.Find( zoneName );
if( zone == null ) {
player.MessageNoZone( zoneName );
return;
}
string name;
while( (name = cmd.Next()) != null ) {
if( name.Length < 2 ) continue;
if( name.StartsWith( "+" ) ) {
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches( player, name.Substring( 1 ) );
if( info == null ) return;
// prevent players from whitelisting themselves to bypass protection
if( !player.Info.Rank.AllowSecurityCircumvention && player.Info == info ) {
if( !zone.Controller.Check( info ) ) {
player.Message( "You must be {0}+&S to add yourself to this zone's whitelist.",
zone.Controller.MinRank.ClassyName );
continue;
}
}
switch( zone.Controller.Include( info ) ) {
case PermissionOverride.Deny:
player.Message( "{0}&S is no longer excluded from zone {1}",
info.ClassyName, zone.ClassyName );
changesWereMade = true;
break;
case PermissionOverride.None:
player.Message( "{0}&S is now included in zone {1}",
info.ClassyName, zone.ClassyName );
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message( "{0}&S is already included in zone {1}",
info.ClassyName, zone.ClassyName );
break;
}
} else if( name.StartsWith( "-" ) ) {
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches( player, name.Substring( 1 ) );
if( info == null ) return;
switch( zone.Controller.Exclude( info ) ) {
case PermissionOverride.Deny:
player.Message( "{0}&S is already excluded from zone {1}",
info.ClassyName, zone.ClassyName );
break;
case PermissionOverride.None:
player.Message( "{0}&S is now excluded from zone {1}",
info.ClassyName, zone.ClassyName );
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message( "{0}&S is no longer included in zone {1}",
info.ClassyName, zone.ClassyName );
changesWereMade = true;
break;
}
} else {
Rank minRank = RankManager.FindRank( name );
if( minRank != null ) {
// prevent players from lowering rank so bypass protection
if( !player.Info.Rank.AllowSecurityCircumvention &&
zone.Controller.MinRank > player.Info.Rank && minRank <= player.Info.Rank ) {
player.Message( "You are not allowed to lower the zone's rank." );
continue;
}
if( zone.Controller.MinRank != minRank ) {
zone.Controller.MinRank = minRank;
player.Message( "Permission for zone \"{0}\" changed to {1}+",
zone.Name,
minRank.ClassyName );
changesWereMade = true;
}
} else {
player.MessageNoRank( name );
}
}
if( changesWereMade ) {
zone.Edit( player.Info );
} else {
player.Message( "No changes were made to the zone." );
}
}
}
internal static void RealmBuild(Player player, Command cmd, string worldName, string name, string NameIfRankIsName)
{
// Print information about the current realm
if (worldName == null)
{
if (player.World == null)
{
player.Message("When calling /wbuild from console, you must specify a realm name.");
}
else
{
player.Message(player.World.BuildSecurity.GetDescription(player.World, "realm", "modified"));
}
return;
}
// Find a realm by name
World realm = WorldManager.FindWorldOrPrintMatches(player, worldName);
if (realm == null)
{
return;
}
if (name == null)
{
player.Message(realm.BuildSecurity.GetDescription(realm, "realm", "modified"));
return;
}
bool changesWereMade = false;
do
{
if (name.Length < 2)
{
continue;
}
// Whitelisting individuals
if (name.StartsWith("+"))
{
PlayerInfo info;
if (!PlayerDB.FindPlayerInfo(name.Substring(1), out info))
{
player.Message("More than one player found matching \"{0}\"", name.Substring(1));
continue;
}
else if (info == null)
{
player.MessageNoPlayer(name.Substring(1));
continue;
}
if (realm.BuildSecurity.CheckDetailed(info) == SecurityCheckResult.Allowed)
{
player.Message("{0}&S is already allowed to build in {1}&S (by rank)",
info.ClassyName, realm.ClassyName);
continue;
}
Player target = info.PlayerObject;
if (target == player)
{
target = null; // to avoid duplicate messages
}
switch (realm.BuildSecurity.Include(info))
{
case PermissionOverride.Deny:
if (realm.BuildSecurity.Check(info))
{
player.Message("{0}&S is no longer barred from building in {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You can now build in realm {0}&S (removed from blacklist by {1}&S).",
realm.ClassyName, player.ClassyName);
}
}
else
{
player.Message("{0}&S was removed from the build blacklist of {1}&S. " +
"Player is still NOT allowed to build (by rank).",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You were removed from the build blacklist of realm {0}&S by {1}&S. " +
"You are still NOT allowed to build (by rank).",
player.ClassyName, realm.ClassyName);
}
}
Logger.Log(LogType.UserActivity, "{0} removed {1} from the build blacklist of {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.None:
player.Message("{0}&S is now allowed to build in {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You can now build in realm {0}&S (whitelisted by {1}&S).",
realm.ClassyName, player.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} added {1} to the build whitelist on realm {2}",
player.Name, info.Name, realm.Name);
break;
case PermissionOverride.Allow:
player.Message("{0}&S is already on the build whitelist of {1}",
info.ClassyName, realm.ClassyName);
break;
}
// Blacklisting individuals
}
else if (name.StartsWith("-"))
{
PlayerInfo info;
if (!PlayerDB.FindPlayerInfo(name.Substring(1), out info))
{
player.Message("More than one player found matching \"{0}\"", name.Substring(1));
continue;
}
else if (info == null)
{
player.MessageNoPlayer(name.Substring(1));
continue;
}
if (realm.BuildSecurity.CheckDetailed(info) == SecurityCheckResult.RankTooHigh ||
realm.BuildSecurity.CheckDetailed(info) == SecurityCheckResult.RankTooLow)
{
player.Message("{0}&S is already barred from building in {1}&S (by rank)",
info.ClassyName, realm.ClassyName);
continue;
}
Player target = info.PlayerObject;
if (target == player)
{
target = null; // to avoid duplicate messages
}
switch (realm.BuildSecurity.Exclude(info))
{
case PermissionOverride.Deny:
player.Message("{0}&S is already on build blacklist of {1}",
info.ClassyName, realm.ClassyName);
break;
case PermissionOverride.None:
player.Message("{0}&S is now barred from building in {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("&WYou were barred by {0}&W from building in realm {1}",
player.ClassyName, realm.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} added {1} to the build blacklist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.Allow:
if (realm.BuildSecurity.Check(info))
{
player.Message("{0}&S is no longer on the build whitelist of {1}&S. " +
"Player is still allowed to build (by rank).",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You were removed from the build whitelist of realm {0}&S by {1}&S. " +
"You are still allowed to build (by rank).",
player.ClassyName, realm.ClassyName);
}
}
else
{
player.Message("{0}&S is no longer allowed to build in {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("&WYou can no longer build in realm {0}&W (removed from whitelist by {1}&W).",
realm.ClassyName, player.ClassyName);
}
}
Logger.Log(LogType.UserActivity, "{0} removed {1} from the build whitelist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
}
// Setting minimum rank
}
else
{
Rank rank = RankManager.FindRank(name);
if (rank == null)
{
player.MessageNoRank(name);
}
else if (!player.Info.Rank.AllowSecurityCircumvention &&
realm.BuildSecurity.MinRank > rank &&
realm.BuildSecurity.MinRank > player.Info.Rank)
{
player.Message("&WYou must be ranked {0}&W+ to lower build restrictions for realm {1}",
realm.BuildSecurity.MinRank.ClassyName, realm.ClassyName);
}
else
{
// list players who are redundantly blacklisted
var exceptionList = realm.BuildSecurity.ExceptionList;
PlayerInfo[] noLongerExcluded = exceptionList.Excluded.Where(excludedPlayer => excludedPlayer.Rank < rank).ToArray();
if (noLongerExcluded.Length > 0)
{
player.Message("Following players no longer need to be blacklisted on realm {0}&S: {1}",
realm.ClassyName,
noLongerExcluded.JoinToClassyString());
}
// list players who are redundantly whitelisted
PlayerInfo[] noLongerIncluded = exceptionList.Included.Where(includedPlayer => includedPlayer.Rank >= rank).ToArray();
if (noLongerIncluded.Length > 0)
{
player.Message("Following players no longer need to be whitelisted on realm {0}&S: {1}",
realm.ClassyName,
noLongerIncluded.JoinToClassyString());
}
// apply changes
realm.BuildSecurity.MinRank = rank;
changesWereMade = true;
if (realm.BuildSecurity.MinRank == RankManager.LowestRank)
{
Server.Message("{0}&S allowed anyone to build on realm {1}",
player.ClassyName, realm.ClassyName);
}
else
{
Server.Message("{0}&S allowed only {1}+&S to build in realm {2}",
player.ClassyName, realm.BuildSecurity.MinRank.ClassyName, realm.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} set build rank for realm {1} to {2}+",
player.Name, realm.Name, realm.BuildSecurity.MinRank.Name);
}
}
} while ((name = cmd.Next()) != null);
if (changesWereMade)
{
WorldManager.SaveWorldList();
}
}
public static void RealmLoad(Player player, Command cmd, string fileName, string worldName, string buildRankName, string accessRankName)
{
if (worldName == null && player.World == null)
{
player.Message("When using /realm from console, you must specify the realm name.");
return;
}
if (fileName == null)
{
// No params given at all
return;
}
string fullFileName = WorldManager.FindMapFile(player, fileName);
if (fullFileName == null)
{
return;
}
// Loading map into current realm
if (worldName == null)
{
if (!cmd.IsConfirmed)
{
player.Confirm(cmd, "About to replace THIS REALM with \"{0}\".", fileName);
return;
}
Map map;
try
{
map = MapUtility.Load(fullFileName);
}
catch (Exception ex)
{
player.MessageNow("Could not load specified file: {0}: {1}", ex.GetType().Name, ex.Message);
return;
}
World realm = player.World;
// Loading to current realm
realm.MapChangedBy = player.Name;
realm.ChangeMap(map);
realm.Players.Message(player, "{0}&S loaded a new map for this realm.",
player.ClassyName);
player.MessageNow("New map loaded for the realm {0}", realm.ClassyName);
Logger.Log(LogType.UserActivity,
"{0} loaded new map for realm \"{1}\" from {2}",
player.Name, realm.Name, fileName);
realm.IsHidden = false;
realm.IsRealm = true;
WorldManager.SaveWorldList();
}
else
{
// Loading to some other (or new) realm
if (!World.IsValidName(worldName))
{
player.MessageInvalidWorldName(worldName);
return;
}
Rank buildRank = RankManager.DefaultBuildRank;
Rank accessRank = null;
if (buildRankName != null)
{
buildRank = RankManager.FindRank(buildRankName);
if (buildRank == null)
{
player.MessageNoRank(buildRankName);
return;
}
if (accessRankName != null)
{
accessRank = RankManager.FindRank(accessRankName);
if (accessRank == null)
{
player.MessageNoRank(accessRankName);
return;
}
}
}
// Retype realm name, if needed
if (worldName == "-")
{
if (player.LastUsedWorldName != null)
{
worldName = player.LastUsedWorldName;
}
else
{
player.Message("Cannot repeat realm name: you haven't used any names yet.");
return;
}
}
lock (WorldManager.SyncRoot)
{
World realm = WorldManager.FindWorldExact(worldName);
if (realm != null)
{
player.LastUsedWorldName = realm.Name;
// Replacing existing realm's map
if (!cmd.IsConfirmed)
{
player.Confirm(cmd, "About to replace realm map for {0}&S with \"{1}\".",
realm.ClassyName, fileName);
return;
}
Map map;
try
{
map = MapUtility.Load(fullFileName);
realm.IsHidden = false;
realm.IsRealm = true;
WorldManager.SaveWorldList();
}
catch (Exception ex)
{
player.MessageNow("Could not load specified file: {0}: {1}", ex.GetType().Name, ex.Message);
return;
}
try
{
realm.MapChangedBy = player.Name;
realm.ChangeMap(map);
realm.IsHidden = false;
realm.IsRealm = true;
WorldManager.SaveWorldList();
}
catch (WorldOpException ex)
{
Logger.Log(LogType.Error,
"Could not complete RealmLoad operation: {0}", ex.Message);
player.Message("&WRealmLoad: {0}", ex.Message);
return;
}
realm.Players.Message(player, "{0}&S loaded a new map for the realm {1}",
player.ClassyName, realm.ClassyName);
player.MessageNow("New map for the realm {0}&S has been loaded.", realm.ClassyName);
Logger.Log(LogType.UserActivity,
"{0} loaded new map for realm \"{1}\" from {2}",
player.Name, realm.Name, fullFileName);
}
else
{
// Adding a new realm
string targetFullFileName = Path.Combine(Paths.MapPath, worldName + ".fcm");
if (!cmd.IsConfirmed &&
File.Exists(targetFullFileName) && // target file already exists
!Paths.Compare(targetFullFileName, fullFileName))
{
// and is different from sourceFile
player.Confirm(cmd,
"A map named \"{0}\" already exists, and will be overwritten with \"{1}\".",
Path.GetFileName(targetFullFileName), Path.GetFileName(fullFileName));
return;
}
Map map;
try
{
map = MapUtility.Load(fullFileName);
//realm.IsHidden = false;
//realm.IsRealm = true;
//WorldManager.SaveWorldList();
}
catch (Exception ex)
{
player.MessageNow("Could not load \"{0}\": {1}: {2}",
fileName, ex.GetType().Name, ex.Message);
return;
}
World newWorld;
try
{
newWorld = WorldManager.AddWorld(player, worldName, map, false);
}
catch (WorldOpException ex)
{
player.Message("RealmLoad: {0}", ex.Message);
return;
}
player.LastUsedWorldName = worldName;
newWorld.BuildSecurity.MinRank = buildRank;
if (accessRank == null)
{
newWorld.AccessSecurity.ResetMinRank();
}
else
{
newWorld.AccessSecurity.MinRank = accessRank;
}
newWorld.BlockDB.AutoToggleIfNeeded();
if (BlockDB.IsEnabledGlobally && newWorld.BlockDB.IsEnabled)
{
player.Message("BlockDB is now auto-enabled on realm {0}", newWorld.ClassyName);
}
newWorld.LoadedBy = player.Name;
newWorld.LoadedOn = DateTime.UtcNow;
Server.Message("{0}&S created a new realm named {1}",
player.ClassyName, newWorld.ClassyName);
Logger.Log(LogType.UserActivity,
"{0} created a new realm named \"{1}\" (loaded from \"{2}\")",
player.Name, worldName, fileName);
newWorld.IsHidden = false;
newWorld.IsRealm = true;
WorldManager.SaveWorldList();
player.MessageNow("Access permission is {0}+&S, and build permission is {1}+",
newWorld.AccessSecurity.MinRank.ClassyName,
newWorld.BuildSecurity.MinRank.ClassyName);
}
}
}
Server.RequestGC();
}
static void WorldMainHandler(Player player, Command cmd)
{
string param = cmd.Next();
if (param == null)
{
player.Message("Main world is {0}", WorldManager.MainWorld.ClassyName);
var mainedRanks = RankManager.Ranks
.Where(r => r.MainWorld != null && r.MainWorld != WorldManager.MainWorld);
if (mainedRanks.Count() > 0)
{
player.Message("Rank mains: {0}",
mainedRanks.JoinToString(r => String.Format("{0}&S for {1}&S",
// ReSharper disable PossibleNullReferenceException
r.MainWorld.ClassyName,
// ReSharper restore PossibleNullReferenceException
r.ClassyName)));
}
return;
}
if (param.StartsWith("@"))
{
string rankName = param.Substring(1);
Rank rank = RankManager.FindRank(rankName);
if (rank == null)
{
player.MessageNoRank(rankName);
return;
}
string worldName = cmd.Next();
if (worldName == null)
{
if (rank.MainWorld != null)
{
player.Message("Main world for rank {0}&S is {1}",
rank.ClassyName,
rank.MainWorld.ClassyName);
}
else
{
player.Message("Main world for rank {0}&S is {1}&S (default)",
rank.ClassyName,
WorldManager.MainWorld.ClassyName);
}
}
else
{
World world = WorldManager.FindWorldOrPrintMatches(player, worldName);
if (world != null)
{
SetRankMainWorld(player, rank, world);
}
}
}
else
{
World world = WorldManager.FindWorldOrPrintMatches(player, param);
if (world != null)
{
SetMainWorld(player, world);
}
}
}
public static void RankHandler( Player player, Command cmd )
{
string name = cmd.Next();
string newRankName = cmd.Next();
// Check arguments
if( name == null || newRankName == null ) {
CdRank.PrintUsage( player );
player.Message( "See &H/Ranks&S for list of ranks." );
return;
}
// Parse rank name
Rank newRank = RankManager.FindRank( newRankName );
if( newRank == null ) {
player.MessageNoRank( newRankName );
return;
}
// Parse player name
if( name == "-" ) {
if( player.LastUsedPlayerName != null ) {
name = player.LastUsedPlayerName;
} else {
player.Message( "Cannot repeat player name: you haven't used any names yet." );
return;
}
}
PlayerInfo targetInfo = PlayerDB.FindPlayerInfoExact( name );
if( targetInfo == null ) {
if( !player.Can( Permission.EditPlayerDB ) ) {
player.MessageNoPlayer( name );
return;
}
if( !Player.IsValidName( name ) ) {
player.MessageInvalidPlayerName( name );
CdRank.PrintUsage( player );
return;
}
if( cmd.IsConfirmed ) {
if( newRank > RankManager.DefaultRank ) {
targetInfo = PlayerDB.AddFakeEntry( name, RankChangeType.Promoted );
} else {
targetInfo = PlayerDB.AddFakeEntry( name, RankChangeType.Demoted );
}
} else {
player.Confirm( cmd,
"Warning: Player \"{0}\" is not in the database (possible typo). Type the full name or",
name );
return;
}
}
try {
player.LastUsedPlayerName = targetInfo.Name;
//reset temprank values
if (targetInfo.isTempRanked)
{
targetInfo.isTempRanked = false;
targetInfo.tempRankTime = TimeSpan.FromSeconds(0);
}
targetInfo.ChangeRank( player, newRank, cmd.NextAll(), true, true, false );
} catch( PlayerOpException ex ) {
player.Message( ex.MessageColored );
}
}
private static void MostHandler(Player player, CommandReader cmd) {
string stat = cmd.Next();
if (string.IsNullOrEmpty(stat)) {
CdMost.PrintUsage(player);
return;
}
string rankStr = cmd.Next();
string offsetStr = cmd.Next();
string value;
bool noRank = false;
int offset = 0, pad = 0;
Rank rank = RankManager.FindRank(rankStr);
if (string.IsNullOrEmpty(rankStr)) {
noRank = true;
} else {
if (rank == null) {
if (!int.TryParse(rankStr, out offset)) {
player.MessageNoRank(rankStr);
return;
} else {
noRank = true;
}
}
if (offsetStr != null) {
if (!int.TryParse(offsetStr, out offset)) {
offset = 0;
}
}
}
IEnumerable<PlayerInfo> allPlayers = PlayerDB.PlayerInfoList;
PlayerInfo[] playersPart = allPlayers.ToArray();
switch (stat.ToLower()) {
case ("bans"):
case ("banned"):
allPlayers = allPlayers.Where(p => p.TimesBannedOthers >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.TimesBannedOthers).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N0}", playersPart[0].TimesBannedOthers).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N0}", playersPart[i].TimesBannedOthers);
sendMostMessage(player, value, playersPart[i], pad);
}
break;
case ("built"):
allPlayers = allPlayers.Where(p => p.BlocksBuilt >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.BlocksBuilt).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N0}", playersPart[0].BlocksBuilt).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N0}", playersPart[i].BlocksBuilt);
sendMostMessage(player, value, playersPart[i], pad);
}
break;
case ("chat"):
allPlayers = allPlayers.Where(p => p.MessagesWritten >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.MessagesWritten).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N0}", playersPart[0].MessagesWritten).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N0}", playersPart[i].MessagesWritten);
sendMostMessage(player, value, playersPart[i], pad);
}
break;
case ("deleted"):
allPlayers = allPlayers.Where(p => p.BlocksDeleted >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.BlocksDeleted).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N0}", playersPart[0].BlocksDeleted).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N0}", playersPart[i].BlocksDeleted);
sendMostMessage(player, value, playersPart[i], pad);
}
break;
case ("demoted"):
allPlayers = allPlayers.Where(p => p.DemoCount >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.DemoCount).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N0}", playersPart[0].DemoCount).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N0}", playersPart[i].DemoCount);
sendMostMessage(player, value, playersPart[i], pad);
}
break;
case ("drawn"):
allPlayers = allPlayers.Where(p => p.BlocksDrawn >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.BlocksDrawn).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N0}&sK", (playersPart[0].BlocksDrawn / 1000D)).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N0}&sK", (playersPart[i].BlocksDrawn / 1000D));
sendMostMessage(player, value, playersPart[i], pad);
}
break;
case ("time"):
case ("hours"):
allPlayers = allPlayers.Where(p => p.TotalTime.ToHours() >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.TotalTime.ToHours()).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N2}&sH", playersPart[0].TotalTime.TotalHours).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N2}&sH", playersPart[i].TotalTime.TotalHours);
sendMostMessage(player, value, playersPart[i], pad);
}
break;
case ("kicks"):
case ("kicked"):
allPlayers = allPlayers.Where(p => p.TimesKickedOthers >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.TimesKickedOthers).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N0}", playersPart[0].TimesKickedOthers).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N0}", playersPart[i].TimesKickedOthers);
sendMostMessage(player, value, playersPart[i], pad);
}
break;
case ("logins"):
allPlayers = allPlayers.Where(p => p.TimesVisited >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.TimesVisited).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N0}", playersPart[0].TimesVisited).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N0}", playersPart[i].TimesVisited);
sendMostMessage(player, value, playersPart[i], pad);
}
break;
case ("promoted"):
allPlayers = allPlayers.Where(p => p.PromoCount >= 1 && (!noRank ? (p.Rank == rank) : true)).OrderBy(c => c.PromoCount).ToArray().Reverse();
playersPart = allPlayers.Skip(fixOffset(offset, allPlayers.Count())).Take(10).ToArray();
pad = string.Format("{0:N0}", playersPart[0].PromoCount).Length;
player.Message("&STop Players ({0}):", stat);
for (int i = 0; i < playersPart.Count(); i++) {
value = string.Format("{0:N0}", playersPart[i].PromoCount);
sendMostMessage(player, value, playersPart[i], pad);
}
break;
default:
player.Message("No stats for: {0}", stat);
return;
}
player.Message("Showing players{3}{0}-{1} (out of {2}).", offset + 1, offset + playersPart.Length, allPlayers.Count(), (rank != null ? " in rank (" + rank.ClassyName + "&s)" : " "));
}
static void SetInfoHandler( Player player, Command cmd )
{
string targetName = cmd.Next();
string propertyName = cmd.Next();
string valName = cmd.NextAll();
if( targetName == null || propertyName == null ) {
CdSetInfo.PrintUsage( player );
return;
}
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches( player, targetName );
if( info == null ) return;
switch( propertyName.ToLower() ) {
case "timeskicked":
int oldTimesKicked = info.TimesKicked;
if( ValidateInt( valName, 0, 9999 ) ) {
info.TimesKicked = Int32.Parse( valName );
player.Message( "SetInfo: TimesKicked for {0}&S changed from {1} to {2}",
info.ClassyName,
oldTimesKicked,
info.TimesKicked );
} else {
player.Message( "SetInfo: TimesKicked value acceptible (Acceptible value range: 0-9999)" );
}
return;
case "previousrank":
Rank newPreviousRank;
if( valName.Length > 0 ) {
newPreviousRank = RankManager.FindRank( valName );
if( newPreviousRank == null ) {
player.MessageNoRank( valName );
return;
}
} else {
newPreviousRank = null;
}
Rank oldPreviousRank = info.PreviousRank;
if( newPreviousRank == oldPreviousRank ) {
if( newPreviousRank == null ) {
player.Message( "SetInfo: PreviousRank for {0}&S is not set.",
info.ClassyName );
} else {
player.Message( "SetInfo: PreviousRank for {0}&S is already set to {1}",
info.ClassyName,
newPreviousRank.ClassyName );
}
return;
}
if( oldPreviousRank == null ) {
player.Message( "SetInfo: PreviousRank for {0}&S set to {1}&",
info.ClassyName,
newPreviousRank.ClassyName );
} else if( newPreviousRank == null ) {
player.Message( "SetInfo: PreviousRank for {0}&S was reset (was {1}&S)",
info.ClassyName,
oldPreviousRank.ClassyName );
} else {
player.Message( "SetInfo: PreviousRank for {0}&S changed from {1}&S to {2}",
info.ClassyName,
oldPreviousRank.ClassyName,
newPreviousRank.ClassyName );
}
return;
case "totaltime":
TimeSpan newTotalTime;
TimeSpan oldTotalTime = info.TotalTime;
if( valName.TryParseMiniTimespan( out newTotalTime ) ) {
info.TotalTime = newTotalTime;
player.Message( "SetInfo: TotalTime for {0}&S changed from {1} ({2}) to {3} ({4})",
info.ClassyName,
oldTotalTime.ToMiniString(),
oldTotalTime.ToCompactString(),
info.TotalTime.ToMiniString(),
info.TotalTime.ToCompactString() );
} else {
player.Message( "SetInfo: Could not parse value given for TotalTime." );
}
return;
case "rankchangetype":
RankChangeType oldType = info.RankChangeType;
try {
info.RankChangeType = (RankChangeType)Enum.Parse( typeof( RankChangeType ), valName, true );
} catch( ArgumentException ) {
player.Message( "SetInfo: Could not parse RankChangeType. Allowed values: {0}",
String.Join( ", ", Enum.GetNames( typeof( RankChangeType ) ) ) );
return;
}
player.Message( "SetInfo: RankChangeType for {0}&S changed from {1} to {2}",
info.ClassyName,
oldType,
info.RankChangeType );
return;
case "banreason":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "BanReason", info, info.BanReason, valName ) ) {
info.BanReason = valName;
}
return;
case "unbanreason":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "UnbanReason", info, info.UnbanReason, valName ) ) {
info.UnbanReason = valName;
}
return;
case "rankreason":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "RankReason", info, info.RankChangeReason, valName ) ) {
info.RankChangeReason = valName;
}
return;
case "kickreason":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "KickReason", info, info.LastKickReason, valName ) ) {
info.LastKickReason = valName;
}
return;
case "displayedname":
string oldDisplayedName = info.DisplayedName;
if( player.Can( Permission.UseColorCodes ) ) {
valName = Color.ReplacePercentCodes( valName );
}
if( valName.Length == 0 ) valName = null;
if( valName == info.DisplayedName ) {
if( valName == null ) {
player.Message( "SetInfo: DisplayedName for {0} is not set.",
info.Name );
} else {
player.Message( "SetInfo: DisplayedName for {0} is already set to \"{1}&S\"",
info.Name,
valName );
}
return;
}
info.DisplayedName = valName;
if( oldDisplayedName == null ) {
player.Message( "SetInfo: DisplayedName for {0} set to \"{1}&S\"",
info.Name,
valName );
} else if( valName == null ) {
player.Message( "SetInfo: DisplayedName for {0} was reset (was \"{1}&S\")",
info.Name,
oldDisplayedName );
} else {
player.Message( "SetInfo: DisplayedName for {0} changed from \"{1}&S\" to \"{2}&S\"",
info.Name,
oldDisplayedName,
valName );
}
return;
default:
player.Message( "Only the following properties are editable: " +
"TimesKicked, PreviousRank, TotalTime, RankChangeType, " +
"BanReason, UnbanReason, RankReason, KickReason, DisplayedName" );
return;
}
}
private static void MaxPWHandler(Player player, CommandReader cmd) {
string rname = cmd.Next();
string rmax = cmd.Next();
Rank prank = player.Info.Rank;
if (player.Info.Rank == RankManager.HighestRank) {
if (rname == null) {
player.Message("Rank ({0}&s) has a max of {1} personal worlds", prank.ClassyName,
prank.MaxPersonalWorlds);
return;
}
Rank rank = RankManager.FindRank(rname);
if (rank == null) {
player.MessageNoRank(rname);
return;
}
if (rmax == null) {
player.Message("Rank ({0}&s) has a max of {1} personal worlds.", rank.ClassyName,
rank.MaxPersonalWorlds);
return;
}
int max;
if (!int.TryParse(rmax, out max)) {
player.Message(CdMaxPW.Usage);
return;
}
if (rank != null) {
rank.MaxPersonalWorlds = max;
player.Message("Set MaxPersonalWorlds for rank ({0}&s) to {1} personal worlds.", rank.ClassyName,
rank.MaxPersonalWorlds);
Config.Save();
}
} else {
player.Message("Rank ({0}&s) has a max of {1} personal worlds.", prank.ClassyName,
prank.MaxPersonalWorlds);
return;
}
}
private static void CommandsHandler(Player player, CommandReader cmd) {
string param = cmd.Next();
CommandDescriptor[] cd;
CommandCategory category;
string prefix;
if (param == null) {
player.Message("&sCommand Categories:");
player.Message("&h /cmds Building");
player.Message("&h /cmds Chat");
player.Message("&h /cmds Info");
player.Message("&h /cmds Maintenance");
player.Message("&h /cmds Moderation");
player.Message("&h /cmds World");
player.Message("&h /cmds New");
player.Message("&h /cmds All");
return;
}
Array items = CommandManager.GetCommands(player.Info.Rank, false);
string output = "";
if (param.StartsWith("*") && param.EndsWith("*")) {
foreach (CommandDescriptor item in items) {
if (item.Name.ToLower().Contains(param.ToLower().Trim('*'))) {
output += item.MinRank.Color + item.Name + "&s, ";
}
}
player.Message("&sCommands containing \"{0}\":", param.Trim('*'));
if (output.EndsWith(", ")) {
player.Message(output.Remove(output.Length - 2) + ".");
} else {
player.Message("There are no commands containing \"{0}\"", param.Trim('*'));
}
return;
} else if (param.EndsWith("*")) {
foreach (CommandDescriptor item in items) {
if (item.Name.ToLower().StartsWith(param.ToLower().Trim('*'))) {
output += item.MinRank.Color + item.Name + "&s, ";
}
}
player.Message("&sCommands starting with \"{0}\":", param.Trim('*'));
if (output.EndsWith(", ")) {
player.Message(output.Remove(output.Length - 2) + ".");
} else {
player.Message("There are no commands starting with \"{0}\"", param.Trim('*'));
}
return;
} else if (param.StartsWith("*")) {
foreach (CommandDescriptor item in items) {
if (item.Name.ToLower().EndsWith(param.ToLower().Trim('*'))) {
output += item.MinRank.Color + item.Name + "&s, ";
}
}
player.Message("&sCommands ending with \"{0}\":", param.Trim('*'));
if (output.EndsWith(", ")) {
player.Message(output.Remove(output.Length - 2) + ".");
} else {
player.Message("There are no commands ending with \"{0}\"", param.Trim('*'));
}
return;
} else if (param.StartsWith("@")) {
string rankName = param.Substring(1);
Rank rank = RankManager.FindRank(rankName);
if (rank == null) {
player.MessageNoRank(rankName);
return;
}
prefix = String.Format("Commands available to {0}&S", rank.ClassyName);
cd = CommandManager.GetCommands(rank, false);
} else if (param.Equals("all", StringComparison.OrdinalIgnoreCase)) {
prefix = "All commands";
cd = CommandManager.GetCommands();
} else if (param.Equals("hidden", StringComparison.OrdinalIgnoreCase)) {
prefix = "Hidden commands";
cd = CommandManager.GetCommands(true);
} else if (EnumUtil.TryComplete(param, out category, true)) {
prefix = String.Format("{0} commands", category);
cd = CommandManager.GetCommands(category, false);
} else {
CdCommands.PrintUsage(player);
return;
}
player.MessagePrefixed("&S ", "{0}: {1}", prefix, cd.JoinToClassyString());
}
static void SetInfoHandler( Player player, CommandReader cmd ) {
string targetName = cmd.Next();
string propertyName = cmd.Next();
string valName = cmd.NextAll();
if( targetName == null || propertyName == null ) {
CdSetInfo.PrintUsage( player );
return;
}
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches( player, targetName, SearchOptions.IncludeSelf );
if( info == null ) return;
switch( propertyName.ToLower() ) {
case "timeskicked":
case "tk":
int oldTimesKicked = info.TimesKicked;
if( ValidateInt( valName, 0, 9999 ) ) {
info.TimesKicked = Int32.Parse( valName );
player.Message( "SetInfo: TimesKicked for {0}&S changed from {1} to {2}",
info.ClassyName,
oldTimesKicked,
info.TimesKicked );
break;
} else {
player.Message( "SetInfo: TimesKicked value out of range (acceptable: 0-9999)" );
return;
}
case "previousrank":
case "pr":
Rank newPreviousRank;
if( valName.Length > 0 ) {
newPreviousRank = RankManager.FindRank( valName );
if( newPreviousRank == null ) {
player.MessageNoRank( valName );
return;
}
} else {
newPreviousRank = null;
}
Rank oldPreviousRank = info.PreviousRank;
if( newPreviousRank == null && oldPreviousRank == null ) {
player.Message( "SetInfo: PreviousRank for {0}&S is not set.",
info.ClassyName );
return;
} else if( newPreviousRank == oldPreviousRank ) {
player.Message( "SetInfo: PreviousRank for {0}&S is already set to {1}",
info.ClassyName,
newPreviousRank.ClassyName );
return;
}
info.PreviousRank = newPreviousRank;
if( oldPreviousRank == null ) {
player.Message( "SetInfo: PreviousRank for {0}&S set to {1}&",
info.ClassyName,
newPreviousRank.ClassyName );
} else if( newPreviousRank == null ) {
player.Message( "SetInfo: PreviousRank for {0}&S was reset (was {1}&S)",
info.ClassyName,
oldPreviousRank.ClassyName );
} else {
player.Message( "SetInfo: PreviousRank for {0}&S changed from {1}&S to {2}",
info.ClassyName,
oldPreviousRank.ClassyName,
newPreviousRank.ClassyName );
}
break;
case "totaltime":
case "tt":
TimeSpan newTotalTime;
TimeSpan oldTotalTime = info.TotalTime;
if( valName.TryParseMiniTimeSpan( out newTotalTime ) ) {
if( newTotalTime > DateTimeUtil.MaxTimeSpan ) {
player.MessageMaxTimeSpan();
return;
}
info.TotalTime = newTotalTime;
player.Message( "SetInfo: TotalTime for {0}&S changed from {1} ({2}) to {3} ({4})",
info.ClassyName,
oldTotalTime.ToMiniString(),
oldTotalTime.ToCompactString(),
info.TotalTime.ToMiniString(),
info.TotalTime.ToCompactString() );
break;
} else {
player.Message( "SetInfo: Could not parse value given for TotalTime." );
return;
}
case "rankchangetype":
case "rct":
RankChangeType oldType = info.RankChangeType;
RankChangeType newType;
if(!EnumUtil.TryParse(valName, out newType, true)){
player.Message( "SetInfo: Could not parse RankChangeType. Allowed values: {0}",
String.Join( ", ", Enum.GetNames( typeof( RankChangeType ) ) ) );
return;
}
info.RankChangeType = newType;
player.Message( "SetInfo: RankChangeType for {0}&S changed from {1} to {2}",
info.ClassyName,
oldType,
info.RankChangeType );
break;
case "banreason":
case "br":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "BanReason", info, info.BanReason, valName ) ) {
info.BanReason = valName;
break;
} else {
return;
}
case "bandwidth":
case "bw":
BandwidthUseMode oldMode = info.BandwidthUseMode;
BandwidthUseMode newMode;
if( !EnumUtil.TryParse( valName, out newMode, true ) ) {
player.Message( "SetInfo: Could not parse BandwidthUseMode. Allowed values: {0}",
String.Join( ", ", Enum.GetNames( typeof( BandwidthUseMode ) ) ) );
return;
}
info.BandwidthUseMode = newMode;
player.Message( "SetInfo: BandwidthUseMode for {0}&S changed from {1} to {2}",
info.ClassyName,
oldMode, newMode );
break;
case "unbanreason":
case "ur":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "UnbanReason", info, info.UnbanReason, valName ) ) {
info.UnbanReason = valName;
break;
} else {
return;
}
case "rankreason":
case "rr":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "RankReason", info, info.RankChangeReason, valName ) ) {
info.RankChangeReason = valName;
break;
} else {
return;
}
case "kickreason":
case "kr":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "KickReason", info, info.LastKickReason, valName ) ) {
info.LastKickReason = valName;
break;
} else {
return;
}
case "displayedname":
case "dn":
string oldDisplayedName = info.DisplayedName;
if( valName.Length == 0 ) valName = null;
if( valName != null && ( valName.Contains( '\n' ) || valName.Contains( "&n" ) || valName.Contains( "&N" ) ) ) {
player.Message( "SetInfo: DisplayedName may not contain line breaks." );
return;
}
if( valName == info.DisplayedName ) {
if( valName == null ) {
player.Message( "SetInfo: DisplayedName for {0} is not set.",
info.Name );
} else {
player.Message( "SetInfo: DisplayedName for {0} is already set to \"{1}&S\"",
info.Name,
valName );
}
return;
}
info.DisplayedName = valName;
if( oldDisplayedName == null ) {
player.Message( "SetInfo: DisplayedName for {0} set to \"{1}&S\"",
info.Name,
valName );
} else if( valName == null ) {
player.Message( "SetInfo: DisplayedName for {0} was reset (was \"{1}&S\")",
info.Name,
oldDisplayedName );
} else {
player.Message( "SetInfo: DisplayedName for {0} changed from \"{1}&S\" to \"{2}&S\"",
info.Name,
oldDisplayedName,
valName );
}
break;
case "name":
case "n":
if( valName.Equals( info.Name, StringComparison.OrdinalIgnoreCase ) ) {
info.Name = valName;
} else {
player.Message( "SetInfo: Only capitalization changes are allowed in the name. " +
"Type out the whole name ({0}) please.",
info.Name );
return;
}
break;
default:
player.Message( "Only the following properties are editable: " +
"TimesKicked, PreviousRank, TotalTime, RankChangeType, " +
"BanReason, UnbanReason, RankReason, KickReason, DisplayedName" );
return;
}
info.LastModified = DateTime.UtcNow;
}
// TODO: document the fact that this only promotes (unlike "/Import Ranks")
static void ImportRankListHandler( Player player, CommandReader cmd ) {
string fileName = cmd.Next();
string rankName = cmd.Next();
string reason = cmd.NextAll();
if( fileName == null || rankName == null ) {
CdImportRankList.PrintUsage( player );
return;
}
// parse rank name
Rank rank = RankManager.FindRank( rankName );
if( rank == null ) {
player.MessageNoRank( rankName );
return;
}
// Make sure that the target file is legit
if( !Paths.Contains( Paths.WorkingPath, fileName ) ) {
Logger.Log( LogType.SuspiciousActivity,
"ImportRankList: Player {0} tried to import from \"{1}\"",
player.Name,
fileName );
player.MessageUnsafePath();
return;
}
// Make sure file exists
if( !File.Exists( fileName ) ) {
player.Message( "Rank list file not found: " + fileName );
return;
}
// Read list of names from file.
// Using List list to preserve capitalization and a HashSet to avoid duplicates.
List<string> nameList = new List<string>();
using( StreamReader reader = new StreamReader( fileName ) ) {
HashSet<string> lowerNameSet = new HashSet<string>();
while( true ) {
string nextName = reader.ReadLine();
if( nextName == null ) break;
if( !Player.IsValidPlayerName( nextName ) ) {
player.Message( "ImportRankList: Invalid player name skipped: {0}", nextName );
continue;
}
string nameToLower = nextName.ToLowerInvariant();
if( lowerNameSet.Contains( nameToLower ) ) {
player.Message( "ImportRankList: Skipping a duplicate name: {0}", nextName );
continue;
}
nameList.Add( nextName );
lowerNameSet.Add( nameToLower );
}
}
// Ask player to confirm before continuing
if( !cmd.IsConfirmed ) {
Logger.Log( LogType.UserActivity,
"Import: Asked {0} to confirm importing {1} ranks from {2}",
player.Name,
nameList.Count,
fileName );
player.Confirm( cmd,
"ImportRankList: Are you sure you want to rank {0} players to {1}&S?",
nameList.Count,
rank.ClassyName );
return;
}
// Carry out the promotions
int newPlayers = 0,
promotedPlayers = 0,
skippedPlayers = 0;
foreach( string name in nameList ) {
PlayerInfo info = PlayerDB.FindPlayerInfoExact( name );
if( info == null ) {
// Create and promote a new record
newPlayers++;
PlayerInfo newInfo = PlayerDB.CreateNewPlayerInfo( name, RankChangeType.Promoted );
newInfo.ChangeRank( player, rank, reason, true, true, false );
Logger.Log( LogType.UserActivity, "ImportRankList: Created a new player record for {0}", name );
} else {
// Check if an existing record needs updating
if( info.Rank < rank && // don't demote anyone
!info.IsBanned && // don't promote banned players
info.RankChangeType != RankChangeType.Demoted && // don't re-promote demoted players
info.RankChangeType != RankChangeType.AutoDemoted ) {
// Promote!
info.ChangeRank( player, rank, reason, true, true, false );
promotedPlayers++;
} else {
skippedPlayers++;
}
}
}
string successMsg = String.Format(
"ImportRankList: Created {0} new records, promoted {1} players, " +
"skipped {2} records from file \"{3}\"",
newPlayers,
promotedPlayers,
skippedPlayers,
Path.GetFileName( fileName ) );
Logger.Log( LogType.UserActivity, successMsg );
player.Message( successMsg );
}
static void ImportRanks(Player player, CommandReader cmd)
{
string serverName = cmd.Next();
string fileName = cmd.Next();
string rankName = cmd.Next();
bool silent = (cmd.Next() != null);
// Make sure all parameters are specified
if (serverName == null || fileName == null || rankName == null)
{
CdImport.PrintUsage(player);
return;
}
// Check if file exists
if (!File.Exists(fileName))
{
player.Message("File not found: {0}", fileName);
return;
}
Rank targetRank = RankManager.FindRank(rankName);
if (targetRank == null)
{
player.MessageNoRank(rankName);
return;
}
string[] names;
switch (serverName.ToLower())
{
case "mcsharp":
case "mczall":
case "mclawl":
try {
names = File.ReadAllLines(fileName);
} catch (Exception ex) {
Logger.Log(LogType.Error,
"Could not open \"{0}\" to import ranks: {1}",
fileName, ex);
return;
}
break;
default:
player.Message("fCraft does not support importing from {0}", serverName);
return;
}
if (!cmd.IsConfirmed)
{
player.Confirm(cmd, "Import {0} player ranks from \"{1}\"?",
names.Length, Path.GetFileName(fileName));
return;
}
string reason = "(Import from " + serverName + ")";
foreach (string name in names)
{
PlayerInfo info = PlayerDB.FindExact(name) ??
PlayerDB.AddUnrecognizedPlayer(name, RankChangeType.Promoted);
try {
info.ChangeRank(player, targetRank, reason, !silent, true, false);
} catch (PlayerOpException ex) {
player.Message(ex.MessageColored);
}
}
PlayerDB.Save();
}
static void BringAllHandler( Player player, CommandReader cmd ) {
World playerWorld = player.World;
if( playerWorld == null ) PlayerOpException.ThrowNoWorld( player );
List<World> targetWorlds = new List<World>();
List<Rank> targetRanks = new List<Rank>();
bool allWorlds = false;
bool allRanks = true;
// Parse the list of worlds and ranks
string arg;
while( (arg = cmd.Next()) != null ) {
if( arg.StartsWith( "@" ) ) {
Rank rank = RankManager.FindRank( arg.Substring( 1 ) );
if( rank == null ) {
player.MessageNoRank( arg.Substring( 1 ) );
return;
} else {
if( player.Can( Permission.Bring, rank ) ) {
targetRanks.Add( rank );
} else {
player.Message( "&WYou are not allowed to bring players of rank {0}",
rank.ClassyName );
}
allRanks = false;
}
} else if( arg == "*" ) {
allWorlds = true;
} else {
World world = WorldManager.FindWorldOrPrintMatches( player, arg );
if( world == null ) return;
targetWorlds.Add( world );
}
}
// If no worlds were specified, use player's current world
if( !allWorlds && targetWorlds.Count == 0 ) {
targetWorlds.Add( player.World );
}
// Apply all the rank and world options
HashSet<Player> targetPlayers;
if( allRanks && allWorlds ) {
targetPlayers = new HashSet<Player>( Server.Players );
} else if( allWorlds ) {
targetPlayers = new HashSet<Player>();
foreach( Rank rank in targetRanks ) {
foreach( Player rankPlayer in Server.Players.Ranked( rank ) ) {
targetPlayers.Add( rankPlayer );
}
}
} else if( allRanks ) {
targetPlayers = new HashSet<Player>();
foreach( World world in targetWorlds ) {
foreach( Player worldPlayer in world.Players ) {
targetPlayers.Add( worldPlayer );
}
}
} else {
targetPlayers = new HashSet<Player>();
foreach( Rank rank in targetRanks ) {
foreach( World world in targetWorlds ) {
foreach( Player rankWorldPlayer in world.Players.Ranked( rank ) ) {
targetPlayers.Add( rankWorldPlayer );
}
}
}
}
Rank bringLimit = player.Info.Rank.GetLimit( Permission.Bring );
// Remove the player him/herself
targetPlayers.Remove( player );
int count = 0;
// Actually bring all the players
foreach( Player targetPlayer in targetPlayers.CanBeSeen( player )
.RankedAtMost( bringLimit ) ) {
if( targetPlayer.World == playerWorld ) {
// teleport within the same world
targetPlayer.TeleportTo( player.Position );
targetPlayer.Position = player.Position;
if( targetPlayer.Info.IsFrozen ) {
targetPlayer.Position = player.Position;
}
} else {
// teleport to a different world
BringPlayerToWorld( player, targetPlayer, playerWorld, false, true );
}
count++;
}
// Check if there's anyone to bring
if( count == 0 ) {
player.Message( "No players to bring!" );
} else {
player.Message( "Bringing {0} players...", count );
}
}
static void LPRHandler(Player player, CommandReader cmd)
{
string name = cmd.Next();
PlayerInfo[] infos;
Rank rank = RankManager.FindRank(player.Info.Rank.Name);
if (name != null)
{
rank = RankManager.FindRank(name);
if (rank == null)
{
player.MessageNoRank(name);
return;
}
}
infos = PlayerDB.PlayerInfoList.Where(info => info.PreviousRank == rank).OrderBy(c => c.TimeSinceRankChange).ToArray();
int offset;
if (!cmd.NextInt(out offset)) offset = 0;
if (offset >= infos.Count())
{
offset = Math.Max(0, infos.Count() - PlayersPerPage);
}
var playersPart = infos.Skip(offset).Take(10).ToArray();
player.MessagePrefixed("&S ", "&SPlayers who previously had rank ({1}&s): {0}", playersPart.JoinToString((r => String.Format("&n{0}&S (Had current rank ({2}&s) for: {1})", r.ClassyName, r.TimeSinceRankChange.ToMiniString(), r.Rank.ClassyName))), rank.ClassyName);
player.Message("Showing players {0}-{1} (out of {2}).", offset + 1, offset + playersPart.Length, infos.Count());
}
// Shows general information about a particular rank.
static void RankInfoHandler( Player player, CommandReader cmd ) {
Rank rank;
string rankName = cmd.Next();
if( cmd.HasNext ) {
CdRankInfo.PrintUsage( player );
return;
}
if( rankName == null ) {
rank = player.Info.Rank;
} else {
rank = RankManager.FindRank( rankName );
if( rank == null ) {
player.MessageNoRank( rankName );
return;
}
}
List<Permission> permissions = new List<Permission>();
for( int i = 0; i < rank.Permissions.Length; i++ ) {
if( rank.Permissions[i] ) {
permissions.Add( (Permission)i );
}
}
Permission[] sortedPermissionNames =
permissions.OrderBy( s => s.ToString(), StringComparer.OrdinalIgnoreCase ).ToArray();
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat( "Players of rank {0}&S can: ", rank.ClassyName );
bool first = true;
for( int i = 0; i < sortedPermissionNames.Length; i++ ) {
Permission p = sortedPermissionNames[i];
if( !first ) sb.Append( ',' ).Append( ' ' );
Rank permissionLimit = rank.PermissionLimits[(int)p];
sb.Append( p );
if( permissionLimit != null ) {
sb.AppendFormat( "({0}&S)", permissionLimit.ClassyName );
}
first = false;
}
player.Message( sb.ToString() );
}
if( rank.Can( Permission.Draw ) ) {
StringBuilder sb = new StringBuilder();
if( rank.DrawLimit > 0 ) {
sb.AppendFormat( "Draw limit: {0} blocks.", rank.DrawLimit );
} else {
sb.AppendFormat( "Draw limit: None (unlimited)." );
}
if( rank.Can( Permission.CopyAndPaste ) ) {
sb.AppendFormat( " Copy/paste slots: {0}", rank.CopySlots );
}
player.Message( sb.ToString() );
}
if( rank.IdleKickTimer > 0 ) {
player.Message( "Idle kick after {0}", TimeSpan.FromMinutes( rank.IdleKickTimer ).ToMiniString() );
}
}
// Shows general information about a particular rank.
static void RankInfoHandler( Player player, CommandReader cmd ) {
Rank rank;
string rankName = cmd.Next();
if( cmd.HasNext ) {
CdRankInfo.PrintUsage( player );
return;
}
if( rankName == null ) {
rank = player.Info.Rank;
} else {
rank = RankManager.FindRank( rankName );
if( rank == null ) {
player.MessageNoRank( rankName );
return;
}
}
List<Permission> permissions = new List<Permission>();
for( int i = 0; i < rank.Permissions.Length; i++ ) {
if( rank.Permissions[i] ) {
permissions.Add( (Permission)i );
}
}
Permission[] sortedPermissionNames =
permissions.OrderBy( s => s.ToString(), StringComparer.OrdinalIgnoreCase ).ToArray();
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat( "Players of rank {0}&S can: ", rank.ClassyName );
bool first = true;
for( int i = 0; i < sortedPermissionNames.Length; i++ ) {
Permission p = sortedPermissionNames[i];
if( !first ) sb.Append( ',' ).Append( ' ' );
Rank permissionLimit = rank.PermissionLimits[(int)p];
sb.Append( p );
if( permissionLimit != null ) {
sb.AppendFormat( "({0}&S)", permissionLimit.ClassyName );
}
first = false;
}
player.Message( sb.ToString() );
}
if( rank.Can( Permission.Draw ) ) {
StringBuilder sb = new StringBuilder();
if( rank.DrawLimit > 0 ) {
sb.AppendFormat( "Draw limit: {0} blocks.", rank.DrawLimit );
} else {
sb.AppendFormat( "Draw limit: None (unlimited)." );
}
if( rank.Can( Permission.CopyAndPaste ) ) {
sb.AppendFormat( " Copy/paste slots: {0}", rank.CopySlots );
}
player.Message( sb.ToString() );
}
if( rank.IdleKickTimer > 0 ) {
player.Message( "Idle kick after {0}", TimeSpan.FromMinutes( rank.IdleKickTimer ).ToMiniString() );
}
if (Directory.Exists(Paths.RankReqDirectory) && player.IsStaff) {
string rankReqFileName = null;
string[] sectionFiles = Directory.GetFiles(Paths.RankReqPath,rank.Name.ToLower() + ".txt", SearchOption.TopDirectoryOnly);
for (int i = 0; i < sectionFiles.Length; i++) {
string sectionFullName = Path.GetFileNameWithoutExtension(sectionFiles[i]).ToLower();
if (rank.Name.ToLower().Equals(sectionFullName)) {
rankReqFileName = sectionFiles[i];
break;
}
}
if (rankReqFileName != null) {
string sectionFullName = Path.GetFileNameWithoutExtension(rankReqFileName);
FileInfo rankReqFile = new FileInfo(rankReqFileName);
try {
string[] ruleLines = File.ReadAllLines(rankReqFile.FullName);
player.Message("&RRank requirements:");
foreach (string ruleLine in ruleLines) {
if (ruleLine.Trim().Length > 0) {
player.Message("&R{0}", Chat.ReplaceTextKeywords(player, ruleLine));
}
}
} catch (Exception ex) {
Logger.Log(LogType.Error,
"InfoCommands.PrintRankReq: An error occurred while trying to read {0}: {1}",
rankReqFile.FullName, ex);
player.Message("&WError reading the rank requirement file.");
}
}
}
}
static void ImportRanks( Player player, Command cmd )
{
string serverName = cmd.Next();
string fileName = cmd.Next();
string rankName = cmd.Next();
bool silent = (cmd.Next() != null);
// Make sure all parameters are specified
if( serverName == null || fileName == null || rankName == null ) {
CdImport.PrintUsage( player );
return;
}
// Check if file exists
if( !File.Exists( fileName ) ) {
player.Message( "File not found: {0}", fileName );
return;
}
Rank targetRank = RankManager.FindRank( rankName );
if( targetRank == null ) {
player.MessageNoRank( rankName );
return;
}
string[] names;
switch( serverName.ToLower() ) {
case "mcsharp":
case "mczall":
case "mclawl":
try {
names = File.ReadAllLines( fileName );
} catch( Exception ex ) {
Logger.Log( LogType.Error,
"Could not open \"{0}\" to import ranks: {1}",
fileName, ex );
return;
}
break;
default:
player.Message( "fCraft does not support importing from {0}", serverName );
return;
}
if( !cmd.IsConfirmed ) {
player.Confirm( cmd, "You are about to import {0} player ranks.", names.Length );
return;
}
string reason = "(Import from " + serverName + ")";
foreach( string name in names ) {
PlayerInfo info = PlayerDB.FindPlayerInfoExact( name ) ??
PlayerDB.AddFakeEntry( name, RankChangeType.Promoted );
try {
info.ChangeRank( player, targetRank, reason, !silent, true, false );
} catch( PlayerOpException ex ) {
player.Message( ex.MessageColored );
}
}
PlayerDB.Save();
}
static void ListStaffHandler(Player player, CommandReader cmd)
{
Rank ranktarget;
if (cmd.HasNext)
{
string rankName = cmd.Next();
ranktarget = RankManager.FindRank( rankName );
if (ranktarget == null)
{
player.MessageNoRank(rankName);
return;
}
}
else ranktarget = null;
PlayerInfo[] infos;
if (ranktarget == null)
{
player.Message("&sBelow is a list of ALL staff members.");
foreach (Rank rank in RankManager.Ranks)
{
if (rank.IsStaff)
{
infos = PlayerDB.PlayerInfoList
.Where(info => info.Rank == rank)
.ToArray();
if (infos != null && rank.PlayerCount > 0)
{
Array.Sort(infos, new PlayerInfoComparer(player));
IClassy[] itemsEnumerated = infos;
string nameList = itemsEnumerated.Take( 15 ).JoinToString( "&s, ", p => p.ClassyName );
if (rank.PlayerCount > 15) {
player.Message( " {0} &s(&f{1}&s): {2}{3} &s{4} more", rank.ClassyName, rank.PlayerCount, rank.Color, nameList, (rank.PlayerCount - 15) );
} else {
player.Message( " {0} &s(&f{1}&s): {2}{3}", rank.ClassyName, rank.PlayerCount, rank.Color, nameList );
}
}
}
}
}
else
{
player.Message("&sBelow is a list of ALL staff members of rank '" + ranktarget.ClassyName + "&s':");
infos = PlayerDB.PlayerInfoList
.Where(info => info.Rank == ranktarget)
.ToArray();
if (infos != null)
{
Array.Sort(infos, new PlayerInfoComparer(player));
IClassy[] itemsEnumerated = infos;
string nameList = itemsEnumerated.Take(30).JoinToString(", ", p => p.ClassyName);
if (ranktarget.PlayerCount > 15) {
player.Message( " {0} &s(&f{1}&s): {2}{3} &s{4} more", ranktarget.ClassyName, ranktarget.PlayerCount, ranktarget.Color, nameList, (ranktarget.PlayerCount - 30) );
} else {
player.Message( " {0} &s(&f{1}&s): {2}{3}", ranktarget.ClassyName, ranktarget.PlayerCount, ranktarget.Color, nameList );
}
}
}
}
static void TempRankHandler(Player player, Command cmd)
{
string target = cmd.Next();
string rank = cmd.Next();
string rankTime = cmd.Next();
TimeSpan rankDuration;
string reason = cmd.Next();
if(String.IsNullOrEmpty(target))
{
player.Message("&SPlease input a player's name to temprank.");
return;
}
if (String.IsNullOrEmpty(rank))
{
player.Message("&SPlease input your desired rank.");
return;
}
if (String.IsNullOrEmpty(rankTime))
{
player.Message("&SPlease input the duration of the temprank.");
return;
}
if (String.IsNullOrEmpty(reason))
{
player.Message("&SPlease input the reason for the temprank.");
return;
}
if (!rankTime.TryParseMiniTimespan(out rankDuration) || rankDuration <= TimeSpan.Zero)
{
player.Message("&SThe time must be an integer greater than 0!");
return;
}
Rank targetRank = RankManager.FindRank(rank);
if (targetRank == null)
{
player.MessageNoRank(rank);
return;
}
PlayerInfo targetInfo = PlayerDB.FindPlayerInfoExact(target);
if (targetInfo == null)
{
player.Message("&SThe player, {0}&S could not be found. Please check the spelling of the player.", target);
}
targetInfo.ChangeRank(player, targetRank, "TempRank(" + rankTime + "): " + reason , true, true, false);
targetInfo.isTempRanked = true;
targetInfo.tempRankTime = rankDuration;
}
static void ZoneEditHandler(Player player, Command cmd)
{
bool changesWereMade = false;
string zoneName = cmd.Next();
if (zoneName == null)
{
player.Message("No zone name specified. See &H/Help ZEdit");
return;
}
Zone zone = player.WorldMap.Zones.Find(zoneName);
if (zone == null)
{
player.MessageNoZone(zoneName);
return;
}
string name;
while ((name = cmd.Next()) != null)
{
if (name.StartsWith("+"))
{
if (name.Length == 1)
{
CdZoneEdit.PrintUsage(player);
break;
}
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches(player, name.Substring(1));
if (info == null)
{
return;
}
// prevent players from whitelisting themselves to bypass protection
if (!player.Info.Rank.AllowSecurityCircumvention && player.Info == info)
{
if (!zone.Controller.Check(info))
{
player.Message("You must be {0}+&S to add yourself to this zone's whitelist.",
zone.Controller.MinRank.ClassyName);
continue;
}
}
switch (zone.Controller.Include(info))
{
case PermissionOverride.Deny:
player.Message("{0}&S is no longer excluded from zone {1}",
info.ClassyName, zone.ClassyName);
changesWereMade = true;
break;
case PermissionOverride.None:
player.Message("{0}&S is now included in zone {1}",
info.ClassyName, zone.ClassyName);
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message("{0}&S is already included in zone {1}",
info.ClassyName, zone.ClassyName);
break;
}
}
else if (name.StartsWith("-"))
{
if (name.Length == 1)
{
CdZoneEdit.PrintUsage(player);
break;
}
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches(player, name.Substring(1));
if (info == null)
{
return;
}
switch (zone.Controller.Exclude(info))
{
case PermissionOverride.Deny:
player.Message("{0}&S is already excluded from zone {1}",
info.ClassyName, zone.ClassyName);
break;
case PermissionOverride.None:
player.Message("{0}&S is now excluded from zone {1}",
info.ClassyName, zone.ClassyName);
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message("{0}&S is no longer included in zone {1}",
info.ClassyName, zone.ClassyName);
changesWereMade = true;
break;
}
}
else
{
Rank minRank = RankManager.FindRank(name);
if (minRank != null)
{
// prevent players from lowering rank so bypass protection
if (!player.Info.Rank.AllowSecurityCircumvention &&
zone.Controller.MinRank > player.Info.Rank && minRank <= player.Info.Rank)
{
player.Message("You are not allowed to lower the zone's rank.");
continue;
}
if (zone.Controller.MinRank != minRank)
{
zone.Controller.MinRank = minRank;
player.Message("Permission for zone \"{0}\" changed to {1}+",
zone.Name,
minRank.ClassyName);
changesWereMade = true;
}
}
else
{
player.MessageNoRank(name);
}
}
if (changesWereMade)
{
zone.Edit(player.Info);
}
else
{
player.Message("No changes were made to the zone.");
}
}
}
static void WorldLoadHandler(Player player, Command cmd)
{
string fileName = cmd.Next();
string worldName = cmd.Next();
if (worldName == null && player.World == null)
{
player.Message("When using /WLoad from console, you must specify the world name.");
return;
}
if (fileName == null)
{
// No params given at all
CdWorldLoad.PrintUsage(player);
return;
}
string fullFileName = WorldManager.FindMapFile(player, fileName);
if (fullFileName == null) return;
// Loading map into current world
if (worldName == null)
{
if (!cmd.IsConfirmed)
{
player.Confirm(cmd, "Replace THIS MAP with \"{0}\"?", fileName);
return;
}
Map map;
try
{
map = MapUtility.Load(fullFileName);
}
catch (Exception ex)
{
player.MessageNow("Could not load specified file: {0}: {1}", ex.GetType().Name, ex.Message);
return;
}
World world = player.World;
// Loading to current world
world.MapChangedBy = player.Name;
world.ChangeMap(map);
world.Players.Message(player, "{0}&S loaded a new map for this world.",
player.ClassyName);
player.MessageNow("New map loaded for the world {0}", world.ClassyName);
Logger.Log(LogType.UserActivity,
"{0} loaded new map for world \"{1}\" from {2}",
player.Name, world.Name, fileName);
}
else
{
// Loading to some other (or new) world
if (!World.IsValidName(worldName))
{
player.MessageInvalidWorldName(worldName);
return;
}
string buildRankName = cmd.Next();
string accessRankName = cmd.Next();
Rank buildRank = RankManager.DefaultBuildRank;
Rank accessRank = null;
if (buildRankName != null)
{
buildRank = RankManager.FindRank(buildRankName);
if (buildRank == null)
{
player.MessageNoRank(buildRankName);
return;
}
if (accessRankName != null)
{
accessRank = RankManager.FindRank(accessRankName);
if (accessRank == null)
{
player.MessageNoRank(accessRankName);
return;
}
}
}
// Retype world name, if needed
if (worldName == "-")
{
if (player.LastUsedWorldName != null)
{
worldName = player.LastUsedWorldName;
}
else
{
player.Message("Cannot repeat world name: you haven't used any names yet.");
return;
}
}
lock (WorldManager.SyncRoot)
{
World world = WorldManager.FindWorldExact(worldName);
if (world != null)
{
player.LastUsedWorldName = world.Name;
// Replacing existing world's map
if (!cmd.IsConfirmed)
{
player.Confirm(cmd, "Replace map for {0}&S with \"{1}\"?",
world.ClassyName, fileName);
return;
}
Map map;
try
{
map = MapUtility.Load(fullFileName);
}
catch (Exception ex)
{
player.MessageNow("Could not load specified file: {0}: {1}", ex.GetType().Name, ex.Message);
return;
}
try
{
world.MapChangedBy = player.Name;
world.ChangeMap(map);
}
catch (WorldOpException ex)
{
Logger.Log(LogType.Error,
"Could not complete WorldLoad operation: {0}", ex.Message);
player.Message("&WWLoad: {0}", ex.Message);
return;
}
world.Players.Message(player, "{0}&S loaded a new map for the world {1}",
player.ClassyName, world.ClassyName);
player.MessageNow("New map for the world {0}&S has been loaded.", world.ClassyName);
Logger.Log(LogType.UserActivity,
"{0} loaded new map for world \"{1}\" from {2}",
player.Name, world.Name, fullFileName);
}
else
{
// Adding a new world
string targetFullFileName = Path.Combine(Paths.MapPath, worldName + ".fcm");
if (!cmd.IsConfirmed &&
File.Exists(targetFullFileName) && // target file already exists
!Paths.Compare(targetFullFileName, fullFileName))
{
// and is different from sourceFile
player.Confirm(cmd,
"A map named \"{0}\" already exists, and will be overwritten with \"{1}\".",
Path.GetFileName(targetFullFileName), Path.GetFileName(fullFileName));
return;
}
Map map;
try
{
map = MapUtility.Load(fullFileName);
}
catch (Exception ex)
{
player.MessageNow("Could not load \"{0}\": {1}: {2}",
fileName, ex.GetType().Name, ex.Message);
return;
}
World newWorld;
try
{
newWorld = WorldManager.AddWorld(player, worldName, map, false);
}
catch (WorldOpException ex)
{
player.Message("WLoad: {0}", ex.Message);
return;
}
if (newWorld == null)
{
player.MessageNow("Failed to create a new world.");
return;
}
player.LastUsedWorldName = worldName;
newWorld.BuildSecurity.MinRank = buildRank;
if (accessRank == null)
{
newWorld.AccessSecurity.ResetMinRank();
}
else
{
newWorld.AccessSecurity.MinRank = accessRank;
}
newWorld.BlockDB.AutoToggleIfNeeded();
if (BlockDB.IsEnabledGlobally && newWorld.BlockDB.IsEnabled)
{
player.Message("BlockDB is now auto-enabled on world {0}", newWorld.ClassyName);
}
newWorld.LoadedBy = player.Name;
newWorld.LoadedOn = DateTime.UtcNow;
Server.Message("{0}&S created a new world named {1}",
player.ClassyName, newWorld.ClassyName);
Logger.Log(LogType.UserActivity,
"{0} created a new world named \"{1}\" (loaded from \"{2}\")",
player.Name, worldName, fileName);
WorldManager.SaveWorldList();
player.MessageNow("Access permission is {0}+&S, and build permission is {1}+",
newWorld.AccessSecurity.MinRank.ClassyName,
newWorld.BuildSecurity.MinRank.ClassyName);
}
}
}
Server.RequestGC();
}
static void MassRankHandler( Player player, CommandReader cmd ) {
string fromRankName = cmd.Next();
string toRankName = cmd.Next();
string reason = cmd.NextAll();
if( fromRankName == null || toRankName == null ) {
CdMassRank.PrintUsage( player );
return;
}
Rank fromRank = RankManager.FindRank( fromRankName );
if( fromRank == null ) {
player.MessageNoRank( fromRankName );
return;
}
Rank toRank = RankManager.FindRank( toRankName );
if( toRank == null ) {
player.MessageNoRank( toRankName );
return;
}
if( fromRank == toRank ) {
player.Message( "Ranks must be different" );
return;
}
int playerCount = fromRank.PlayerCount;
string verb = (fromRank > toRank ? "demot" : "promot");
if( !cmd.IsConfirmed ) {
Logger.Log( LogType.UserActivity,
"MassRank: Asked {0} to confirm {1}ion of {2} players.",
player.Name, verb, playerCount );
player.Confirm( cmd, "{0}e {1} players?", verb.UppercaseFirst(), playerCount );
return;
}
player.Message( "MassRank: {0}ing {1} players...",
verb, playerCount );
int affected = PlayerDB.MassRankChange( player, fromRank, toRank, reason );
player.Message( "MassRank: done, {0} records affected.", affected );
}
static void WorldsHandler(Player player, Command cmd)
{
string param = cmd.Next();
World[] worlds;
string listName;
string extraParam;
int offset = 0;
if (param == null || Int32.TryParse(param, out offset))
{
listName = "available worlds";
extraParam = "";
worlds = WorldManager.Worlds.Where(w => !w.IsRealm).Where(player.CanSee).ToArray();
}
else
{
switch (Char.ToLower(param[0]))
{
case 'a':
listName = "worlds";
extraParam = "all ";
worlds = WorldManager.Worlds;
break;
case 'h':
listName = "hidden worlds";
extraParam = "hidden ";
worlds = WorldManager.Worlds.Where(w => !player.CanSee(w)).ToArray();
break;
case 'r':
listName = "Available Realms";
extraParam = "realms";
worlds = WorldManager.Worlds.Where(w => w.IsRealm).ToArray();
break;
case 'p':
listName = "populated worlds";
extraParam = "populated ";
worlds = WorldManager.Worlds.Where(w => w.Players.Any(player.CanSee)).ToArray();
break;
case '@':
if (param.Length == 1)
{
CdWorlds.PrintUsage(player);
return;
}
string rankName = param.Substring(1);
Rank rank = RankManager.FindRank(rankName);
if (rank == null)
{
player.MessageNoRank(rankName);
return;
}
listName = String.Format("worlds where {0}&S+ can build", rank.ClassyName);
extraParam = "@" + rank.Name + " ";
worlds = WorldManager.Worlds.Where(w => (w.BuildSecurity.MinRank <= rank) && player.CanSee(w))
.ToArray();
break;
default:
CdWorlds.PrintUsage(player);
return;
}
if (cmd.HasNext && !cmd.NextInt(out offset))
{
CdWorlds.PrintUsage(player);
return;
}
}
if (worlds.Length == 0)
{
player.Message("There are no {0}.", listName);
}
else if (worlds.Length <= WorldNamesPerPage || player.IsSuper)
{
player.MessagePrefixed("&S ", "&SThere are {0} {1}: {2}",
worlds.Length, listName, worlds.JoinToClassyString());
}
else
{
if (offset >= worlds.Length)
{
offset = Math.Max(0, worlds.Length - WorldNamesPerPage);
}
World[] worldsPart = worlds.Skip(offset).Take(WorldNamesPerPage).ToArray();
player.MessagePrefixed("&S ", "&S{0}: {1}",
listName.UppercaseFirst(), worldsPart.JoinToClassyString());
if (offset + worldsPart.Length < worlds.Length)
{
player.Message("Showing {0}-{1} (out of {2}). Next: &H/Worlds {3}{1}",
offset + 1, offset + worldsPart.Length, worlds.Length, extraParam);
}
else
{
player.Message("Showing worlds {0}-{1} (out of {2}).",
offset + 1, offset + worldsPart.Length, worlds.Length);
}
}
}
static void ZoneEditHandler( Player player, CommandReader cmd ) {
World playerWorld = player.World;
if( playerWorld == null ) PlayerOpException.ThrowNoWorld( player );
bool changesWereMade = false;
string zoneName = cmd.Next();
if( zoneName == null ) {
player.Message( "No zone name specified. See &H/Help ZEdit" );
return;
}
Zone zone = player.WorldMap.Zones.Find( zoneName );
if( zone == null ) {
player.MessageNoZone( zoneName );
return;
}
string nextToken;
while( (nextToken = cmd.Next()) != null ) {
// Clear whitelist
if( nextToken.Equals( "-*" ) ) {
PlayerInfo[] oldWhitelist = zone.Controller.ExceptionList.Included;
if( oldWhitelist.Length > 0 ) {
zone.Controller.ResetIncludedList();
player.Message( "Whitelist of zone {0}&S cleared: {1}",
zone.ClassyName, oldWhitelist.JoinToClassyString() );
Logger.Log( LogType.UserActivity,
"Player {0} cleared whitelist of zone {1} on world {2}: {3}",
player.Name, zone.Name, playerWorld.Name,
oldWhitelist.JoinToString( pi => pi.Name ) );
} else {
player.Message( "Whitelist of zone {0}&S is empty.",
zone.ClassyName );
}
continue;
}
// Clear blacklist
if( nextToken.Equals( "+*" ) ) {
PlayerInfo[] oldBlacklist = zone.Controller.ExceptionList.Excluded;
if( oldBlacklist.Length > 0 ) {
zone.Controller.ResetExcludedList();
player.Message( "Blacklist of zone {0}&S cleared: {1}",
zone.ClassyName, oldBlacklist.JoinToClassyString() );
Logger.Log( LogType.UserActivity,
"Player {0} cleared blacklist of zone {1} on world {2}: {3}",
player.Name, zone.Name, playerWorld.Name,
oldBlacklist.JoinToString( pi => pi.Name ) );
} else {
player.Message( "Blacklist of zone {0}&S is empty.",
zone.ClassyName );
}
continue;
}
if( nextToken.StartsWith( "+" ) ) {
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches( player, nextToken.Substring( 1 ), SearchOptions.IncludeSelf );
if( info == null ) return;
// prevent players from whitelisting themselves to bypass protection
if( !player.Info.Rank.AllowSecurityCircumvention && player.Info == info ) {
switch( zone.Controller.CheckDetailed( info ) ) {
case SecurityCheckResult.BlackListed:
player.Message( "You are not allowed to remove yourself from the blacklist of zone {0}",
zone.ClassyName );
continue;
case SecurityCheckResult.RankTooLow:
player.Message( "You must be {0}+&S to add yourself to the whitelist of zone {1}",
zone.Controller.MinRank.ClassyName, zone.ClassyName );
continue;
}
}
switch( zone.Controller.Include( info ) ) {
case PermissionOverride.Deny:
player.Message( "{0}&S is no longer excluded from zone {1}",
info.ClassyName, zone.ClassyName );
changesWereMade = true;
break;
case PermissionOverride.None:
player.Message( "{0}&S is now included in zone {1}",
info.ClassyName, zone.ClassyName );
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message( "{0}&S is already included in zone {1}",
info.ClassyName, zone.ClassyName );
break;
}
} else if( nextToken.StartsWith( "-" ) ) {
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches( player, nextToken.Substring( 1 ), SearchOptions.IncludeSelf );
if( info == null ) return;
switch( zone.Controller.Exclude( info ) ) {
case PermissionOverride.Deny:
player.Message( "{0}&S is already excluded from zone {1}",
info.ClassyName, zone.ClassyName );
break;
case PermissionOverride.None:
player.Message( "{0}&S is now excluded from zone {1}",
info.ClassyName, zone.ClassyName );
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message( "{0}&S is no longer included in zone {1}",
info.ClassyName, zone.ClassyName );
changesWereMade = true;
break;
}
} else {
Rank minRank = RankManager.FindRank( nextToken );
if( minRank != null ) {
// prevent players from lowering rank so bypass protection
if( !player.Info.Rank.AllowSecurityCircumvention &&
zone.Controller.MinRank > player.Info.Rank && minRank <= player.Info.Rank ) {
player.Message( "You are not allowed to lower the zone's rank." );
continue;
}
if( zone.Controller.MinRank != minRank ) {
zone.Controller.MinRank = minRank;
player.Message( "Permission for zone \"{0}\" changed to {1}+",
zone.Name,
minRank.ClassyName );
changesWereMade = true;
}
} else {
player.MessageNoRank( nextToken );
}
}
if( changesWereMade ) {
zone.OnEdited( player.Info.Name );
} else {
player.Message( "No changes were made to the zone." );
}
}
}
internal static void RealmAccess(Player player, Command cmd, string worldName, string name)
{
// Print information about the current realm
if (worldName == null)
{
if (player.World == null)
{
player.Message("Error.");
}
else
{
player.Message(player.World.AccessSecurity.GetDescription(player.World, "realm", "accessed"));
}
return;
}
// Find a realm by name
World realm = WorldManager.FindWorldOrPrintMatches(player, worldName);
if (realm == null)
{
return;
}
if (name == null)
{
player.Message(realm.AccessSecurity.GetDescription(realm, "realm", "accessed"));
return;
}
if (realm == WorldManager.MainWorld)
{
player.Message("The main realm cannot have access restrictions.");
return;
}
bool changesWereMade = false;
do
{
if (name.Length < 2)
{
continue;
}
// Whitelisting individuals
if (name.StartsWith("+"))
{
PlayerInfo info;
if (!PlayerDB.FindPlayerInfo(name.Substring(1), out info))
{
player.Message("More than one player found matching \"{0}\"", name.Substring(1));
continue;
}
else if (info == null)
{
player.MessageNoPlayer(name.Substring(1));
continue;
}
// prevent players from whitelisting themselves to bypass protection
if (realm.AccessSecurity.CheckDetailed(info) == SecurityCheckResult.Allowed)
{
player.Message("{0}&S is already allowed to access {1}&S (by rank)",
info.ClassyName, realm.ClassyName);
continue;
}
Player target = info.PlayerObject;
if (target == player)
{
target = null; // to avoid duplicate messages
}
switch (realm.AccessSecurity.Include(info))
{
case PermissionOverride.Deny:
if (realm.AccessSecurity.Check(info))
{
player.Message("{0}&S is unbanned from Realm {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You are now unbanned from Realm {0}&S (removed from blacklist by {1}&S).",
realm.ClassyName, player.ClassyName);
}
}
else
{
player.Message("{0}&S was unbanned from Realm {1}&S. " +
"Player is still NOT allowed to join (by rank).",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You were Unbanned from Realm {0}&S by {1}&S. " +
"You are still NOT allowed to join (by rank).",
player.ClassyName, realm.ClassyName);
}
}
Logger.Log(LogType.UserActivity, "{0} removed {1} from the access blacklist of {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.None:
player.Message("{0}&S is now allowed to access {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You can now access realm {0}&S (whitelisted by {1}&S).",
realm.ClassyName, player.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} added {1} to the access whitelist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message("{0}&S is already on the access whitelist of {1}",
info.ClassyName, realm.ClassyName);
break;
}
// Blacklisting individuals
}
else if (name.StartsWith("-"))
{
PlayerInfo info;
if (!PlayerDB.FindPlayerInfo(name.Substring(1), out info))
{
player.Message("More than one player found matching \"{0}\"", name.Substring(1));
continue;
}
else if (info == null)
{
player.MessageNoPlayer(name.Substring(1));
continue;
}
if (realm.AccessSecurity.CheckDetailed(info) == SecurityCheckResult.RankTooHigh ||
realm.AccessSecurity.CheckDetailed(info) == SecurityCheckResult.RankTooLow)
{
player.Message("{0}&S is already barred from accessing {1}&S (by rank)",
info.ClassyName, realm.ClassyName);
continue;
}
Player target = info.PlayerObject;
if (target == player)
{
target = null; // to avoid duplicate messages
}
switch (realm.AccessSecurity.Exclude(info))
{
case PermissionOverride.Deny:
player.Message("{0}&S is already banned from Realm {1}",
info.ClassyName, realm.ClassyName);
break;
case PermissionOverride.None:
player.Message("{0}&S is now banned from accessing {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("&WYou were banned by {0}&W from accessing realm {1}",
player.ClassyName, realm.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} added {1} to the access blacklist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.Allow:
if (realm.AccessSecurity.Check(info))
{
player.Message("{0}&S is no longer on the access whitelist of {1}&S. " +
"Player is still allowed to join (by rank).",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You were banned from Realm {0}&S by {1}&S. " +
"You are still allowed to join (by rank).",
player.ClassyName, realm.ClassyName);
}
}
else
{
player.Message("{0}&S is no longer allowed to access {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("&WYou were banned from Realm {0}&W (Banned by {1}&W).",
realm.ClassyName, player.ClassyName);
}
}
Logger.Log(LogType.UserActivity, "{0} removed {1} from the access whitelist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
}
// Setting minimum rank
}
else
{
Rank rank = RankManager.FindRank(name);
if (rank == null)
{
player.MessageNoRank(name);
}
else
{
// list players who are redundantly blacklisted
var exceptionList = realm.AccessSecurity.ExceptionList;
PlayerInfo[] noLongerExcluded = exceptionList.Excluded.Where(excludedPlayer => excludedPlayer.Rank < rank).ToArray();
if (noLongerExcluded.Length > 0)
{
player.Message("Following players no longer need to be blacklisted to be barred from {0}&S: {1}",
realm.ClassyName,
noLongerExcluded.JoinToClassyString());
}
// list players who are redundantly whitelisted
PlayerInfo[] noLongerIncluded = exceptionList.Included.Where(includedPlayer => includedPlayer.Rank >= rank).ToArray();
if (noLongerIncluded.Length > 0)
{
player.Message("Following players no longer need to be whitelisted to access {0}&S: {1}",
realm.ClassyName,
noLongerIncluded.JoinToClassyString());
}
// apply changes
realm.AccessSecurity.MinRank = rank;
changesWereMade = true;
if (realm.AccessSecurity.MinRank == RankManager.LowestRank)
{
Server.Message("{0}&S made the realm {1}&S accessible to everyone.",
player.ClassyName, realm.ClassyName);
}
else
{
Server.Message("{0}&S made the realm {1}&S accessible only by {2}+",
player.ClassyName, realm.ClassyName,
realm.AccessSecurity.MinRank.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} set access rank for realm {1} to {2}+",
player.Name, realm.Name, realm.AccessSecurity.MinRank.Name);
}
}
} while ((name = cmd.Next()) != null);
if (changesWereMade)
{
var playersWhoCantStay = realm.Players.Where(p => !p.CanJoin(realm));
foreach (Player p in playersWhoCantStay)
{
p.Message("&WYou are no longer allowed to join realm {0}", realm.ClassyName);
p.JoinWorld(WorldManager.MainWorld, WorldChangeReason.PermissionChanged);
}
WorldManager.SaveWorldList();
}
}
static void MaxCapsHandler(Player player, CommandReader cmd)
{
string rname = cmd.Next();
string rmax = cmd.Next();
Rank prank = player.Info.Rank;
if (player.Info.Rank.Can(Permission.ShutdownServer))
{
if (rname == null)
{
if (prank.MaxCaps != 0 && prank.MaxCaps != 1)
{
player.Message("Rank ({0}&s) has a max of {1} uppercase letters/message.", prank.ClassyName, prank.MaxCaps);
return;
}
else if (prank.MaxCaps == 0)
{
player.Message("Rank ({0}&s) has no max.", prank.ClassyName);
return;
}
else if (prank.MaxCaps == 1)
{
player.Message("Rank ({0}&s) has a max of (RawMessage.Length / 2) uppercase letters/message.", prank.ClassyName);
return;
}
}
Rank rank = RankManager.FindRank(rname);
if (rank == null)
{
player.MessageNoRank(rname);
return;
}
if (rmax == null)
{
if (rank.MaxCaps != 0 && rank.MaxCaps != 1)
{
player.Message("Rank ({0}&s) has a max of {1} uppercase letters/message.", rank.ClassyName, rank.MaxCaps);
return;
}
else if (rank.MaxCaps == 0)
{
player.Message("Rank ({0}&s) has no max.", rank.ClassyName);
return;
}
else if (rank.MaxCaps == 1)
{
player.Message("Rank ({0}&s) has a max of (RawMessage.Length / 2) uppercase letters/message.", rank.ClassyName);
return;
}
}
int mcaps;
if (!int.TryParse(rmax, out mcaps))
{
player.Message(CdMaxCaps.Usage);
return;
}
if (rank != null)
{
rank.MaxCaps = mcaps;
player.Message("Set MaxCaps for rank ({0}&s) to {1} uppercase letters/message.", rank.ClassyName, rank.MaxCaps);
return;
}
}
else
{
if (prank.MaxCaps != 0 && prank.MaxCaps != 1)
{
player.Message("Rank ({0}&s) has a max of {1} uppercase letters/message.", prank.ClassyName, prank.MaxCaps);
return;
}
else if (prank.MaxCaps == 0)
{
player.Message("Rank ({0}&s) has no max.", prank.ClassyName);
return;
}
else if (prank.MaxCaps == 1)
{
player.Message("Rank ({0}&s) has a max of (RawMessage.Length / 2) uppercase letters/message.", prank.ClassyName);
return;
}
return;
}
}
static void ZoneAddHandler( Player player, Command cmd )
{
World playerWorld = player.World;
if( playerWorld == null ) PlayerOpException.ThrowNoWorld( player );
string givenZoneName = cmd.Next();
if( givenZoneName == null ) {
CdZoneAdd.PrintUsage( player );
return;
}
if (givenZoneName.EndsWith("door"))
{
player.Message("&SA Zone name cannot end with 'door'");
return;
}
if( !player.Info.Rank.AllowSecurityCircumvention ) {
SecurityCheckResult buildCheck = playerWorld.BuildSecurity.CheckDetailed( player.Info );
switch( buildCheck ) {
case SecurityCheckResult.BlackListed:
player.Message( "Cannot add zones to world {0}&S: You are barred from building here.",
playerWorld.ClassyName );
return;
case SecurityCheckResult.RankTooLow:
player.Message( "Cannot add zones to world {0}&S: You are not allowed to build here.",
playerWorld.ClassyName );
return;
//case SecurityCheckResult.RankTooHigh:
}
}
Zone newZone = new Zone();
ZoneCollection zoneCollection = player.WorldMap.Zones;
if( givenZoneName.StartsWith( "+" ) ) {
// personal zone (/ZAdd +Name)
givenZoneName = givenZoneName.Substring( 1 );
// Find the target player
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches( player, givenZoneName );
if( info == null ) return;
// Make sure that the name is not taken already.
// If a zone named after the player already exists, try adding a number after the name (e.g. "Notch2")
newZone.Name = info.Name;
for( int i = 2; zoneCollection.Contains( newZone.Name ); i++ ) {
newZone.Name = givenZoneName + i;
}
newZone.Controller.MinRank = info.Rank.NextRankUp ?? info.Rank;
newZone.Controller.Include( info );
player.Message( "Zone: Creating a {0}+&S zone for player {1}&S. Place a block or type /Mark to use your location.",
newZone.Controller.MinRank.ClassyName, info.ClassyName );
player.SelectionStart( 2, ZoneAddCallback, newZone, CdZoneAdd.Permissions );
} else {
// Adding an ordinary, rank-restricted zone.
if( !World.IsValidName( givenZoneName ) ) {
player.Message( "\"{0}\" is not a valid zone name", givenZoneName );
return;
}
if( zoneCollection.Contains( givenZoneName ) ) {
player.Message( "A zone with this name already exists. Use &H/ZEdit&S to edit." );
return;
}
newZone.Name = givenZoneName;
string rankName = cmd.Next();
if( rankName == null ) {
player.Message( "No rank was specified. See &H/Help zone" );
return;
}
Rank minRank = RankManager.FindRank( rankName );
if( minRank != null ) {
string name;
while( (name = cmd.Next()) != null ) {
if( name.Length == 0 ) continue;
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches( player, name.Substring( 1 ) );
if( info == null ) return;
if( name.StartsWith( "+" ) ) {
newZone.Controller.Include( info );
} else if( name.StartsWith( "-" ) ) {
newZone.Controller.Exclude( info );
}
}
newZone.Controller.MinRank = minRank;
player.SelectionStart( 2, ZoneAddCallback, newZone, CdZoneAdd.Permissions );
player.Message( "Zone: Place a block or type &H/Mark&S to use your location." );
} else {
player.MessageNoRank( rankName );
}
}
}
static void ZoneEditHandler(Player player, CommandReader cmd)
{
if (player.World == null)
{
PlayerOpException.ThrowNoWorld(player);
}
bool changesWereMade = false;
string zoneName = cmd.Next();
if (zoneName == null)
{
player.Message("No zone name specified. See &H/Help ZEdit");
return;
}
Zone zone = player.WorldMap.Zones.Find(zoneName);
if (zone == null)
{
player.MessageNoZone(zoneName);
return;
}
string nextToken;
while ((nextToken = cmd.Next()) != null)
{
// Clear whitelist
if (nextToken.Equals("-*"))
{
PlayerInfo[] oldWhitelist = zone.Controller.ExceptionList.Included;
if (oldWhitelist.Length > 0)
{
zone.Controller.ResetIncludedList();
player.Message("Whitelist of zone {0}&S cleared: {1}",
zone.ClassyName, oldWhitelist.JoinToClassyString());
Logger.Log(LogType.UserActivity,
"Player {0} cleared whitelist of zone {1} on world {2}: {3}",
player.Name, zone.Name, player.World.Name,
oldWhitelist.JoinToString(pi => pi.Name));
}
else
{
player.Message("Whitelist of zone {0}&S is empty.",
zone.ClassyName);
}
continue;
}
// Clear blacklist
if (nextToken.Equals("+*"))
{
PlayerInfo[] oldBlacklist = zone.Controller.ExceptionList.Excluded;
if (oldBlacklist.Length > 0)
{
zone.Controller.ResetExcludedList();
player.Message("Blacklist of zone {0}&S cleared: {1}",
zone.ClassyName, oldBlacklist.JoinToClassyString());
Logger.Log(LogType.UserActivity,
"Player {0} cleared blacklist of zone {1} on world {2}: {3}",
player.Name, zone.Name, player.World.Name,
oldBlacklist.JoinToString(pi => pi.Name));
}
else
{
player.Message("Blacklist of zone {0}&S is empty.",
zone.ClassyName);
}
continue;
}
if (nextToken.StartsWith("+"))
{
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches(player, nextToken.Substring(1));
if (info == null)
{
return;
}
// prevent players from whitelisting themselves to bypass protection
if (!player.Info.Rank.AllowSecurityCircumvention && player.Info == info)
{
switch (zone.Controller.CheckDetailed(info))
{
case SecurityCheckResult.BlackListed:
player.Message("You are not allowed to remove yourself from the blacklist of zone {0}",
zone.ClassyName);
continue;
case SecurityCheckResult.RankTooLow:
player.Message("You must be {0}+&S to add yourself to the whitelist of zone {1}",
zone.Controller.MinRank.ClassyName, zone.ClassyName);
continue;
}
}
switch (zone.Controller.Include(info))
{
case PermissionOverride.Deny:
player.Message("{0}&S is no longer excluded from zone {1}",
info.ClassyName, zone.ClassyName);
changesWereMade = true;
break;
case PermissionOverride.None:
player.Message("{0}&S is now included in zone {1}",
info.ClassyName, zone.ClassyName);
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message("{0}&S is already included in zone {1}",
info.ClassyName, zone.ClassyName);
break;
}
}
else if (nextToken.StartsWith("-"))
{
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches(player, nextToken.Substring(1));
if (info == null)
{
return;
}
switch (zone.Controller.Exclude(info))
{
case PermissionOverride.Deny:
player.Message("{0}&S is already excluded from zone {1}",
info.ClassyName, zone.ClassyName);
break;
case PermissionOverride.None:
player.Message("{0}&S is now excluded from zone {1}",
info.ClassyName, zone.ClassyName);
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message("{0}&S is no longer included in zone {1}",
info.ClassyName, zone.ClassyName);
changesWereMade = true;
break;
}
}
else
{
Rank minRank = RankManager.FindRank(nextToken);
if (minRank != null)
{
// prevent players from lowering rank so bypass protection
if (!player.Info.Rank.AllowSecurityCircumvention &&
zone.Controller.MinRank > player.Info.Rank && minRank <= player.Info.Rank)
{
player.Message("You are not allowed to lower the zone's rank.");
continue;
}
if (zone.Controller.MinRank != minRank)
{
zone.Controller.MinRank = minRank;
player.Message("Permission for zone \"{0}\" changed to {1}+",
zone.Name,
minRank.ClassyName);
changesWereMade = true;
}
}
else
{
player.MessageNoRank(nextToken);
}
}
if (changesWereMade)
{
zone.Edit(player.Info);
}
else
{
player.Message("No changes were made to the zone.");
}
}
}
static void RankHandler( Player player, CommandReader cmd ) {
string name = cmd.Next();
string newRankName = cmd.Next();
// Check arguments
if( name == null || newRankName == null ) {
CdRank.PrintUsage( player );
player.Message( "See &H/Ranks&S for list of ranks." );
return;
}
// Parse rank name
Rank newRank = RankManager.FindRank( newRankName );
if( newRank == null ) {
player.MessageNoRank( newRankName );
return;
}
if( name == "-" ) {
if( player.LastUsedPlayerName != null ) {
name = player.LastUsedPlayerName;
} else {
player.Message( "Cannot repeat player name: you haven't used any names yet." );
return;
}
}
PlayerInfo targetInfo;
// Find player by name
if( name.StartsWith( "!" ) ) {
name = name.Substring( 1 );
Player target = Server.FindPlayerExact( player, name, false );
if( target == null ) {
player.MessageNoPlayer( name );
return;
}
targetInfo = target.Info;
} else {
targetInfo = PlayerDB.FindPlayerInfoExact( name );
}
// Handle non-existent players
if( targetInfo == null ) {
if( !player.Can( Permission.EditPlayerDB ) ) {
player.MessageNoPlayer( name );
return;
}
if( !Player.IsValidName( name ) ) {
player.MessageInvalidPlayerName( name );
CdRank.PrintUsage( player );
return;
}
if( cmd.IsConfirmed ) {
if( newRank > RankManager.DefaultRank ) {
targetInfo = PlayerDB.AddFakeEntry( name, RankChangeType.Promoted );
} else {
targetInfo = PlayerDB.AddFakeEntry( name, RankChangeType.Demoted );
}
} else {
Logger.Log( LogType.UserActivity,
"Rank: Asked {0} to confirm adding unrecognized name \"{1}\" to the database.",
player.Name, name );
player.Confirm( cmd,
"Warning: Player \"{0}\" is not in the database (possible typo). Type the full name or",
name );
return;
}
}
try {
player.LastUsedPlayerName = targetInfo.Name;
targetInfo.ChangeRank( player, newRank, cmd.NextAll(), true, true, false );
} catch( PlayerOpException ex ) {
player.Message( ex.MessageColored );
}
}
static void ZoneAddHandler(Player player, CommandReader cmd)
{
World playerWorld = player.World;
if (playerWorld == null)
{
PlayerOpException.ThrowNoWorld(player);
}
string givenZoneName = cmd.Next();
if (givenZoneName == null)
{
CdZoneAdd.PrintUsage(player);
return;
}
if (!player.Info.Rank.AllowSecurityCircumvention)
{
SecurityCheckResult buildCheck = playerWorld.BuildSecurity.CheckDetailed(player.Info);
switch (buildCheck)
{
case SecurityCheckResult.BlackListed:
player.Message("Cannot add zones to world {0}&S: You are barred from building here.",
playerWorld.ClassyName);
return;
case SecurityCheckResult.RankTooLow:
player.Message("Cannot add zones to world {0}&S: You are not allowed to build here.",
playerWorld.ClassyName);
return;
}
}
Zone newZone = new Zone();
ZoneCollection zoneCollection = player.WorldMap.Zones;
if (givenZoneName.StartsWith("+"))
{
// personal zone (/ZAdd +Name)
givenZoneName = givenZoneName.Substring(1);
// Find the target player
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches(player, givenZoneName);
if (info == null)
{
return;
}
// Make sure that the name is not taken already.
// If a zone named after the player already exists, try adding a number after the name (e.g. "Notch2")
newZone.Name = info.Name;
for (int i = 2; zoneCollection.Contains(newZone.Name); i++)
{
newZone.Name = givenZoneName + i;
}
newZone.Controller.MinRank = info.Rank.NextRankUp ?? info.Rank;
newZone.Controller.Include(info);
player.Message("ZoneAdd: Creating a {0}+&S zone for player {1}&S. Click or &H/Mark&S 2 blocks.",
newZone.Controller.MinRank.ClassyName, info.ClassyName);
player.SelectionStart(2, ZoneAddCallback, newZone, CdZoneAdd.Permissions);
}
else
{
// Adding an ordinary, rank-restricted zone.
if (!World.IsValidName(givenZoneName))
{
player.Message("\"{0}\" is not a valid zone name", givenZoneName);
return;
}
if (zoneCollection.Contains(givenZoneName))
{
player.Message("A zone with this name already exists. Use &H/ZEdit&S to edit.");
return;
}
newZone.Name = givenZoneName;
string rankName = cmd.Next();
if (rankName == null)
{
player.Message("No rank was specified. See &H/Help zone");
return;
}
Rank minRank = RankManager.FindRank(rankName);
if (minRank == null)
{
player.MessageNoRank(rankName);
return;
}
string name;
while ((name = cmd.Next()) != null)
{
if (name.Length < 1)
{
CdZoneAdd.PrintUsage(player);
return;
}
PlayerInfo info = PlayerDB.FindPlayerInfoOrPrintMatches(player, name.Substring(1));
if (info == null)
{
return;
}
if (name.StartsWith("+"))
{
newZone.Controller.Include(info);
}
else if (name.StartsWith("-"))
{
newZone.Controller.Exclude(info);
}
}
newZone.Controller.MinRank = minRank;
player.SelectionStart(2, ZoneAddCallback, newZone, CdZoneAdd.Permissions);
player.Message("ZoneAdd: Creating zone {0}&S. Click or &H/Mark&S 2 blocks.",
newZone.ClassyName);
}
}
static void CommandsHandler( Player player, CommandReader cmd ) {
string param = cmd.Next();
if( cmd.HasNext ) {
CdCommands.PrintUsage( player );
return;
}
CommandDescriptor[] cd;
CommandCategory category;
string prefix;
if( param == null ) {
prefix = "Available commands";
cd = CommandManager.GetCommands( player.Info.Rank, false );
} else if( param.StartsWith( "@" ) ) {
string rankName = param.Substring( 1 );
Rank rank = RankManager.FindRank( rankName );
if( rank == null ) {
player.MessageNoRank( rankName );
return;
} else {
prefix = String.Format( "Commands available to {0}&S", rank.ClassyName );
cd = CommandManager.GetCommands( rank, false );
}
} else if( param.Equals( "all", StringComparison.OrdinalIgnoreCase ) ) {
prefix = "All commands";
cd = CommandManager.GetCommands();
} else if( param.Equals( "hidden", StringComparison.OrdinalIgnoreCase ) ) {
prefix = "Hidden commands";
cd = CommandManager.GetCommands( true );
} else if( EnumUtil.TryParse( param, out category, true ) ) {
prefix = String.Format( "{0} commands", category );
cd = CommandManager.GetCommands( category, false );
} else {
CdCommands.PrintUsage( player );
return;
}
player.MessagePrefixed( "&S ", "{0}: {1}", prefix, cd.JoinToClassyString() );
}
internal static void RealmAccess(Player player, Command cmd, string worldName, string name)
{
// Print information about the current realm
if (worldName == null)
{
if (player.World == null)
{
player.Message("Error.");
}
else
{
player.Message(player.World.AccessSecurity.GetDescription(player.World, "realm", "accessed"));
}
return;
}
// Find a realm by name
World realm = WorldManager.FindWorldOrPrintMatches(player, worldName);
if (realm == null) return;
if (name == null)
{
player.Message(realm.AccessSecurity.GetDescription(realm, "realm", "accessed"));
return;
}
if (realm == WorldManager.MainWorld)
{
player.Message("The main realm cannot have access restrictions.");
return;
}
bool changesWereMade = false;
do
{
if (name.Length < 2) continue;
// Whitelisting individuals
if (name.StartsWith("+"))
{
PlayerInfo info;
if (!PlayerDB.FindPlayerInfo(name.Substring(1), out info))
{
player.Message("More than one player found matching \"{0}\"", name.Substring(1));
continue;
}
else if (info == null)
{
player.MessageNoPlayer(name.Substring(1));
continue;
}
// prevent players from whitelisting themselves to bypass protection
if (realm.AccessSecurity.CheckDetailed(info) == SecurityCheckResult.Allowed)
{
player.Message("{0}&S is already allowed to access {1}&S (by rank)",
info.ClassyName, realm.ClassyName);
continue;
}
Player target = info.PlayerObject;
if (target == player) target = null; // to avoid duplicate messages
switch (realm.AccessSecurity.Include(info))
{
case PermissionOverride.Deny:
if (realm.AccessSecurity.Check(info))
{
player.Message("{0}&S is unbanned from Realm {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You are now unbanned from Realm {0}&S (removed from blacklist by {1}&S).",
realm.ClassyName, player.ClassyName);
}
}
else
{
player.Message("{0}&S was unbanned from Realm {1}&S. " +
"Player is still NOT allowed to join (by rank).",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You were Unbanned from Realm {0}&S by {1}&S. " +
"You are still NOT allowed to join (by rank).",
player.ClassyName, realm.ClassyName);
}
}
Logger.Log(LogType.UserActivity, "{0} removed {1} from the access blacklist of {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.None:
player.Message("{0}&S is now allowed to access {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You can now access realm {0}&S (whitelisted by {1}&S).",
realm.ClassyName, player.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} added {1} to the access whitelist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.Allow:
player.Message("{0}&S is already on the access whitelist of {1}",
info.ClassyName, realm.ClassyName);
break;
}
// Blacklisting individuals
}
else if (name.StartsWith("-"))
{
PlayerInfo info;
if (!PlayerDB.FindPlayerInfo(name.Substring(1), out info))
{
player.Message("More than one player found matching \"{0}\"", name.Substring(1));
continue;
}
else if (info == null)
{
player.MessageNoPlayer(name.Substring(1));
continue;
}
if (realm.AccessSecurity.CheckDetailed(info) == SecurityCheckResult.RankTooHigh ||
realm.AccessSecurity.CheckDetailed(info) == SecurityCheckResult.RankTooLow)
{
player.Message("{0}&S is already barred from accessing {1}&S (by rank)",
info.ClassyName, realm.ClassyName);
continue;
}
Player target = info.PlayerObject;
if (target == player) target = null; // to avoid duplicate messages
switch (realm.AccessSecurity.Exclude(info))
{
case PermissionOverride.Deny:
player.Message("{0}&S is already banned from Realm {1}",
info.ClassyName, realm.ClassyName);
break;
case PermissionOverride.None:
player.Message("{0}&S is now banned from accessing {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("&WYou were banned by {0}&W from accessing realm {1}",
player.ClassyName, realm.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} added {1} to the access blacklist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.Allow:
if (realm.AccessSecurity.Check(info))
{
player.Message("{0}&S is no longer on the access whitelist of {1}&S. " +
"Player is still allowed to join (by rank).",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You were banned from Realm {0}&S by {1}&S. " +
"You are still allowed to join (by rank).",
player.ClassyName, realm.ClassyName);
}
}
else
{
player.Message("{0}&S is no longer allowed to access {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("&WYou were banned from Realm {0}&W (Banned by {1}&W).",
realm.ClassyName, player.ClassyName);
}
}
Logger.Log(LogType.UserActivity, "{0} removed {1} from the access whitelist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
}
// Setting minimum rank
}
else
{
Rank rank = RankManager.FindRank(name);
if (rank == null)
{
player.MessageNoRank(name);
}
else
{
// list players who are redundantly blacklisted
var exceptionList = realm.AccessSecurity.ExceptionList;
PlayerInfo[] noLongerExcluded = exceptionList.Excluded.Where(excludedPlayer => excludedPlayer.Rank < rank).ToArray();
if (noLongerExcluded.Length > 0)
{
player.Message("Following players no longer need to be blacklisted to be barred from {0}&S: {1}",
realm.ClassyName,
noLongerExcluded.JoinToClassyString());
}
// list players who are redundantly whitelisted
PlayerInfo[] noLongerIncluded = exceptionList.Included.Where(includedPlayer => includedPlayer.Rank >= rank).ToArray();
if (noLongerIncluded.Length > 0)
{
player.Message("Following players no longer need to be whitelisted to access {0}&S: {1}",
realm.ClassyName,
noLongerIncluded.JoinToClassyString());
}
// apply changes
realm.AccessSecurity.MinRank = rank;
changesWereMade = true;
if (realm.AccessSecurity.MinRank == RankManager.LowestRank)
{
Server.Message("{0}&S made the realm {1}&S accessible to everyone.",
player.ClassyName, realm.ClassyName);
}
else
{
Server.Message("{0}&S made the realm {1}&S accessible only by {2}+",
player.ClassyName, realm.ClassyName,
realm.AccessSecurity.MinRank.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} set access rank for realm {1} to {2}+",
player.Name, realm.Name, realm.AccessSecurity.MinRank.Name);
}
}
} while ((name = cmd.Next()) != null);
if (changesWereMade)
{
var playersWhoCantStay = realm.Players.Where(p => !p.CanJoin(realm));
foreach (Player p in playersWhoCantStay)
{
p.Message("&WYou are no longer allowed to join realm {0}", realm.ClassyName);
p.JoinWorld(WorldManager.MainWorld, WorldChangeReason.PermissionChanged);
}
WorldManager.SaveWorldList();
}
}
static void InfoHandler( Player player, CommandReader cmd ) {
string name = cmd.Next();
if( name == null ) {
// no name given, print own info
PrintPlayerInfo( player, player.Info );
return;
} else if( name.Equals( player.Name, StringComparison.OrdinalIgnoreCase ) ) {
// own name given
player.LastUsedPlayerName = player.Name;
PrintPlayerInfo( player, player.Info );
return;
} else if( !player.Can( Permission.ViewOthersInfo ) ) {
// someone else's name or IP given, permission required.
player.MessageNoAccess( Permission.ViewOthersInfo );
return;
}
// repeat last-typed name
if( name == "-" ) {
if( player.LastUsedPlayerName != null ) {
name = player.LastUsedPlayerName;
} else {
player.Message( "Cannot repeat player name: you haven't used any names yet." );
return;
}
}
PlayerInfo[] infos;
IPAddress ip;
if( name.Contains( "/" ) ) {
// IP range matching (CIDR notation)
string ipString = name.Substring( 0, name.IndexOf( '/' ) );
string rangeString = name.Substring( name.IndexOf( '/' ) + 1 );
byte range;
if( IPAddressUtil.IsIP( ipString ) && IPAddress.TryParse( ipString, out ip ) &&
Byte.TryParse( rangeString, out range ) && range <= 32 ) {
player.Message( "Searching {0}-{1}", ip.RangeMin( range ), ip.RangeMax( range ) );
infos = PlayerDB.FindPlayersCidr( ip, range );
} else {
player.Message( "Info: Invalid IP range format. Use CIDR notation." );
return;
}
} else if( IPAddressUtil.IsIP( name ) && IPAddress.TryParse( name, out ip ) ) {
// find players by IP
infos = PlayerDB.FindPlayers( ip );
} else if( name.Equals( "*" ) ) {
infos = (PlayerInfo[])PlayerDB.PlayerInfoList.Clone();
} else if( name.Contains( "*" ) || name.Contains( "?" ) ) {
// find players by regex/wildcard
string regexString = "^" + RegexNonNameChars.Replace( name, "" ).Replace( "*", ".*" ).Replace( "?", "." ) + "$";
Regex regex = new Regex( regexString, RegexOptions.IgnoreCase | RegexOptions.Compiled );
infos = PlayerDB.FindPlayers( regex );
} else if( name.StartsWith( "@" ) ) {
string rankName = name.Substring( 1 );
Rank rank = RankManager.FindRank( rankName );
if( rank == null ) {
player.MessageNoRank( rankName );
return;
} else {
infos = PlayerDB.PlayerInfoList
.Where( info => info.Rank == rank )
.ToArray();
}
} else if( name.StartsWith( "!" ) ) {
// find online players by partial matches
name = name.Substring( 1 );
infos = Server.FindPlayers( name, true )
.Select( p => p.Info )
.ToArray();
} else {
// find players by partial matching
PlayerInfo tempInfo;
if( !PlayerDB.FindPlayerInfo( name, out tempInfo ) ) {
infos = PlayerDB.FindPlayers( name );
} else if( tempInfo == null ) {
player.MessageNoPlayer( name );
return;
} else {
infos = new[] { tempInfo };
}
}
Array.Sort( infos, new PlayerInfoComparer( player ) );
if( infos.Length == 1 ) {
// only one match found; print it right away
player.LastUsedPlayerName = infos[0].Name;
PrintPlayerInfo( player, infos[0] );
} else if( infos.Length > 1 ) {
// multiple matches found
if( infos.Length <= PlayersPerPage ) {
// all fit to one page
player.MessageManyMatches( "player", infos );
} else {
// pagination
int offset;
if( !cmd.NextInt( out offset ) ) offset = 0;
if( offset >= infos.Length ) {
offset = Math.Max( 0, infos.Length - PlayersPerPage );
}
PlayerInfo[] infosPart = infos.Skip( offset ).Take( PlayersPerPage ).ToArray();
player.MessageManyMatches( "player", infosPart );
if( offset + infosPart.Length < infos.Length ) {
// normal page
player.Message( "Showing {0}-{1} (out of {2}). Next: &H/Info {3} {4}",
offset + 1, offset + infosPart.Length, infos.Length,
name, offset + infosPart.Length );
} else {
// last page
player.Message( "Showing matches {0}-{1} (out of {2}).",
offset + 1, offset + infosPart.Length, infos.Length );
}
}
} else {
// no matches found
player.MessageNoPlayer( name );
}
}
internal static void RealmBuild(Player player, Command cmd, string worldName, string name, string NameIfRankIsName)
{
// Print information about the current realm
if (worldName == null)
{
if (player.World == null)
{
player.Message("When calling /wbuild from console, you must specify a realm name.");
}
else
{
player.Message(player.World.BuildSecurity.GetDescription(player.World, "realm", "modified"));
}
return;
}
// Find a realm by name
World realm = WorldManager.FindWorldOrPrintMatches(player, worldName);
if (realm == null) return;
if (name == null)
{
player.Message(realm.BuildSecurity.GetDescription(realm, "realm", "modified"));
return;
}
bool changesWereMade = false;
do
{
if (name.Length < 2) continue;
// Whitelisting individuals
if (name.StartsWith("+"))
{
PlayerInfo info;
if (!PlayerDB.FindPlayerInfo(name.Substring(1), out info))
{
player.Message("More than one player found matching \"{0}\"", name.Substring(1));
continue;
}
else if (info == null)
{
player.MessageNoPlayer(name.Substring(1));
continue;
}
if (realm.BuildSecurity.CheckDetailed(info) == SecurityCheckResult.Allowed)
{
player.Message("{0}&S is already allowed to build in {1}&S (by rank)",
info.ClassyName, realm.ClassyName);
continue;
}
Player target = info.PlayerObject;
if (target == player) target = null; // to avoid duplicate messages
switch (realm.BuildSecurity.Include(info))
{
case PermissionOverride.Deny:
if (realm.BuildSecurity.Check(info))
{
player.Message("{0}&S is no longer barred from building in {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You can now build in realm {0}&S (removed from blacklist by {1}&S).",
realm.ClassyName, player.ClassyName);
}
}
else
{
player.Message("{0}&S was removed from the build blacklist of {1}&S. " +
"Player is still NOT allowed to build (by rank).",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You were removed from the build blacklist of realm {0}&S by {1}&S. " +
"You are still NOT allowed to build (by rank).",
player.ClassyName, realm.ClassyName);
}
}
Logger.Log(LogType.UserActivity, "{0} removed {1} from the build blacklist of {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.None:
player.Message("{0}&S is now allowed to build in {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You can now build in realm {0}&S (whitelisted by {1}&S).",
realm.ClassyName, player.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} added {1} to the build whitelist on realm {2}",
player.Name, info.Name, realm.Name);
break;
case PermissionOverride.Allow:
player.Message("{0}&S is already on the build whitelist of {1}",
info.ClassyName, realm.ClassyName);
break;
}
// Blacklisting individuals
}
else if (name.StartsWith("-"))
{
PlayerInfo info;
if (!PlayerDB.FindPlayerInfo(name.Substring(1), out info))
{
player.Message("More than one player found matching \"{0}\"", name.Substring(1));
continue;
}
else if (info == null)
{
player.MessageNoPlayer(name.Substring(1));
continue;
}
if (realm.BuildSecurity.CheckDetailed(info) == SecurityCheckResult.RankTooHigh ||
realm.BuildSecurity.CheckDetailed(info) == SecurityCheckResult.RankTooLow)
{
player.Message("{0}&S is already barred from building in {1}&S (by rank)",
info.ClassyName, realm.ClassyName);
continue;
}
Player target = info.PlayerObject;
if (target == player) target = null; // to avoid duplicate messages
switch (realm.BuildSecurity.Exclude(info))
{
case PermissionOverride.Deny:
player.Message("{0}&S is already on build blacklist of {1}",
info.ClassyName, realm.ClassyName);
break;
case PermissionOverride.None:
player.Message("{0}&S is now barred from building in {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("&WYou were barred by {0}&W from building in realm {1}",
player.ClassyName, realm.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} added {1} to the build blacklist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
case PermissionOverride.Allow:
if (realm.BuildSecurity.Check(info))
{
player.Message("{0}&S is no longer on the build whitelist of {1}&S. " +
"Player is still allowed to build (by rank).",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("You were removed from the build whitelist of realm {0}&S by {1}&S. " +
"You are still allowed to build (by rank).",
player.ClassyName, realm.ClassyName);
}
}
else
{
player.Message("{0}&S is no longer allowed to build in {1}",
info.ClassyName, realm.ClassyName);
if (target != null)
{
target.Message("&WYou can no longer build in realm {0}&W (removed from whitelist by {1}&W).",
realm.ClassyName, player.ClassyName);
}
}
Logger.Log(LogType.UserActivity, "{0} removed {1} from the build whitelist on realm {2}",
player.Name, info.Name, realm.Name);
changesWereMade = true;
break;
}
// Setting minimum rank
}
else
{
Rank rank = RankManager.FindRank(name);
if (rank == null)
{
player.MessageNoRank(name);
}
else if (!player.Info.Rank.AllowSecurityCircumvention &&
realm.BuildSecurity.MinRank > rank &&
realm.BuildSecurity.MinRank > player.Info.Rank)
{
player.Message("&WYou must be ranked {0}&W+ to lower build restrictions for realm {1}",
realm.BuildSecurity.MinRank.ClassyName, realm.ClassyName);
}
else
{
// list players who are redundantly blacklisted
var exceptionList = realm.BuildSecurity.ExceptionList;
PlayerInfo[] noLongerExcluded = exceptionList.Excluded.Where(excludedPlayer => excludedPlayer.Rank < rank).ToArray();
if (noLongerExcluded.Length > 0)
{
player.Message("Following players no longer need to be blacklisted on realm {0}&S: {1}",
realm.ClassyName,
noLongerExcluded.JoinToClassyString());
}
// list players who are redundantly whitelisted
PlayerInfo[] noLongerIncluded = exceptionList.Included.Where(includedPlayer => includedPlayer.Rank >= rank).ToArray();
if (noLongerIncluded.Length > 0)
{
player.Message("Following players no longer need to be whitelisted on realm {0}&S: {1}",
realm.ClassyName,
noLongerIncluded.JoinToClassyString());
}
// apply changes
realm.BuildSecurity.MinRank = rank;
changesWereMade = true;
if (realm.BuildSecurity.MinRank == RankManager.LowestRank)
{
Server.Message("{0}&S allowed anyone to build on realm {1}",
player.ClassyName, realm.ClassyName);
}
else
{
Server.Message("{0}&S allowed only {1}+&S to build in realm {2}",
player.ClassyName, realm.BuildSecurity.MinRank.ClassyName, realm.ClassyName);
}
Logger.Log(LogType.UserActivity, "{0} set build rank for realm {1} to {2}+",
player.Name, realm.Name, realm.BuildSecurity.MinRank.Name);
}
}
} while ((name = cmd.Next()) != null);
if (changesWereMade)
{
WorldManager.SaveWorldList();
}
}
static void AutoRankAllHandler( Player player, Command cmd )
{
string rankName = cmd.Next();
Rank rank = null;
if( rankName != null ) {
rank = RankManager.FindRank( rankName );
if( rank == null ) {
player.MessageNoRank( rankName );
return;
}
}
PlayerInfo[] list;
if( rank == null ) {
list = PlayerDB.PlayerInfoList;
} else {
list = PlayerDB.PlayerInfoList.Where( p => p.Rank == rank ).ToArray();
}
DoAutoRankAll( player, list, false, "~AutoRankAll" );
}
static void SetInfoHandler( Player player, CommandReader cmd ) {
string targetName = cmd.Next();
string propertyName = cmd.Next();
string valName = cmd.NextAll();
if( targetName == null || propertyName == null ) {
CdSetInfo.PrintUsage( player );
return;
}
PlayerInfo info = PlayerDB.FindByPartialNameOrPrintMatches( player, targetName );
if( info == null ) return;
switch( propertyName.ToLower() ) {
case "banreason":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "BanReason", info, info.BanReason, valName ) ) {
info.BanReason = valName;
}
break;
case "displayedname":
string oldDisplayedName = info.DisplayedName;
if( valName.Length == 0 ) valName = null;
if( valName == info.DisplayedName ) {
if( valName == null ) {
player.Message( "SetInfo: DisplayedName for {0} is not set.",
info.Name );
} else {
player.Message( "SetInfo: DisplayedName for {0} is already set to \"{1}&S\"",
info.Name,
valName );
}
break;
}
info.DisplayedName = valName;
if( oldDisplayedName == null ) {
player.Message( "SetInfo: DisplayedName for {0} set to \"{1}&S\"",
info.Name,
valName );
} else if( valName == null ) {
player.Message( "SetInfo: DisplayedName for {0} was reset (was \"{1}&S\")",
info.Name,
oldDisplayedName );
} else {
player.Message( "SetInfo: DisplayedName for {0} changed from \"{1}&S\" to \"{2}&S\"",
info.Name,
oldDisplayedName,
valName );
}
break;
case "kickreason":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "KickReason", info, info.LastKickReason, valName ) ) {
info.LastKickReason = valName;
}
break;
case "name":
if( valName.Equals( info.Name, StringComparison.OrdinalIgnoreCase ) ) {
player.Message( "SetInfo: You may change capitalization of player's real name. " +
"If you'd like to make other changes to the way player's name is displayed, " +
"use &H/SetInfo <Name> DisplayedName <NewName>" );
break;
}
string oldName = info.Name;
if( oldName != valName ) {
info.Name = valName;
player.Message( "Name capitalization changed from \"{0}\" to \"{1}\"",
oldName, valName );
} else {
player.Message( "Name capitalization is already \"{0}\"", oldName );
}
break;
case "previousrank":
Rank newPreviousRank;
if( valName.Length > 0 ) {
newPreviousRank = RankManager.FindRank( valName );
if( newPreviousRank == null ) {
player.MessageNoRank( valName );
break;
}
} else {
newPreviousRank = null;
}
Rank oldPreviousRank = info.PreviousRank;
if( newPreviousRank == oldPreviousRank ) {
if( newPreviousRank == null ) {
player.Message( "SetInfo: PreviousRank for {0}&S is not set.",
info.ClassyName );
} else {
player.Message( "SetInfo: PreviousRank for {0}&S is already set to {1}",
info.ClassyName,
newPreviousRank.ClassyName );
}
break;
}
info.PreviousRank = newPreviousRank;
if( oldPreviousRank == null ) {
player.Message( "SetInfo: PreviousRank for {0}&S set to {1}&",
info.ClassyName,
newPreviousRank.ClassyName );
} else if( newPreviousRank == null ) {
player.Message( "SetInfo: PreviousRank for {0}&S was reset (was {1}&S)",
info.ClassyName,
oldPreviousRank.ClassyName );
} else {
player.Message( "SetInfo: PreviousRank for {0}&S changed from {1}&S to {2}",
info.ClassyName,
oldPreviousRank.ClassyName,
newPreviousRank.ClassyName );
}
break;
case "rankchangetype":
RankChangeType oldType = info.RankChangeType;
try {
info.RankChangeType = (RankChangeType)Enum.Parse( typeof( RankChangeType ), valName, true );
} catch( ArgumentException ) {
player.Message( "SetInfo: Could not parse RankChangeType. Allowed values: {0}",
String.Join( ", ", Enum.GetNames( typeof( RankChangeType ) ) ) );
break;
}
player.Message( "SetInfo: RankChangeType for {0}&S changed from {1} to {2}",
info.ClassyName,
oldType,
info.RankChangeType );
break;
case "rankreason":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "RankReason", info, info.RankChangeReason, valName ) ) {
info.RankChangeReason = valName;
}
break;
case "timeskicked":
int oldTimesKicked = info.TimesKicked;
if( ValidateInt( valName, 0, 9999 ) ) {
info.TimesKicked = Int32.Parse( valName );
player.Message( "SetInfo: TimesKicked for {0}&S changed from {1} to {2}",
info.ClassyName,
oldTimesKicked,
info.TimesKicked );
} else {
player.Message( "SetInfo: TimesKicked value out of range (Acceptable value range: 0-9999)" );
}
break;
case "totaltime":
TimeSpan newTotalTime;
TimeSpan oldTotalTime = info.TotalTime;
if( valName.TryParseMiniTimespan( out newTotalTime ) ) {
if( newTotalTime > DateTimeUtil.MaxTimeSpan ) {
player.MessageMaxTimeSpan();
break;
}
info.TotalTime = newTotalTime;
player.Message( "SetInfo: TotalTime for {0}&S changed from {1} ({2}) to {3} ({4})",
info.ClassyName,
oldTotalTime.ToMiniString(),
oldTotalTime.ToCompactString(),
info.TotalTime.ToMiniString(),
info.TotalTime.ToCompactString() );
} else {
player.Message( "SetInfo: Could not parse value given for TotalTime." );
}
break;
case "unbanreason":
if( valName.Length == 0 ) valName = null;
if( SetPlayerInfoField( player, "UnbanReason", info, info.UnbanReason, valName ) ) {
info.UnbanReason = valName;
}
break;
default:
player.Message( "Only the following properties are editable: " +
"TimesKicked, PreviousRank, TotalTime, RankChangeType, " +
"BanReason, UnbanReason, RankReason, KickReason, DisplayedName" );
return;
}
}
static void MassRankHandler( Player player, Command cmd )
{
string fromRankName = cmd.Next();
string toRankName = cmd.Next();
string reason = cmd.NextAll();
if( fromRankName == null || toRankName == null ) {
CdMassRank.PrintUsage( player );
return;
}
Rank fromRank = RankManager.FindRank( fromRankName );
if( fromRank == null ) {
player.MessageNoRank( fromRankName );
return;
}
Rank toRank = RankManager.FindRank( toRankName );
if( toRank == null ) {
player.MessageNoRank( toRankName );
return;
}
if( fromRank == toRank ) {
player.Message( "Ranks must be different" );
return;
}
int playerCount = fromRank.PlayerCount;
string verb = (fromRank > toRank ? "demot" : "promot");
if( !cmd.IsConfirmed ) {
player.Confirm( cmd, "About to {0}e {1} players.", verb, playerCount );
return;
}
player.Message( "MassRank: {0}ing {1} players...",
verb, playerCount );
int affected = PlayerDB.MassRankChange( player, fromRank, toRank, reason );
player.Message( "MassRank: done, {0} records affected.", affected );
}
static void SetInfoHandler(Player player, CommandReader cmd)
{
string targetName = cmd.Next();
string propertyName = cmd.Next();
string valName = cmd.NextAll();
if (targetName == null || propertyName == null)
{
CdSetInfo.PrintUsage(player);
return;
}
PlayerInfo info = PlayerDB.FindByPartialNameOrPrintMatches(player, targetName);
if (info == null)
{
return;
}
switch (propertyName.ToLower())
{
case "banreason":
if (valName.Length == 0)
{
valName = null;
}
if (SetPlayerInfoField(player, "BanReason", info, info.BanReason, valName))
{
info.BanReason = valName;
}
break;
case "displayedname":
string oldDisplayedName = info.DisplayedName;
if (valName.Length == 0)
{
valName = null;
}
if (valName == info.DisplayedName)
{
if (valName == null)
{
player.Message("SetInfo: DisplayedName for {0} is not set.",
info.Name);
}
else
{
player.Message("SetInfo: DisplayedName for {0} is already set to \"{1}&S\"",
info.Name,
valName);
}
break;
}
info.DisplayedName = valName;
if (oldDisplayedName == null)
{
player.Message("SetInfo: DisplayedName for {0} set to \"{1}&S\"",
info.Name,
valName);
}
else if (valName == null)
{
player.Message("SetInfo: DisplayedName for {0} was reset (was \"{1}&S\")",
info.Name,
oldDisplayedName);
}
else
{
player.Message("SetInfo: DisplayedName for {0} changed from \"{1}&S\" to \"{2}&S\"",
info.Name,
oldDisplayedName,
valName);
}
break;
case "kickreason":
if (valName.Length == 0)
{
valName = null;
}
if (SetPlayerInfoField(player, "KickReason", info, info.LastKickReason, valName))
{
info.LastKickReason = valName;
}
break;
case "name":
if (valName.Equals(info.Name, StringComparison.OrdinalIgnoreCase))
{
player.Message("SetInfo: You may change capitalization of player's real name. " +
"If you'd like to make other changes to the way player's name is displayed, " +
"use &H/SetInfo <Name> DisplayedName <NewName>");
break;
}
string oldName = info.Name;
if (oldName != valName)
{
info.Name = valName;
player.Message("Name capitalization changed from \"{0}\" to \"{1}\"",
oldName, valName);
}
else
{
player.Message("Name capitalization is already \"{0}\"", oldName);
}
break;
case "previousrank":
Rank newPreviousRank;
if (valName.Length > 0)
{
newPreviousRank = RankManager.FindRank(valName);
if (newPreviousRank == null)
{
player.MessageNoRank(valName);
break;
}
}
else
{
newPreviousRank = null;
}
Rank oldPreviousRank = info.PreviousRank;
if (newPreviousRank == oldPreviousRank)
{
if (newPreviousRank == null)
{
player.Message("SetInfo: PreviousRank for {0}&S is not set.",
info.ClassyName);
}
else
{
player.Message("SetInfo: PreviousRank for {0}&S is already set to {1}",
info.ClassyName,
newPreviousRank.ClassyName);
}
break;
}
info.PreviousRank = newPreviousRank;
if (oldPreviousRank == null)
{
player.Message("SetInfo: PreviousRank for {0}&S set to {1}&",
info.ClassyName,
newPreviousRank.ClassyName);
}
else if (newPreviousRank == null)
{
player.Message("SetInfo: PreviousRank for {0}&S was reset (was {1}&S)",
info.ClassyName,
oldPreviousRank.ClassyName);
}
else
{
player.Message("SetInfo: PreviousRank for {0}&S changed from {1}&S to {2}",
info.ClassyName,
oldPreviousRank.ClassyName,
newPreviousRank.ClassyName);
}
break;
case "rankchangetype":
RankChangeType oldType = info.RankChangeType;
try {
info.RankChangeType = (RankChangeType)Enum.Parse(typeof(RankChangeType), valName, true);
} catch (ArgumentException) {
player.Message("SetInfo: Could not parse RankChangeType. Allowed values: {0}",
String.Join(", ", Enum.GetNames(typeof(RankChangeType))));
break;
}
player.Message("SetInfo: RankChangeType for {0}&S changed from {1} to {2}",
info.ClassyName,
oldType,
info.RankChangeType);
break;
case "rankreason":
if (valName.Length == 0)
{
valName = null;
}
if (SetPlayerInfoField(player, "RankReason", info, info.RankChangeReason, valName))
{
info.RankChangeReason = valName;
}
break;
case "timeskicked":
int oldTimesKicked = info.TimesKicked;
if (ValidateInt(valName, 0, 9999))
{
info.TimesKicked = Int32.Parse(valName);
player.Message("SetInfo: TimesKicked for {0}&S changed from {1} to {2}",
info.ClassyName,
oldTimesKicked,
info.TimesKicked);
}
else
{
player.Message("SetInfo: TimesKicked value out of range (Acceptable value range: 0-9999)");
}
break;
case "totaltime":
TimeSpan newTotalTime;
TimeSpan oldTotalTime = info.TotalTime;
if (valName.TryParseMiniTimespan(out newTotalTime))
{
if (newTotalTime > DateTimeUtil.MaxTimeSpan)
{
player.MessageMaxTimeSpan();
break;
}
info.TotalTime = newTotalTime;
player.Message("SetInfo: TotalTime for {0}&S changed from {1} ({2}) to {3} ({4})",
info.ClassyName,
oldTotalTime.ToMiniString(),
oldTotalTime.ToCompactString(),
info.TotalTime.ToMiniString(),
info.TotalTime.ToCompactString());
}
else
{
player.Message("SetInfo: Could not parse value given for TotalTime.");
}
break;
case "unbanreason":
if (valName.Length == 0)
{
valName = null;
}
if (SetPlayerInfoField(player, "UnbanReason", info, info.UnbanReason, valName))
{
info.UnbanReason = valName;
}
break;
default:
player.Message("Only the following properties are editable: " +
"TimesKicked, PreviousRank, TotalTime, RankChangeType, " +
"BanReason, UnbanReason, RankReason, KickReason, DisplayedName");
return;
}
}
