void DoZone( Player player, Command cmd ) {
if( !player.Can( Permissions.SetSpawn ) ) {
world.NoAccessMessage( player );
return;
}
string name = cmd.Next();
if( name == null ) {
player.Message( "No zone name specified. See " + Color.Help + "/help zone" );
return;
}
if( !Player.IsValidName( name ) ) {
player.Message( "\"" + name + "\" is not a valid zone name" );
return;
}
Zone zone = new Zone();
zone.name = name;
string property = cmd.Next();
if( property == null ) {
player.Message( "No zone rank/whitelist/blacklist specified. See " + Color.Help + "/help zone" );
return;
}
PlayerClass minRank = world.classes.ParseClass( property );
if( minRank != null ) {
zone.buildRank = minRank.rank;
player.tag = zone;
player.marksExpected = 2;
player.marks.Clear();
player.markCount = 0;
player.selectionCallback = MakeZone;
}
}
public static void SetParametrization(Player p, Command cmd)
{
string strFunc = cmd.Next();
if (string.IsNullOrWhiteSpace(strFunc))
{
p.Message("Error: empty parametrization expression");
return;
}
if (strFunc.Length < 3)
{
p.Message("Error: expression is too short (should be like x=f(t,u,v))");
return;
}
strFunc = strFunc.ToLower();
try
{
string coordVar = SimpleParser.PreparseAssignment(ref strFunc);
CheckCoordVar(coordVar);
Expression expression = SimpleParser.Parse(strFunc, new string[] { "t", "u", "v" });
p.Message("Expression parsed as " + coordVar + "=" + expression.Print());
GetPlayerParametrizationCoordsStorage(p)[VarNameToIdx(coordVar[0])] = expression;
}
catch (Exception e)
{
p.Message("Error: "+e.Message);
}
}
protected FuncDrawOperation(Player player, Command cmd)
: base(player)
{
string strFunc = cmd.Next();
if (string.IsNullOrWhiteSpace(strFunc))
{
player.Message("&WEmpty function expression");
return;
}
if (strFunc.Length < 3)
{
player.Message("&WExpression is too short (should be like z=f(x,y))");
return;
}
strFunc = strFunc.ToLower();
_vaxis = GetAxis(SimpleParser.PreparseAssignment(ref strFunc));
_expression = SimpleParser.Parse(strFunc, GetVarArray(_vaxis));
Player.Message("Expression parsed as "+_expression.Print());
string scalingStr=cmd.Next();
_scaler = new Scaler(scalingStr);
}
internal static void CModeWater(Player player, Command cmd)
{
if (!player.Can(Permissions.ControlPhysics))
{
player.NoAccessMessage(Permissions.ControlPhysics);
return;
}
string blockpar = cmd.Next();
string wmt = "";
int BlockAddr = -1;
try { BlockAddr = Convert.ToInt32(blockpar); }
catch
{
player.Message("Incorrect parameter!"); return;
}
if (BlockAddr < 3 && BlockAddr >= 0)
{
player.world.map.modeWater = BlockAddr;
switch (BlockAddr)
{
case 0: wmt = "'none'"; break;
case 1: wmt = "'infinite'"; break;
case 2: wmt = "'finite'"; break;
}
player.Message("Water mode set to " + wmt + ".");
}
}
static void PayHandler(Player player, Command cmd)
{
string targetName = cmd.Next();
string money = cmd.Next();
int amount;
if (money == null)
{
player.Message("&ePlease select the amount of bits you wish to send.");
return;
}
Player target = Server.FindPlayerOrPrintMatches(player, targetName, false, true);
if (target == null)
{
player.Message("&ePlease select a player to pay bits towards.");
return;
}
if (!int.TryParse(money, out amount))
{
player.Message("&ePlease select from a whole number.");
return;
}
PayHandler(player, new Command("/economy pay " + target + " " + money));
}
void Paint( Player player, Command cmd ) {
player.replaceMode = !player.replaceMode;
if( player.replaceMode ){
player.Message( "Replacement mode: ON" );
} else {
player.Message( "Replacement mode: OFF" );
}
}
public void PrintUsage( Player player ) {
if( player == null ) throw new ArgumentNullException( "player" );
if( Usage != null ) {
player.Message( "Usage: &H{0}", Usage );
} else {
player.Message( "Usage: &H/{0}", Name );
}
}
public static void SetParamIteration(Player p, CommandReader cmd)
{
string strParam = cmd.Next();
if (string.IsNullOrWhiteSpace(strParam))
{
p.Message("Error: missing param variable name");
return;
}
strParam = strParam.ToLower();
try
{
CheckParamVar(strParam);
double from = ReadDoubleParam(cmd, "lower bound");
double to = ReadDoubleParam(cmd, "upper bound");
double step = ReadDoubleParam(cmd, "step");
if (step == 0 ||
(to - from)/step < 0)
throw new ArgumentException("wrong iteration bounds/step combination");
p.Message("Iteration for " + strParam + " from " + from + " to " + to + " with step " + step + ". " +
((to - from)/step + 1) + " steps.");
GetPlayerParametrizationParamsStorage(p)[VarNameToIdx(strParam[0])] = new double[] {from, to, step};
}
catch (Exception e)
{
p.Message("Error: " + e.Message);
}
}
internal static void CancelDraw( Player player, Command command )
{
if( player.marksExpected > 0 ) {
player.marksExpected = 0;
} else {
player.Message( "There is currently nothing to cancel." );
}
}
void Compass( Player player, Command cmd ) {
int offset = (int)(player.pos.r / 255f * 64f) + 32;
string name = cmd.Next();
if( name != null ) {
Player target = world.FindPlayer( name );
if( target != null ) {
player.Message( "Coordinates of player \"" + target.name + "\":" );
offset = (int)(target.pos.r / 255f * 64f) + 32;
} else {
world.NoPlayerMessage( player, name );
return;
}
}
player.Message( Color.Silver, String.Format( "({0},{1},{2}) - {3}[{4}{5}{6}{3}{7}]",
player.pos.x / 32,
player.pos.y / 32,
player.pos.h / 32,
Color.White,
compass.Substring( offset - 12, 11 ),
Color.Red,
compass.Substring( offset - 1, 3 ),
compass.Substring( offset + 2, 11 ) ) );
}
static void BumHandler(Player player, CommandReader cmd)
{
string newModeName = cmd.Next();
if (newModeName == null)
{
player.Message("&sBytes Sent: {0} Per Second: {1:0.0}", player.BytesSent, player.BytesSentRate);
player.Message("&sBytes Received: {0} Per Second: {1:0.0}", player.BytesReceived, player.BytesReceivedRate);
player.Message("&sBandwidth mode: {0}",player.BandwidthUseMode);
return;
}
else if (player.Can(Permission.EditPlayerDB))
{
var newMode = (BandwidthUseMode)Enum.Parse(typeof(BandwidthUseMode), newModeName, true);
player.Message("&sBandwidth mode: {0} --> {1}", player.BandwidthUseMode, newMode.ToString());
player.BandwidthUseMode = newMode;
player.Info.BandwidthUseMode = newMode;
return;
}
else
{
player.Message("You need {0}&s to change your BandwidthUseMode", RankManager.GetMinRankWithAnyPermission(Permission.EditPlayerDB).ClassyName);
return;
}
}
private static void TrollHandler( Player player, CommandReader cmd ) {
string Name = cmd.Next();
if ( Name == null ) {
player.Message( "Player not found. Please specify valid name." );
return;
}
if ( !Player.IsValidPlayerName( Name ) )
return;
Player target = Server.FindPlayerOrPrintMatches( player, Name, SearchOptions.Default );
if ( target == null )
return;
string options = cmd.Next();
if ( options == null ) {
CdTroll.PrintUsage( player );
return;
}
string Message = cmd.NextAll();
if ( Message.Length < 1 && options.ToLower() != "leave" ) {
player.Message( "&WError: Please enter a message for {0}.", target.ClassyName );
return;
}
switch ( options.ToLower() ) {
case "pm":
if ( player.Can( Permission.UseColorCodes ) && Message.Contains( "%" ) ) {
Message = Chat.ReplacePercentColorCodes( Message, false );
}
Server.Players.Message( "&Pfrom {0}: {1}",
target.Name, Message );
break;
case "st":
case "staff":
Chat.SendStaff( target, Message );
break;
case "i":
case "impersonate":
case "msg":
case "message":
case "m":
Server.Message( "{0}&S&F: {1}",
target.ClassyName, Message );
break;
case "leave":
case "disconnect":
case "gtfo":
Server.Players.Message( "&SPlayer {0}&S left the server.",
target.ClassyName );
break;
default:
player.Message( "Invalid option. Please choose st, ac, pm, message or leave" );
break;
}
}
void Solid( Player player, Command cmd ) {
if( player.mode == BlockPlacementMode.Solid ){
player.mode = BlockPlacementMode.Normal;
player.Message( "Solid: OFF" );
} else if( player.Can( Permissions.PlaceAdmincrete ) ) {
player.mode = BlockPlacementMode.Solid;
player.Message( "Solid: ON" );
} else {
world.NoAccessMessage( player );
}
}
void Water( Player player, Command cmd ) {
if( player.mode == BlockPlacementMode.Water ) {
player.mode = BlockPlacementMode.Normal;
player.Message( "Water: OFF" );
} else if( player.Can( Permissions.PlaceWater ) ) {
player.mode = BlockPlacementMode.Water;
player.Message( "Water: ON. Blue blocks are replaced with water." );
} else {
world.NoAccessMessage( player );
}
}
void Lava( Player player, Command cmd ) {
if( player.mode == BlockPlacementMode.Lava ) {
player.mode = BlockPlacementMode.Normal;
player.Message( "Lava: OFF." );
} else if( player.Can( Permissions.PlaceWater ) ) {
player.mode = BlockPlacementMode.Lava;
player.Message( "Lava: ON. Red blocks are replaced with lava." );
} else {
world.NoAccessMessage( player );
}
}
void Grass( Player player, Command cmd ) {
if( player.mode == BlockPlacementMode.Grass ) {
player.mode = BlockPlacementMode.Normal;
player.Message( "Grass: OFF" );
} else if( player.Can( Permissions.PlaceGrass ) ) {
player.mode = BlockPlacementMode.Grass;
player.Message( "Grass: ON. Dirt blocks are replaced with grass." );
} else {
world.NoAccessMessage( player );
}
}
internal static void Hardened(Player player, Command cmd)
{
if (player.hardenedMode == BlockPlacementMode.Hardened) {
player.hardenedMode = BlockPlacementMode.Normal;
player.Message("Hardened blocks: OFF");
} else if (player.Can(Permissions.PlaceHardenedBlocks)) {
player.hardenedMode = BlockPlacementMode.Hardened;
player.Message("Hardened blocks: ON");
} else {
player.NoAccessMessage( Permissions.PlaceHardenedBlocks );
}
}
internal static void WorldInfo( Player player, Command cmd ) {
string worldName = cmd.Next();
if( worldName == null ) {
if( player.World == null ) {
player.Message( "Please specify a world name when calling /winfo form console." );
return;
} else {
worldName = player.World.Name;
}
}
World world = WorldManager.FindWorldOrPrintMatches( player, worldName );
if( world == null ) return;
player.Message( "World {0}&S has {1} player(s) on.",
world.GetClassyName(),
world.CountVisiblePlayers(player) );
Map map = world.Map;
// If map is not currently loaded, grab its header from disk
if( map == null ) {
try {
map = MapUtility.LoadHeader( Path.Combine( Paths.MapPath, world.GetMapName() ) );
} catch( Exception ex ) {
player.Message( "Map information could not be loaded: {0}: {1}",
ex.GetType().Name, ex.Message );
}
}
if( map != null ) {
player.Message( "Map dimensions are {0} x {1} x {2}",
map.WidthX, map.WidthY, map.Height );
}
// Print access/build limits
world.AccessSecurity.PrintDescription( player, world, "world", "accessed" );
world.BuildSecurity.PrintDescription( player, world, "world", "modified" );
// Print lock/unlock information
if( world.IsLocked ) {
player.Message( "{0}&S was locked {1} ago by {2}",
world.GetClassyName(),
DateTime.UtcNow.Subtract( world.LockedDate ).ToMiniString(),
world.LockedBy );
} else if( world.UnlockedBy != null ) {
player.Message( "{0}&S was unlocked {1} ago by {2}",
world.GetClassyName(),
DateTime.UtcNow.Subtract( world.UnlockedDate ).ToMiniString(),
world.UnlockedBy );
}
}
internal void ParseCommand( Player player, string message, bool fromConsole ) {
Command cmd = new Command( message );
if( consoleSafeHandlers.ContainsKey( cmd.name ) ) {
consoleSafeHandlers[cmd.name]( player, cmd );
} else if( handlers.ContainsKey( cmd.name ) ) {
if( fromConsole ) {
player.Message( "You cannot use this command from console." );
} else {
handlers[cmd.name]( player, cmd );
}
} else {
player.Message( "Unrecognized command: " + cmd.name );
}
}
public static void ProcessCommand( Player p, Command cmd )
{
string command = cmd.Next();
if ( String.IsNullOrWhiteSpace( command ) ) {
p.Message( "&WLife command is missing or empty" );
return;
}
LifeCommand c;
if ( !Commands.TryGetValue( command.ToLower(), out c ) ) {
p.Message( "&WUnknown life command " + command + ". &hType '/life help' for the list of commands." );
return;
}
c.F( p, cmd );
}
static void BanHandler( Player player, CommandReader cmd ) {
string targetName = cmd.Next();
if( targetName == null ) {
CdBan.PrintUsage( player );
return;
}
PlayerInfo target = PlayerDB.FindPlayerInfoOrPrintMatches( player,
targetName,
SearchOptions.ReturnSelfIfOnlyMatch );
if( target == null ) return;
if( target == player.Info ) {
player.Message( "You cannot &H/Ban&S yourself." );
return;
}
string reason = cmd.NextAll();
try {
Player targetPlayer = target.PlayerObject;
target.Ban( player, reason, true, true );
WarnIfOtherPlayersOnIP( player, target, targetPlayer );
} catch( PlayerOpException ex ) {
player.Message( ex.MessageColored );
if( ex.ErrorCode == PlayerOpExceptionCode.ReasonRequired ) {
FreezeIfAllowed( player, target );
}
}
}
public static void AssignBlue(Player p)
{
string sbName = p.Name;
p.Message("Let the games Begin!");
p.Message("You are on the &1Blue Team");
p.iName = "TeamBlue";
p.Info.tempDisplayedName = "&f(" + blueTeam + "&f) " + Color.Navy + sbName;
p.Info.isOnBlueTeam = true;
p.Info.isOnRedTeam = false;
p.Info.isPlayingTD = true;
p.entityChanged = true;
p.Info.gameKills = 0;
p.Info.gameDeaths = 0;
blueTeamCount++;
return;
}
internal static void DumpStats( Player player, Command cmd ) {
string fileName = cmd.Next();
if( fileName == null ) {
cdDumpStats.PrintUsage( player );
return;
}
if( !Paths.Contains( Paths.WorkingPath, fileName ) ) {
player.UnsafePathMessage();
return;
}
if( Paths.IsProtectedFileName( Path.GetFileName( fileName ) ) ) {
player.Message( "You may not use this file." );
return;
}
if( Path.HasExtension( fileName ) &&
!Path.GetExtension( fileName ).Equals( ".txt", StringComparison.OrdinalIgnoreCase ) ) {
player.Message( "Stats filename must end with .txt" );
return;
}
if( File.Exists( fileName ) && !cmd.IsConfirmed ) {
player.AskForConfirmation( cmd, "File \"{0}\" already exists. Overwrite?", Path.GetFileName( fileName ) );
return;
}
if( !Paths.TestFile( "dumpstats file", fileName, false, true, false ) ) {
player.Message( "Cannot create specified file. See log for details." );
return;
}
PlayerInfo[] infos;
using( FileStream fs = File.Create( fileName ) ) {
using( StreamWriter writer = new StreamWriter( fs ) ) {
infos = PlayerDB.GetPlayerListCopy();
if( infos.Length == 0 ) {
writer.WriteLine( "{0} (0 players)", "(TOTAL)" );
writer.WriteLine();
} else {
DumpPlayerGroupStats( writer, infos, "(TOTAL)" );
}
foreach( Rank rank in RankManager.Ranks ) {
infos = PlayerDB.GetPlayerListCopy( rank );
if( infos.Length == 0 ) {
writer.WriteLine( "{0} (0 players)", rank.Name );
writer.WriteLine();
} else {
DumpPlayerGroupStats( writer, infos, rank.Name );
}
}
}
}
player.Message( "Stats saved to \"{0}\"", Path.GetFileName( fileName ) );
}
internal static void Colors( Player player, Command cmd ) {
StringBuilder sb = new StringBuilder( "List of colors: " );
foreach( var color in Color.ColorNames ) {
sb.AppendFormat( "&{0}%{0} {1} ", color.Key, color.Value );
}
player.Message( sb.ToString() );
}
public override MapGeneratorParameters CreateParameters( Player player, CommandReader cmd ) {
string themeName = cmd.Next();
if( themeName == null ) {
return CreateDefaultParameters();
}
MapGenTheme theme;
RealisticMapGenTerrainType terrainType;
string templateName = cmd.Next();
if( templateName == null ) {
player.Message( "SetGen: Realistic MapGen requires both a theme and a terrainType. " +
"See &H/Help SetGen Realistic&S or check wiki.fCraft.net for details" );
return null;
}
// parse theme
bool swapThemeAndTemplate;
if( EnumUtil.TryParse( themeName, out theme, true ) ) {
swapThemeAndTemplate = false;
} else if( EnumUtil.TryParse( templateName, out theme, true ) ) {
swapThemeAndTemplate = true;
} else {
player.Message( "SetGen: Unrecognized theme \"{0}\". Available themes are: {1}",
themeName,
Enum.GetNames( typeof( MapGenTheme ) ).JoinToString() );
return null;
}
// parse terrainType
if( swapThemeAndTemplate && !EnumUtil.TryParse( themeName, out terrainType, true ) ) {
MessageTemplateList( themeName, player );
return null;
} else if( !EnumUtil.TryParse( templateName, out terrainType, true ) ) {
MessageTemplateList( templateName, player );
return null;
}
// TODO: optional parameters for preset customization
return CreateParameters( terrainType, theme );
}
public static void test(Player player, Command cmd)
{
if (!File.Exists("C:/users/jb509/desktop/1.schematic"))
{
player.Message("Nop"); return;
}
NbtFile file = new NbtFile("C:/users/jb509/desktop/1.schematic");
file.RootTag = new NbtCompound("Schematic");
file.LoadFile();
bool notClassic = false;
short width = file.RootTag.Query<NbtShort>("/Schematic/Width").Value;
short height = file.RootTag.Query<NbtShort>("/Schematic/Height").Value;
short length = file.RootTag.Query<NbtShort>("/Schematic/Length").Value;
Byte[] blocks = file.RootTag.Query<NbtByteArray>("/Schematic/Blocks").Value;
Vector3I pos = player.Position.ToBlockCoords();
int i = 0;
player.Message("&SDrawing Schematic ({0}x{1}x{2})", length, width, height);
for (int x = pos.X; x < width + pos.X; x++)
{
for (int y = pos.Y; y < length + pos.Y; y++)
{
for (int z = pos.Z; z < height + pos.Z; z++)
{
if (Enum.Parse(typeof(Block), ((Block)blocks[i]).ToString(), true) != null)
{
if (!notClassic && blocks[i] > 49)
{
notClassic = true;
player.Message("&WSchematic used is not designed for Minecraft Classic;" +
" Converting all unsupported blocks with air");
}
if (blocks[i] < 50)
{
player.WorldMap.QueueUpdate(new BlockUpdate(null, (short)x, (short)y, (short)z, (Block)blocks[i]));
}
}
i++;
}
}
}
file.Dispose();
}
private static void ModelHandler(Player player, CommandReader cmd) {
PlayerInfo otherPlayer = InfoCommands.FindPlayerInfo(player, cmd, cmd.Next() ?? player.Name);
if (otherPlayer == null) return;
if (!player.IsStaff && otherPlayer != player.Info) {
Rank staffRank = RankManager.GetMinRankWithAnyPermission(Permission.ReadStaffChat);
if (staffRank != null) {
player.Message("You must be {0}&s+ to change another players Model", staffRank.ClassyName);
} else {
player.Message("No ranks have the ReadStaffChat permission so no one can change other players Model, yell at the owner.");
}
return;
}
if (otherPlayer.Rank.Index < player.Info.Rank.Index) {
player.Message("Cannot change the Model of someone higher rank than you.");
return;
}
if (otherPlayer == null) {
player.Message("Your current Model: &f" + player.Info.Mob);
return;
}
string model = cmd.Next();
if (string.IsNullOrEmpty(model)) {
player.Message("Current Model for {0}: &f{1}", otherPlayer.Name, otherPlayer.Mob);
return;
}
if (otherPlayer.IsOnline && otherPlayer.Rank.Index >= player.Info.Rank.Index) {
if (!validEntities.Contains(model.ToLower())) {
Block block;
if (Map.GetBlockByName(model, false, out block)) {
model = block.GetHashCode().ToString();
} else {
player.Message("Model not valid, see &h/Help Model&s.");
return;
}
}
if (otherPlayer.Mob.ToLower() == model.ToLower()) {
player.Message("&f{0}&s's model is already set to &f{1}", otherPlayer.Name, model);
return;
}
if (otherPlayer.IsOnline) {
otherPlayer.PlayerObject.Message("&f{0}&shanged your model from &f{1} &sto &f{2}", (otherPlayer.PlayerObject == player ? "&sC" : player.Name + " &sc"), otherPlayer.Mob, model);
}
if (otherPlayer.PlayerObject != player) {
player.Message("&sChanged model of &f{0} &sfrom &f{1} &sto &f{2}", otherPlayer.Name, otherPlayer.Mob, model);
}
otherPlayer.oldMob = otherPlayer.Mob;
otherPlayer.Mob = model;
} else {
player.Message("Player not found/online or lower rank than you");
}
}
void Load( Player player, Command cmd ) {
lock( loadLock ) {
if( world.loadInProgress || world.loadSendingInProgress ) {
player.Message( "Loading already in progress, please wait." );
return;
}
world.loadInProgress = true;
}
if( !player.Can( Permissions.SaveAndLoad ) ) {
world.NoAccessMessage( player );
world.loadInProgress = false;
return;
}
string mapName = cmd.Next();
if( mapName == null ) {
player.Message( "Syntax: " + Color.Help + "/load mapName" );
world.loadInProgress = false;
return;
}
string mapFileName = mapName + ".fcm";
if( !File.Exists( mapFileName ) ) {
player.Message( "No backup file \"" + mapName + "\" found." );
world.loadInProgress = false;
return;
}
Map newMap = Map.Load( world, mapFileName );
if( newMap == null ) {
player.Message( "Could not load \"" + mapFileName + "\". Check logfile for details." );
world.loadInProgress = false;
return;
}
if( newMap.widthX != world.map.widthX ||
newMap.widthY != world.map.widthY ||
newMap.height != world.map.height ) {
player.Message( "Map sizes of \"" + mapName + "\" and the current map do not match." );
world.loadInProgress = false;
return;
}
world.log.Log( "{0} is loading the map \"{1}\".", LogType.UserActivity, player.name, mapName );
player.Message( "Loading map \"" + mapName + "\"..." );
world.BeginLockDown();
MapSenderParams param = new MapSenderParams() {
map = newMap,
player = player,
world = world
};
world.tasks.Add( MapSender.StreamLoad, param, true );
}
public EqualityDrawOperation( Player player, Command cmd )
: base(player)
{
string strFunc = cmd.Next();
if ( string.IsNullOrWhiteSpace( strFunc ) ) {
player.Message( "empty equality expression" );
return;
}
if ( strFunc.Length < 3 ) {
player.Message( "expression is too short (should be like f(x,y,z)=g(x,y,z))" );
return;
}
strFunc = strFunc.ToLower();
_expression = SimpleParser.ParseAsEquality( strFunc, new string[] { "x", "y", "z" } );
player.Message( "Expression parsed as " + _expression.Print() );
string scalingStr = cmd.Next();
_scaler = new Scaler( scalingStr );
}
public static void AssignBlue(Player p)
{
p.Message("You are on the &9Blue Team");
p.iName = "TeamBlue";
p.Info.tempDisplayedName = "&f(" + blueTeam + "&f) " + Color.Navy + p.Name;
p.Info.CTFBlueTeam = true;
p.Info.CTFRedTeam = false;
p.Info.isPlayingCTF = true;
p.entityChanged = true;
blueTeamCount++;
return;
}
public static void coords(Player player)
{
Vector3I Blockcoords = player.Position.ToBlockCoords();
player.Message("Your current coordinates are " + Blockcoords + ".");
}
/// <summary> Sends a global (white) chat. </summary>
/// <param name="player"> Player writing the message. </param>
/// <param name="rawMessage"> Message text. </param>
/// <returns> True if message was sent, false if it was cancelled by an event callback. </returns>
public static bool SendGlobal([NotNull] Player player, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
string OriginalMessage = rawMessage;
if (Server.Moderation && !Server.VoicedPlayers.Contains(player) && player.World != null)
{
player.Message("&WError: Server Moderation is activated. Message failed to send");
return(false);
}
rawMessage = rawMessage.Replace("$name", player.ClassyName);
rawMessage = rawMessage.Replace("$kicks", player.Info.TimesKickedOthers.ToString());
rawMessage = rawMessage.Replace("$bans", player.Info.TimesBannedOthers.ToString());
rawMessage = rawMessage.Replace("$awesome",
"It is my professional opinion, that " + ConfigKey.ServerName.GetString() +
" is the best server on Minecraft");
rawMessage = rawMessage.Replace("$server", ConfigKey.ServerName.GetString());
rawMessage = rawMessage.Replace("$motd", ConfigKey.MOTD.GetString());
rawMessage = rawMessage.Replace("$date", DateTime.UtcNow.ToShortDateString());
rawMessage = rawMessage.Replace("$time", DateTime.Now.ToString());
rawMessage = rawMessage.Replace("$money", player.Info.Money.ToString());
if (!player.Can(Permission.ChatWithCaps))
{
int caps = 0;
for (int i = 0; i < rawMessage.Length; i++)
{
if (Char.IsUpper(rawMessage[i]))
{
caps++;
if (caps > ConfigKey.MaxCaps.GetInt())
{
rawMessage = rawMessage.ToLower();
player.Message(
"Your message was changed to lowercase as it exceeded the maximum amount of capital letters.");
}
}
}
}
if (!player.Can(Permission.Swear))
{
if (!File.Exists("SwearWords.txt"))
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("#This txt file should be filled with bad words that you want to be filtered out");
sb.AppendLine("#I have included some examples, excuse my language :P");
sb.AppendLine("f**k");
sb.AppendLine("f*****g");
sb.AppendLine("f****d");
sb.AppendLine("dick");
sb.AppendLine("bitch");
sb.AppendLine("shit");
sb.AppendLine("s******g");
sb.AppendLine("s******d");
sb.AppendLine("c**t");
sb.AppendLine("nigger");
sb.AppendLine("wanker");
sb.AppendLine("wank");
sb.AppendLine("wanking");
sb.AppendLine("piss");
File.WriteAllText("SwearWords.txt", sb.ToString());
}
string CensoredText = Color.ReplacePercentCodes(ConfigKey.SwearName.GetString()) + Color.White;
if (ConfigKey.SwearName.GetString() == null)
{
CensoredText = "&CBlock&F";
}
const string PatternTemplate = @"\b({0})(s?)\b";
const RegexOptions Options = RegexOptions.IgnoreCase;
if (Swears.Count == 0)
{
Swears.AddRange(File.ReadAllLines("SwearWords.txt").
Where(line => line.StartsWith("#") == false || line.Trim().Equals(String.Empty)));
}
if (badWordMatchers == null)
{
badWordMatchers = Swears.
Select(x => new Regex(string.Format(PatternTemplate, x), Options));
}
string output = badWordMatchers.
Aggregate(rawMessage, (current, matcher) => matcher.Replace(current, CensoredText));
rawMessage = output;
}
var recepientList = Server.Players.NotIgnoring(player);
string formattedMessage = String.Format("{0}&F: {1}",
player.ClassyName,
rawMessage);
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Global,
recepientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.GlobalChat,
"{0}: {1}", player.Name, OriginalMessage);
return(true);
}
public Map AcceptPlayer([NotNull] Player player, bool announce)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
lock ( SyncRoot ) {
if (IsFull)
{
if (player.Info.Rank.HasReservedSlot)
{
Player idlestPlayer = Players.Where(p => p.Info.Rank.IdleKickTimer != 0)
.OrderBy(p => p.LastActiveTime)
.FirstOrDefault();
if (idlestPlayer != null)
{
idlestPlayer.Kick(Player.Console, "Auto-kicked to make room (idle).",
LeaveReason.IdleKick, false, false, false);
Server.Players
.CanSee(player)
.Message("&SPlayer {0}&S was auto-kicked to make room for {1}",
idlestPlayer.ClassyName, player.ClassyName);
Server.Players
.CantSee(player)
.Message("{0}&S was kicked for being idle for {1} min",
player.ClassyName, player.Info.Rank.IdleKickTimer);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
if (playerIndex.ContainsKey(player.Name.ToLower()))
{
Logger.Log(LogType.Error,
"This world already contains the player by name ({0}). " +
"Some sort of state corruption must have occurred.",
player.Name);
playerIndex.Remove(player.Name.ToLower());
}
playerIndex.Add(player.Name.ToLower(), player);
// load the map, if it's not yet loaded
IsPendingMapUnload = false;
Map = LoadMap();
if (ConfigKey.BackupOnJoin.Enabled() && (HasChangedSinceBackup || !ConfigKey.BackupOnlyWhenChanged.Enabled()))
{
string backupFileName = String.Format(JoinBackupFormat,
Name, DateTime.Now, player.Name); // localized
SaveBackup(Path.Combine(Paths.BackupPath, backupFileName));
}
UpdatePlayerList();
if (announce && ConfigKey.ShowJoinedWorldMessages.Enabled())
{
Server.Players.CanSee(player)
.Message("&SPlayer {0}&S joined {1}",
player.ClassyName, ClassyName);
}
Logger.Log(LogType.UserActivity,
"Player {0} joined world {1}.",
player.Name, Name);
if (IsLocked)
{
player.Message("&WThis map is currently locked (read-only).");
}
if (player.Info.IsHidden)
{
player.Message("&8Reminder: You are still hidden.");
}
return(Map);
}
}
/// <summary> Parses next parameter as a Minecraft block name.
/// Allows an optional integer parameter to follow the block name after a slash, e.g. "BlockName/#"
/// Messages warnings directly to the player in case of problems. </summary>
/// <param name="player"> Player to send warnings to (if any come up). </param>
/// <param name="allowNoneBlock"> Whether "none"/"skip" blocktype is allowed. </param>
/// <param name="block"> On success, this is set to the given block type.
/// On failure, this is set to Block.None </param>
/// <param name="param"> Optional integer parameter. Set to 1 if not given. </param>
/// <returns> True on success.
/// False if no more parameters were given;
/// if next parameter could not be parsed as a block name;
/// if optional parameter was given but was not an integer;
/// or if "none" blocktype was given and allowNoneBlock is false. </returns>
public bool NextBlockWithParam([CanBeNull] Player player, bool allowNoneBlock, out Block block, out int param)
{
block = Block.None;
param = 1;
string jointString = Next();
if (jointString == null)
{
return(false);
}
int slashIndex = jointString.IndexOf('/');
if (slashIndex != -1)
{
string blockName = jointString.Substring(0, slashIndex);
string paramString = jointString.Substring(slashIndex + 1);
if (Map.GetBlockByName(blockName, true, out block))
{
if (block == Block.None && !allowNoneBlock)
{
if (player != null)
{
player.Message("The \"none\" block is not allowed here");
}
}
else if (Int32.TryParse(paramString, out param))
{
return(true);
}
else if (player != null)
{
player.Message("Could not parse \"{0}\" as an integer.", paramString);
}
}
else if (player != null)
{
player.Message("Unrecognized blocktype \"{0}\"", blockName);
}
}
else
{
if (Map.GetBlockByName(jointString, true, out block))
{
if (block != Block.None || allowNoneBlock)
{
return(true);
}
else if (player != null)
{
player.Message("The \"none\" block is not allowed here");
}
}
else if (player != null)
{
player.Message("Unrecognized blocktype \"{0}\"", jointString);
}
}
return(false);
}
static void DoorCheckH(Player player, Command cmd)
{
player.Message("Left click to select a door.");
player.Info.isDoorChecking = true;
player.Info.doorCheckTime = DateTime.Now;
}
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 if (name.ToLower().StartsWith("msg="))
{
zone.Message = name.Substring(4) + " " + (cmd.NextAll() ?? "");
changesWereMade = true;
player.Message("Zedit: Custom denied messaged changed to '" + zone.Message + "'");
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 ZoneTestHandler(Player player, Command cmd)
{
player.SelectionStart(1, ZoneTestCallback, null);
player.Message("Click the block that you would like to test.");
}
/// <summary> Sends a global(white) chat. </summary>
/// <param name="player"> Player writing the message. </param>
/// <param name="rawMessage"> Message text. </param>
/// <returns> True if message was sent, false if it was cancelled by an event callback. </returns>
public static bool SendGlobal([NotNull] Player player, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
string OriginalMessage = rawMessage;
rawMessage = rawMessage.Replace("$name", player.ClassyName + "&f");
rawMessage = rawMessage.Replace("$kicks", player.Info.TimesKickedOthers.ToString());
rawMessage = rawMessage.Replace("$bans", player.Info.TimesBannedOthers.ToString());
rawMessage = rawMessage.Replace("$awesome", "It is my professional opinion, that " + ConfigKey.ServerName.GetString() + " is the best server on Minecraft");
rawMessage = rawMessage.Replace("$server", ConfigKey.ServerName.GetString());
rawMessage = rawMessage.Replace("$motd", ConfigKey.MOTD.GetString());
rawMessage = rawMessage.Replace("$date", DateTime.UtcNow.ToShortDateString());
rawMessage = rawMessage.Replace("$time", DateTime.Now.ToString());
rawMessage = rawMessage.Replace("$money", player.Info.Money.ToString());
rawMessage = rawMessage.Replace("$ass", "You, my good sir, are an &cAss&f");
rawMessage = rawMessage.Replace("$mad", "U &cmad&f, bro?");
rawMessage = rawMessage.Replace("$welcome", "Welcome to " + ConfigKey.ServerName.GetString());
rawMessage = rawMessage.Replace("$clap", "A round of applause might be appropriate, *claps*");
rawMessage = rawMessage.Replace("$website", ConfigKey.WebsiteURL.GetString());
rawMessage = rawMessage.Replace("$ws", ConfigKey.WebsiteURL.GetString());
if (ConfigKey.IRCBotEnabled.Enabled())
{
rawMessage = rawMessage.Replace("$irc", ConfigKey.IRCBotChannels.GetString());
}
else
{
rawMessage = rawMessage.Replace("$irc", "No IRC");
}
if (player.Can(Permission.UseColorCodes))
{
rawMessage = rawMessage.Replace("$lime", "&a"); //alternate color codes for ease if you can't remember the codes
rawMessage = rawMessage.Replace("$aqua", "&b");
rawMessage = rawMessage.Replace("$cyan", "&b");
rawMessage = rawMessage.Replace("$red", "&c");
rawMessage = rawMessage.Replace("$magenta", "&d");
rawMessage = rawMessage.Replace("$pink", "&d");
rawMessage = rawMessage.Replace("$yellow", "&e");
rawMessage = rawMessage.Replace("$white", "&f");
rawMessage = rawMessage.Replace("$navy", "&1");
rawMessage = rawMessage.Replace("$darkblue", "&1");
rawMessage = rawMessage.Replace("$green", "&2");
rawMessage = rawMessage.Replace("$teal", "&3");
rawMessage = rawMessage.Replace("$maroon", "&4");
rawMessage = rawMessage.Replace("$purple", "&5");
rawMessage = rawMessage.Replace("$olive", "&6");
rawMessage = rawMessage.Replace("$gold", "&6");
rawMessage = rawMessage.Replace("$silver", "&7");
rawMessage = rawMessage.Replace("$grey", "&8");
rawMessage = rawMessage.Replace("$gray", "&8");
rawMessage = rawMessage.Replace("$blue", "&9");
rawMessage = rawMessage.Replace("$black", "&0");
}
if (!player.Can(Permission.ChatWithCaps))
{
int caps = 0;
for (int i = 0; i < rawMessage.Length; i++)
{
if (Char.IsUpper(rawMessage[i]))
{
caps++;
if (caps > ConfigKey.MaxCaps.GetInt())
{
rawMessage = rawMessage.ToLower();
player.Message("Your message was changed to lowercase as it exceeded the maximum amount of capital letters.");
}
}
}
}
if (!player.Can(Permission.Swear))
{
if (!File.Exists(Paths.SwearWordsFileName))
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("#This txt file should be filled with bad words that you want to be filtered out");
sb.AppendLine("#I have included some examples, excuse my language :P");
sb.AppendLine("f**k");
sb.AppendLine("f*****g");
sb.AppendLine("f****d");
sb.AppendLine("dick");
sb.AppendLine("bitch");
sb.AppendLine("shit");
sb.AppendLine("s******g");
sb.AppendLine("s******d");
sb.AppendLine("c**t");
sb.AppendLine("nigger");
sb.AppendLine("wanker");
sb.AppendLine("wank");
sb.AppendLine("wanking");
sb.AppendLine("piss");
File.WriteAllText(Paths.SwearWordsFileName, sb.ToString());
}
string CensoredText = Color.ReplacePercentCodes(ConfigKey.SwearName.GetString()) + Color.White;
if (ConfigKey.SwearName.GetString() == null)
{
CensoredText = "&CBlock&F";
}
const string PatternTemplate = @"\b({0})(s?)\b";
const RegexOptions Options = RegexOptions.IgnoreCase;
if (Swears.Count == 0)
{
Swears.AddRange(File.ReadAllLines(Paths.SwearWordsFileName).
Where(line => line.StartsWith("#") == false || line.Trim().Equals(String.Empty)));
}
if (badWordMatchers == null)
{
badWordMatchers = Swears.
Select(x => new Regex(string.Format(PatternTemplate, x), Options));
}
string output = badWordMatchers.
Aggregate(rawMessage, (current, matcher) => matcher.Replace(current, CensoredText));
rawMessage = output;
}
/*if(player.World != null)
* {
* if(player.World.GameOn)
* {
* if(Games.MineChallenge.mode == Games.MineChallenge.GameMode.math1)
* {
* if(rawMessage == Games.MineChallenge.answer.ToString() && !Games.MineChallenge.completed.Contains(player))
* {
* Games.MineChallenge.completed.Add(player);
* player.Message("&8Correct!");
* if(player.World.blueTeam.Contains(player)) player.World.blueScore++;
* else player.World.redScore++;
* }
* else
* {
* player.Message("&8Incorrect");
* }
* return false;
* }
*
* if(Games.MineChallenge.mode == Games.MineChallenge.GameMode.math2)
* {
* if(rawMessage == Games.MineChallenge.answer.ToString() && !Games.MineChallenge.completed.Contains(player))
* {
* Games.MineChallenge.completed.Add(player);
* player.Message("&8Correct!");
* if(player.World.blueTeam.Contains(player)) player.World.blueScore++;
* else player.World.redScore++;
* }
* else
* {
* player.Message("&8Incorrect");
* }
* return false;
* }
* }
* }*/
var recepientList = Server.Players.NotIgnoring(player); //if(player.World.WorldOnlyChat) recepientList = player.World.Players.NotIgnoring(player);
string formattedMessage = String.Format("{0}&F: {1}",
player.ClassyName,
rawMessage);
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Global,
recepientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.GlobalChat,
"{0}: {1}", player.Name, OriginalMessage);
return(true);
}
private static void TimerHandler(Player player, Command cmd)
{
string param = cmd.Next();
// List timers
if (param == null)
{
ChatTimer[] list = ChatTimer.TimerList.OrderBy(timer => timer.TimeLeft).ToArray();
if (list.Length == 0)
{
player.Message("&SNo timers running.");
}
else
{
player.Message("&WThere are {0} timers running:", list.Length);
foreach (ChatTimer timer in list)
{
player.Message("#{0} \"{1}&S\" (started by {2}, {3} left)",
timer.Id, timer.Message, timer.StartedBy, timer.TimeLeft.ToMiniString());
}
}
return;
}
// Abort a timer
if (param.Equals("abort", StringComparison.OrdinalIgnoreCase))
{
int timerId;
if (cmd.NextInt(out timerId))
{
ChatTimer timer = ChatTimer.FindTimerById(timerId);
if (timer == null || !timer.IsRunning)
{
player.Message("&WTimer #{0} does not exist.", timerId);
}
else
{
timer.Stop();
string abortMsg = String.Format("&Y(Timer) {0}&Y aborted a timer with {1} left: {2}",
player.ClassyName, timer.TimeLeft.ToMiniString(), timer.Message);
Chat.SendSay(player, abortMsg);
}
}
else
{
CdTimer.PrintUsage(player);
}
return;
}
// Start a timer
if (player.Info.IsMuted)
{
player.MessageMuted();
return;
}
if (player.DetectChatSpam())
{
return;
}
TimeSpan duration;
if (!param.TryParseMiniTimespan(out duration))
{
CdTimer.PrintUsage(player);
return;
}
if (duration > DateTimeUtil.MaxTimeSpan)
{
player.MessageMaxTimeSpan();
return;
}
if (duration < ChatTimer.MinDuration)
{
player.Message("&WTimer: Must be at least 1 second.");
return;
}
string sayMessage;
string message = cmd.NextAll();
if (String.IsNullOrEmpty(message))
{
sayMessage = String.Format("&Y(Timer) {0}&Y started a {1} timer",
player.ClassyName,
duration.ToMiniString());
}
else
{
sayMessage = String.Format("&Y(Timer) {0}&Y started a {1} timer: {2}",
player.ClassyName,
duration.ToMiniString(),
message);
}
Chat.SendSay(player, sayMessage);
ChatTimer.Start(duration, message, player.Name);
}
private static void GlobalHandler(Player player, Command cmd)
{
var sendList = Server.Players.Where(p => p.GlobalChatAllowed && !p.IsDeaf);
string msg = cmd.NextAll();
if (!ConfigKey.GlobalChat.Enabled())
{
player.Message("&WGlobal Chat is disabled on this server.");
return;
}
if (!GlobalChat.GlobalThread.GcReady)
{
player.Message("&WGlobal Chat is not connected.");
return;
}
string reason;
if (Server.GlobalChatBans.TryGetValue(player.Name.ToLower(), out reason))
{
player.Message("You were &cbanned &efrom &gglobal chat&e by &h{0}&e", reason);
player.Message("You can appeal your ban at &9http://atomiccraft.net");
return;
}
switch (msg)
{
case "reconnect":
if (player.Can(Permission.ManageGlobalChat))
{
if (GlobalChat.GlobalThread.GcReady)
{
player.Message("&WThis server is currently connected to global chat.");
return;
}
GlobalChat.GlobalThread.GcReady = true;
Server.Message(
"&WAttempting to connect to AtomicCraft Global Chat Network. This may take a few seconds.");
GlobalChat.Init();
GlobalChat.Start();
return;
}
break;
case "rules":
if (!player.GlobalChatAllowed)
{
player.Message(
"&RRules: No spamming and no advertising. All chat rules that apply to your server apply here.\n" +
"&WServer staff have the right to kick you.\n" +
"&SBy using the Global Chat, you accept these conditions.\n" +
"&SType &H/global accept &Sto connect");
return;
}
if (player.GlobalChatAllowed)
{
player.Message(
"&RRules: No spamming and no advertising. All chat rules that apply to your server apply here.\n" +
"&WServer staff have the right to kick you.\n" +
"&SBy using the Global Chat, you accept these conditions.");
return;
}
break;
case "accept":
if (!player.GlobalChatAllowed)
{
player.GlobalChatAllowed = true;
player.Message("&SThank you for accepting the global chat rules.\n" +
"&WYou now have global chat enabled.");
GlobalChat.GlobalThread.SendChannelMessage(player.ClassyName + " &Sjoined global chat.");
sendList.Message(player.ClassyName + " &Sjoined global chat.");
return;
}
if (player.GlobalChatAllowed)
{
player.Message("&WYou have already accepted the global chat rules.");
return;
}
break;
case "ignore":
if (!player.GlobalChatIgnore)
{
player.GlobalChatIgnore = true;
player.Message("&WYou have disconnected from global chat.");
sendList.Message(player.ClassyName + " &Sdisconnected from global chat.");
GlobalChat.GlobalThread.SendChannelMessage(player.ClassyName +
" &Sdisconnected from global chat.");
return;
}
break;
case "help":
CdGlobal.PrintUsage(player);
break;
}
if (player.Info.IsMuted)
{
player.MessageMuted();
return;
}
if ((!player.GlobalChatAllowed) && ((msg.Length < 1) || (msg.Length > 1)))
{
player.Message("&WYou must read and accept the global chat rules. Type &H/global rules");
return;
}
if ((player.GlobalChatAllowed) && string.IsNullOrEmpty(msg))
{
player.Message("&WYou must enter a message!");
return;
}
if (!player.GlobalChatAllowed)
{
return;
}
string pMsg = player.ClassyName + Color.White + ": " + msg;
msg = player.ClassyName + Color.Black + ": " + msg;
sendList.Message("&g[Global] " + pMsg); //send the white message to Server
msg = Color.MinecraftToIrcColors(msg);
msg = Color.ReplacePercentCodes(msg);
GlobalChat.GlobalThread.SendChannelMessage(msg); //send the black message to GC
}
public static PlayerInfo FindPlayerInfoOrPrintMatches([NotNull] Player player, [NotNull] string partialName)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (partialName == null)
{
throw new ArgumentNullException("partialName");
}
CheckIfLoaded();
// If name starts with '!', return matches for online players only
if (partialName.Length > 1 && partialName[0] == '!')
{
partialName = partialName.Substring(1);
Player targetPlayer = Server.FindPlayerOrPrintMatches(player, partialName, false, true);
if (targetPlayer != null)
{
return(targetPlayer.Info);
}
else
{
player.Message("No online players found matching \"{0}\"", partialName);
return(null);
}
}
// Repeat last-used player name
if (partialName == "-")
{
if (player.LastUsedPlayerName != null)
{
partialName = player.LastUsedPlayerName;
}
else
{
player.Message("Cannot repeat player name: you haven't used any names yet.");
return(null);
}
}
// Make sure player name is valid
if (!Player.ContainsValidCharacters(partialName))
{
player.MessageInvalidPlayerName(partialName);
return(null);
}
// Search for exact matches first
PlayerInfo target = FindPlayerInfoExact(partialName);
// If no exact match was found, look for partial matches
if (target == null)
{
PlayerInfo[] targets = FindPlayers(partialName);
if (targets.Length == 0)
{
// No matches
player.MessageNoPlayer(partialName);
return(null);
}
else if (targets.Length > 1)
{
// More than one match
Array.Sort(targets, new PlayerInfoComparer(player));
player.MessageManyMatches("player", targets.Take(25).ToArray());
return(null);
} // else: one match!
target = targets[0];
}
// If a single name has been found, set it as LastUsedPlayerName
player.LastUsedPlayerName = target.Name;
return(target);
}
public static string FindMapFile([NotNull] Player player, [NotNull] string fileName)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (fileName == null)
{
throw new ArgumentNullException("fileName");
}
// Check if path contains missing drives or invalid characters
if (!Paths.IsValidPath(fileName))
{
player.Message("Invalid filename or path.");
return(null);
}
// Look for the file
string sourceFullFileName = Path.Combine(Paths.MapPath, fileName);
if (!File.Exists(sourceFullFileName) && !Directory.Exists(sourceFullFileName))
{
if (File.Exists(sourceFullFileName + ".fcm"))
{
// Try with extension added
sourceFullFileName += ".fcm";
}
else if (MonoCompat.IsCaseSensitive)
{
try {
// If we're on a case-sensitive OS, try case-insensitive search
FileInfo[] candidates = Paths.FindFiles(sourceFullFileName + ".fcm");
if (candidates.Length == 0)
{
candidates = Paths.FindFiles(sourceFullFileName);
}
if (candidates.Length == 0)
{
player.Message("File/directory not found: {0}", fileName);
}
else if (candidates.Length == 1)
{
player.Message("Filenames are case-sensitive! Did you mean to load \"{0}\"?", candidates[0].Name);
}
else
{
player.Message("Filenames are case-sensitive! Did you mean to load one of these: {0}",
String.Join(", ", candidates.Select(c => c.Name).ToArray()));
}
} catch (DirectoryNotFoundException ex) {
player.Message(ex.Message);
}
return(null);
}
else
{
// Nothing found!
player.Message("File/directory not found: {0}", fileName);
return(null);
}
}
// Make sure that the given file is within the map directory
if (!Paths.Contains(Paths.MapPath, sourceFullFileName))
{
player.MessageUnsafePath();
return(null);
}
return(sourceFullFileName);
}
public static void testFunction(Player player)
{
player.Message("This is a legendcraft test function");
}
public static void RealmCreate(Player player, Command cmd, string themeName, string templateName)
{
MapGenTemplate template;
MapGenTheme theme;
int wx, wy, height = 128;
if (!(cmd.NextInt(out wx) && cmd.NextInt(out wy) && cmd.NextInt(out height)))
{
if (player.World != null)
{
wx = 128;
wy = 128;
height = 128;
}
else
{
player.Message("When used from console, /gen requires map dimensions.");
return;
}
cmd.Rewind();
cmd.Next();
cmd.Next();
}
if (!Map.IsValidDimension(wx))
{
player.Message("Cannot make map with width {0}: dimensions must be multiples of 16.", wx);
return;
}
else if (!Map.IsValidDimension(wy))
{
player.Message("Cannot make map with length {0}: dimensions must be multiples of 16.", wy);
return;
}
else if (!Map.IsValidDimension(height))
{
player.Message("Cannot make map with height {0}: dimensions must be multiples of 16.", height);
return;
}
string fileName = player.Name;
if (player.Name.Contains('.'))
{
fileName = player.Name.Replace(".", "-"); //support for email names
}
string fullFileName = null;
if (fileName == null)
{
if (player.World == null)
{
player.Message("When used from console, /gen requires FileName.");
return;
}
if (!cmd.IsConfirmed)
{
player.Confirm(cmd, "Replace this realm's map with a generated one?");
return;
}
}
else
{
fileName = fileName.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
if (!fileName.EndsWith(".fcm", StringComparison.OrdinalIgnoreCase))
{
fileName += ".fcm";
}
fullFileName = Path.Combine(Paths.MapPath, fileName);
if (!Paths.IsValidPath(fullFileName))
{
player.Message("Invalid filename.");
return;
}
if (!Paths.Contains(Paths.MapPath, fullFileName))
{
player.MessageUnsafePath();
return;
}
string dirName = fullFileName.Substring(0, fullFileName.LastIndexOf(Path.DirectorySeparatorChar));
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
if (!cmd.IsConfirmed && File.Exists(fullFileName))
{
player.Confirm(cmd, "The mapfile \"{0}\" already exists. Overwrite?", fileName);
return;
}
}
bool noTrees;
if (themeName.Equals("grass", StringComparison.OrdinalIgnoreCase))
{
theme = MapGenTheme.Forest;
noTrees = true;
}
else
{
try
{
theme = (MapGenTheme)Enum.Parse(typeof(MapGenTheme), themeName, true);
noTrees = (theme != MapGenTheme.Forest);
}
catch (Exception)
{
player.MessageNow("Unrecognized theme \"{0}\". Available themes are: Grass, {1}",
themeName,
String.Join(", ", Enum.GetNames(typeof(MapGenTheme))));
return;
}
}
try
{
template = (MapGenTemplate)Enum.Parse(typeof(MapGenTemplate), templateName, true);
}
catch (Exception)
{
player.Message("Unrecognized template \"{0}\". Available templates are: {1}",
templateName,
String.Join(", ", Enum.GetNames(typeof(MapGenTemplate))));
return;
}
if (!Enum.IsDefined(typeof(MapGenTheme), theme) || !Enum.IsDefined(typeof(MapGenTemplate), template))
{
return;
}
MapGeneratorArgs args = MapGenerator.MakeTemplate(template);
args.MapWidth = wx;
args.MapLength = wy;
args.MapHeight = height;
args.MaxHeight = (int)(args.MaxHeight / 80d * height);
args.MaxDepth = (int)(args.MaxDepth / 80d * height);
args.Theme = theme;
args.AddTrees = !noTrees;
Map map;
try
{
if (theme == MapGenTheme.Forest && noTrees)
{
player.MessageNow("Generating Grass {0}...", template);
}
else
{
player.MessageNow("Generating {0} {1}...", theme, template);
}
if (theme == MapGenTheme.Forest && noTrees && template == MapGenTemplate.Flat)
{
map = MapGenerator.GenerateFlatgrass(args.MapWidth, args.MapLength, args.MapHeight);
}
else
{
MapGenerator generator = new MapGenerator(args);
map = generator.Generate();
}
}
catch (Exception ex)
{
Logger.Log(LogType.Error, "MapGenerator: Generation failed: {0}",
ex);
player.MessageNow("&WAn error occured while generating the map.");
return;
}
if (fileName != null)
{
if (map.Save(fullFileName))
{
player.MessageNow("Generation done. Saved to {0}", fileName);
}
else
{
player.Message("&WAn error occured while saving generated map to {0}", fileName);
}
}
else
{
player.MessageNow("Generation done. Changing map...");
player.World.ChangeMap(map);
}
}
static void DrawEllipsoid(Player player, Position[] marks, object tag)
{
player.drawingInProgress = true;
Block drawBlock = (Block)tag;
// find start/end coordinates
int sx = Math.Min(marks[0].x, marks[1].x);
int ex = Math.Max(marks[0].x, marks[1].x);
int sy = Math.Min(marks[0].y, marks[1].y);
int ey = Math.Max(marks[0].y, marks[1].y);
int sh = Math.Min(marks[0].h, marks[1].h);
int eh = Math.Max(marks[0].h, marks[1].h);
int blocks;
byte block;
int step = 8;
blocks = (ex - sx + 1) * (ey - sy + 1) * (eh - sh + 1);
if (blocks > 2000000)
{
player.Message("NOTE: This draw command is too massive to undo.");
}
// find axis lengths
double rx = (ex - sx + 1) / 2 + .25;
double ry = (ey - sy + 1) / 2 + .25;
double rh = (eh - sh + 1) / 2 + .25;
double rx2 = 1 / (rx * rx);
double ry2 = 1 / (ry * ry);
double rh2 = 1 / (rh * rh);
// find center points
double cx = (ex + sx) / 2;
double cy = (ey + sy) / 2;
double ch = (eh + sh) / 2;
// prepare to draw
player.drawUndoBuffer.Clear();
blocks = (int)(Math.PI * 0.75 * rx * ry * rh);
if (blocks > 2000000)
{
player.Message("NOTE: This draw command is too massive to undo.");
}
for (int x = sx; x <= ex; x += step)
{
for (int y = sy; y <= ey; y += step)
{
for (int h = sh; h <= eh; h += step)
{
for (int h3 = 0; h3 < step && h + h3 <= eh; h3++)
{
for (int y3 = 0; y3 < step && y + y3 <= ey; y3++)
{
for (int x3 = 0; x3 < step && x + x3 <= ex; x3++)
{
// get relative coordinates
double dx = (x + x3 - cx);
double dy = (y + y3 - cy);
double dh = (h + h3 - ch);
// test if it's inside ellipse
if ((dx * dx) * rx2 + (dy * dy) * ry2 + (dh * dh) * rh2 <= 1)
{
block = player.world.map.GetBlock(x + x3, y + y3, h + h3);
if (block == (byte)drawBlock)
{
continue;
}
if (block == (byte)Block.Admincrete && !player.Can(Permissions.DeleteAdmincrete))
{
continue;
}
player.drawUndoBuffer.Enqueue(new BlockUpdate(Player.Console, x + x3, y + y3, h + h3, block));
player.world.map.QueueUpdate(new BlockUpdate(Player.Console, x + x3, y + y3, h + h3, (byte)drawBlock));
}
}
}
}
}
}
}
player.drawingInProgress = false;
player.Message("Drawing " + blocks + " blocks... The map is now being updated.");
player.world.log.Log("{0} initiated drawing a cuboid containing {1} blocks of type {2}.", LogType.UserActivity,
player.name,
blocks,
drawBlock.ToString());
GC.Collect();
}
public static PlayerInfo FindPlayerInfoOrPrintMatches([NotNull] Player player, [NotNull] string namePart,
SearchOptions options)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (namePart == null)
{
throw new ArgumentNullException("namePart");
}
CheckIfLoaded();
bool includeSelf = (options & SearchOptions.IncludeSelf) != 0;
bool returnSelf = (options & SearchOptions.ReturnSelfIfOnlyMatch) != 0;
// If name starts with '!', return matches for online players only
if (namePart.Length > 1 && namePart[0] == '!')
{
namePart = namePart.Substring(1);
Player targetPlayer = Server.FindPlayerOrPrintMatches(player, namePart, options);
if (targetPlayer != null)
{
return(targetPlayer.Info);
}
else
{
player.Message("No online players found matching \"{0}\"", namePart);
return(null);
}
}
// Repeat last-used player name
if (namePart == "-")
{
if (player.LastUsedPlayerName != null)
{
namePart = player.LastUsedPlayerName;
}
else
{
player.Message("Cannot repeat player name: you haven't used any names yet.");
return(null);
}
}
// Make sure player name is valid
if (!Player.ContainsValidCharacters(namePart))
{
player.MessageInvalidPlayerName(namePart);
return(null);
}
// Search for exact matches first
PlayerInfo target = FindPlayerInfoExact(namePart);
// If no exact match was found, look for partial matches
if (target == null || target == player.Info && !includeSelf)
{
PlayerInfo[] targets = FindPlayers(namePart);
if (!includeSelf)
{
// special handling if IncludeSelf flag is not set
if (targets.Length > 1)
{
targets = targets.Where(p => p != player.Info).ToArray();
}
else if (!returnSelf && targets.Length == 1 && targets[0] == player.Info)
{
// special handling if ReturnSelfIfOnlyMatch flag is not set
targets = new PlayerInfo[0];
}
}
if (targets.Length == 0)
{
// No matches
player.MessageNoPlayer(namePart);
return(null);
}
else if (targets.Length > 1)
{
// More than one match
Array.Sort(targets, new PlayerInfoComparer(player));
player.MessageManyMatches("player", targets.Take(MatchesToPrint).ToArray());
return(null);
} // else: one match!
target = targets[0];
}
// If a single name has been found, set it as LastUsedPlayerName
if (includeSelf || target != player.Info)
{
player.LastUsedPlayerName = target.Name;
}
return(target);
}
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 (!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.",
newZone.Controller.MinRank.ClassyName, info.ClassyName);
}
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;
}
if (name.ToLower().StartsWith("msg="))
{
newZone.Message = name.Substring(4) + " " + (cmd.NextAll() ?? "");
player.Message("Zone: Custom denied messaged changed to '" + newZone.Message + "'");
break;
}
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;
}
else
{
player.MessageNoRank(rankName);
return;
}
}
player.Message("Zone " + newZone.ClassyName + "&S: Place a block or type &H/Mark&S to use your location.");
player.SelectionStart(2, ZoneAddCallback, newZone, CdZoneAdd.Permissions);
}
public static void RevertNames() //reverts names for online players. offline players get reverted upon leaving the game
{
List <PlayerInfo> TDPlayers = new List <PlayerInfo>(PlayerDB.PlayerInfoList.Where(r => (r.isOnBlueTeam || r.isOnRedTeam) && r.IsOnline).ToArray());
for (int i = 0; i < TDPlayers.Count(); i++)
{
string p1 = TDPlayers[i].Name.ToString();
PlayerInfo pI = PlayerDB.FindPlayerInfoExact(p1);
Player p = pI.PlayerObject;
if (p != null)
{
p.iName = null;
pI.tempDisplayedName = null;
pI.isOnRedTeam = false;
pI.isOnBlueTeam = false;
pI.isPlayingTD = false;
pI.Health = 100;
p.entityChanged = true;
//reset all special messages
if (p.SupportsMessageTypes)
{
p.Send(PacketWriter.MakeSpecialMessage((byte)100, "&f"));
p.Send(PacketWriter.MakeSpecialMessage((byte)1, "&f"));
p.Send(PacketWriter.MakeSpecialMessage((byte)2, "&f"));
}
//undo gunmode (taken from GunHandler.cs)
p.GunMode = false;
try
{
foreach (Vector3I block in p.GunCache.Values)
{
p.Send(PacketWriter.MakeSetBlock(block.X, block.Y, block.Z, p.WorldMap.GetBlock(block)));
Vector3I removed;
p.GunCache.TryRemove(block.ToString(), out removed);
}
if (p.bluePortal.Count > 0)
{
int j = 0;
foreach (Vector3I block in p.bluePortal)
{
if (p.WorldMap != null && p.World.IsLoaded)
{
p.WorldMap.QueueUpdate(new BlockUpdate(null, block, p.blueOld[j]));
j++;
}
}
p.blueOld.Clear();
p.bluePortal.Clear();
}
if (p.orangePortal.Count > 0)
{
int j = 0;
foreach (Vector3I block in p.orangePortal)
{
if (p.WorldMap != null && p.World.IsLoaded)
{
p.WorldMap.QueueUpdate(new BlockUpdate(null, block, p.orangeOld[j]));
j++;
}
}
p.orangeOld.Clear();
p.orangePortal.Clear();
}
}
catch (Exception ex)
{
Logger.Log(LogType.SeriousError, "" + ex);
}
if (p.IsOnline)
{
p.Message("Your status has been reverted.");
}
}
}
}
static void ZoneInfoHandler(Player player, Command cmd)
{
string zoneName = cmd.Next();
if (zoneName == null)
{
player.Message("No zone name specified. See &H/Help ZInfo");
return;
}
Zone zone = player.WorldMap.Zones.Find(zoneName);
if (zone == null)
{
player.MessageNoZone(zoneName);
return;
}
player.Message("About zone \"{0}\": size {1} x {2} x {3}, contains {4} blocks, editable by {5}+.",
zone.Name,
zone.Bounds.Width, zone.Bounds.Length, zone.Bounds.Height,
zone.Bounds.Volume,
zone.Controller.MinRank.ClassyName);
player.Message(" Zone center is at ({0},{1},{2}).",
(zone.Bounds.XMin + zone.Bounds.XMax) / 2,
(zone.Bounds.YMin + zone.Bounds.YMax) / 2,
(zone.Bounds.ZMin + zone.Bounds.ZMax) / 2);
if (zone.CreatedBy != null)
{
player.Message(" Zone created by {0}&S on {1:MMM d} at {1:h:mm} ({2} ago).",
zone.CreatedByClassy,
zone.CreatedDate,
DateTime.UtcNow.Subtract(zone.CreatedDate).ToMiniString());
}
if (zone.EditedBy != null)
{
player.Message(" Zone last edited by {0}&S on {1:MMM d} at {1:h:mm} ({2}d {3}h ago).",
zone.EditedByClassy,
zone.EditedDate,
DateTime.UtcNow.Subtract(zone.EditedDate).Days,
DateTime.UtcNow.Subtract(zone.EditedDate).Hours);
}
PlayerExceptions zoneExceptions = zone.ExceptionList;
if (zoneExceptions.Included.Length > 0)
{
player.Message(" Zone whitelist includes: {0}",
zoneExceptions.Included.JoinToClassyString());
}
if (zoneExceptions.Excluded.Length > 0)
{
player.Message(" Zone blacklist excludes: {0}",
zoneExceptions.Excluded.JoinToClassyString());
}
if (null != zone.Message)
{
player.Message(" Zone has custom deny build message: " + zone.Message);
}
else
{
player.Message(" Zone has no custom deny build message");
}
}
public static void GunHandler(Player player, Command cmd)
{
//to prevent players from doing /gun during a TDM game that arent actually playing in
if (player.World.gameMode == GameMode.TeamDeathMatch && !player.Info.isPlayingTD)
{
player.Message("Players who are not playing Team DeathMatch can only spectate.");
return;
}
if (player.Info.isPlayingCTF && player.Info.gunDisarmed)
{
player.Message("You are currently disarmed. You cannot use a gun until the disarm powerup has worn off.");
return;
}
if (player.GunMode)
{
player.GunMode = false;
try
{
foreach (Vector3I block in player.GunCache.Values)
{
player.Send(PacketWriter.MakeSetBlock(block.X, block.Y, block.Z, player.WorldMap.GetBlock(block)));
Vector3I removed;
player.GunCache.TryRemove(block.ToString(), out removed);
}
if (player.bluePortal.Count > 0)
{
int i = 0;
foreach (Vector3I block in player.bluePortal)
{
if (player.WorldMap != null && player.World.IsLoaded)
{
player.WorldMap.QueueUpdate(new BlockUpdate(null, block, player.blueOld[i]));
i++;
}
}
player.blueOld.Clear();
player.bluePortal.Clear();
}
if (player.orangePortal.Count > 0)
{
int i = 0;
foreach (Vector3I block in player.orangePortal)
{
if (player.WorldMap != null && player.World.IsLoaded)
{
player.WorldMap.QueueUpdate(new BlockUpdate(null, block, player.orangeOld[i]));
i++;
}
}
player.orangeOld.Clear();
player.orangePortal.Clear();
}
player.Message("&SGunMode deactivated");
}
catch (Exception ex)
{
Logger.Log(LogType.SeriousError, "" + ex);
}
}
else
{
if (!player.World.gunPhysics)
{
player.Message("&WGun physics are disabled on this world");
return;
}
player.GunMode = true;
GunGlassTimer timer = new GunGlassTimer(player);
timer.Start();
player.Message("&SGunMode activated. Fire at will!");
}
}
static void ZoneRenameHandler(Player player, Command cmd)
{
World playerWorld = player.World;
if (playerWorld == null)
{
PlayerOpException.ThrowNoWorld(player);
}
// make sure that both parameters are given
string oldName = cmd.Next();
string newName = cmd.Next();
if (oldName == null || newName == null)
{
CdZoneRename.PrintUsage(player);
return;
}
// make sure that the new name is valid
if (!World.IsValidName(newName))
{
player.Message("\"{0}\" is not a valid zone name", newName);
return;
}
// find the old zone
var zones = player.WorldMap.Zones;
Zone oldZone = zones.Find(oldName);
if (oldZone == null)
{
player.MessageNoZone(oldName);
return;
}
// Check if a zone with "newName" name already exists
Zone newZone = zones.FindExact(newName);
if (newZone != null && newZone != oldZone)
{
player.Message("A zone with the name \"{0}\" already exists.", newName);
return;
}
// check if any change is needed
string fullOldName = oldZone.Name;
if (fullOldName == newName)
{
player.Message("The zone is already named \"{0}\"", fullOldName);
return;
}
// actually rename the zone
zones.Rename(oldZone, newName);
// announce the rename
playerWorld.Players.Message("&SZone \"{0}\" was renamed to \"{1}&S\" by {2}",
fullOldName, oldZone.ClassyName, player.ClassyName);
Logger.Log(LogType.UserActivity,
"Player {0} renamed zone \"{1}\" to \"{2}\" on world {3}",
player.Name, fullOldName, newName, playerWorld.Name);
}
static void ZoneRemoveHandler(Player player, CommandReader cmd)
{
if (player.World == null)
{
PlayerOpException.ThrowNoWorld(player);
}
string zoneName = cmd.Next();
if (zoneName == null || cmd.HasNext)
{
CdZoneRemove.PrintUsage(player);
return;
}
if (zoneName == "*")
{
if (!cmd.IsConfirmed)
{
Logger.Log(LogType.UserActivity,
"ZRemove: Asked {0} to confirm removing all zones on world {1}",
player.Name, player.World.Name);
player.Confirm(cmd,
"&WRemove ALL zones on this world ({0}&W)? This cannot be undone.&S",
player.World.ClassyName);
return;
}
player.WorldMap.Zones.Clear();
Logger.Log(LogType.UserActivity,
"Player {0} removed all zones on world {1}",
player.Name, player.World.Name);
Server.Message("Player {0}&S removed all zones on world {1}",
player.ClassyName, player.World.ClassyName);
return;
}
ZoneCollection zones = player.WorldMap.Zones;
Zone zone = zones.Find(zoneName);
if (zone != null)
{
if (!player.Info.Rank.AllowSecurityCircumvention)
{
switch (zone.Controller.CheckDetailed(player.Info))
{
case SecurityCheckResult.BlackListed:
player.Message("You are not allowed to remove zone {0}: you are blacklisted.", zone.ClassyName);
return;
case SecurityCheckResult.RankTooLow:
player.Message("You are not allowed to remove zone {0}.", zone.ClassyName);
return;
}
}
if (!cmd.IsConfirmed)
{
Logger.Log(LogType.UserActivity,
"ZRemove: Asked {0} to confirm removing zone {1} from world {2}",
player.Name, zone.Name, player.World.Name);
player.Confirm(cmd, "Remove zone {0}&S?", zone.ClassyName);
return;
}
if (zones.Remove(zone.Name))
{
Logger.Log(LogType.UserActivity,
"Player {0} removed zone {1} from world {2}",
player.Name, zone.Name, player.World.Name);
player.Message("Zone \"{0}\" removed.", zone.Name);
}
}
else
{
player.MessageNoZone(zoneName);
}
}
public static void ClearParametrization(Player p, Command cmd)
{
p.PublicAuxStateObjects.Remove(CoordsStorageName);
p.PublicAuxStateObjects.Remove(ParamsStorageName);
p.Message("Prepared parametrization data cleared");
}
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();
}
}
public static void PowerUp(Player p)
{
int GetPowerUp = (new Random()).Next(1, 4);
if (GetPowerUp < 3)
{
return;
}
int choosePowerUp = (new Random()).Next(1, 19);
//decide which powerup to use, certain powerups have a higher chance such as first aid kit and dodge as opposed to rarer ones like holy blessing
switch (choosePowerUp)
{
case 1:
case 2:
case 3:
//first aid kit - heal user for 50 hp
world_.Players.Message("&f{0} has discovered a &aFirst Aid Kit&f!", p.Name);
world_.Players.Message("&f{0} has been healed for 50 hp.", p.Name);
//set health to 100, make sure it doesn't overflow
p.Info.Health += 50;
if (p.Info.Health > 100)
{
p.Info.Health = 100;
}
string healthBar = "&f[&a--------&f]";
if (p.Info.Health == 75)
{
healthBar = "&f[&a------&8--&f]";
}
else if (p.Info.Health == 50)
{
healthBar = "&f[&e----&8----&f]";
}
else if (p.Info.Health == 25)
{
healthBar = "&f[&c--&8------&f]";
}
else
{
healthBar = "&f[&8--------&f]";
}
if (p.SupportsMessageTypes)
{
p.Send(PacketWriter.MakeSpecialMessage((byte)1, healthBar));
}
else
{
p.Message("You have " + p.Info.Health.ToString() + " health.");
}
break;
case 4:
case 5:
//penicillin - heal user for 100 hp
world_.Players.Message("&f{0} has discovered a &aPenicillin Case&f!", p.Name);
world_.Players.Message("&f{0} has been healed for 100 hp.", p.Name);
p.Info.Health = 100;
if (p.SupportsMessageTypes)
{
p.Send(PacketWriter.MakeSpecialMessage((byte)1, "&f[&8--------&f]"));
}
else
{
p.Message("You have " + p.Info.Health.ToString() + " health.");
}
break;
case 6:
case 7:
//disarm
world_.Players.Message("&f{0} has discovered a &aDisarm Spell&f!", p.Name);
if (p.Info.CTFBlueTeam)
{
world_.Players.Message("The red team has lost all weaponry for 30 seconds!");
foreach (Player pl in world_.Players)
{
if (pl.Info.CTFRedTeam)
{
pl.Info.gunDisarmed = true;
pl.Info.stabDisarmed = true;
pl.GunMode = false;
}
}
RedDisarmed = DateTime.UtcNow;
}
else
{
world_.Players.Message("The blue team has lost all weaponry for 30 seconds!");
foreach (Player pl in world_.Players)
{
if (pl.Info.CTFBlueTeam)
{
pl.Info.gunDisarmed = true;
pl.Info.stabDisarmed = true;
pl.GunMode = false;
}
}
BlueDisarmed = DateTime.UtcNow;
}
break;
case 8:
case 9:
//blades of fury
world_.Players.Message("&f{0} has discovered the &aBlades of Fury&f!", p.Name);
if (p.Info.CTFBlueTeam)
{
world_.Players.Message("The red team is unable to backstab for 1 minute!");
world_.Players.Message("The blue team can now stab the red team from any angle for 1 minute!");
foreach (Player pl in world_.Players)
{
if (pl.Info.CTFBlueTeam)
{
pl.Info.stabAnywhere = true;
}
else
{
pl.Info.stabDisarmed = true;
}
}
RedBOFdebuff = DateTime.UtcNow;
}
else
{
world_.Players.Message("The blue team is unable to backstab for 1 minute!");
world_.Players.Message("The red team can now stab the blue team from any angle for 1 minute!");
foreach (Player pl in world_.Players)
{
if (pl.Info.CTFRedTeam)
{
pl.Info.stabAnywhere = true;
}
else
{
pl.Info.stabDisarmed = true;
}
}
RedBOFdebuff = DateTime.UtcNow;
}
break;
case 10:
case 11:
//war cry
world_.Players.Message("&f{0} has discovered their &aWar Cry&f!", p.Name);
if (p.Info.CTFBlueTeam)
{
world_.Players.Message("The red team has been frightened back into their spawn!");
foreach (Player pl in world_.Players)
{
if (pl.Info.CTFRedTeam)
{
pl.TeleportTo(world_.redCTFSpawn.ToPlayerCoords());
}
}
}
else
{
world_.Players.Message("The blue team has been frightened back into their spawn!");
foreach (Player pl in world_.Players)
{
if (pl.Info.CTFBlueTeam)
{
pl.TeleportTo(world_.blueCTFSpawn.ToPlayerCoords());
}
}
}
break;
case 12:
case 13:
case 14:
//strengthen
world_.Players.Message("&f{0} has discovered a &aStrength Pack&f!", p.Name);
world_.Players.Message("&f{0}'s gun now deals twice the damage for the next minute!", p.Name);
p.Info.strengthened = true;
p.Info.strengthTime = DateTime.UtcNow;
break;
case 15:
case 16:
case 17:
//dodge
world_.Players.Message("&f{0} has discovered a new &aDodging Technique&f!", p.Name);
world_.Players.Message("&f{0}'s has a 50% chance to dodge incomming gun attacks for the next minute!", p.Name);
p.Info.canDodge = true;
p.Info.dodgeTime = DateTime.UtcNow;
break;
case 18:
//holy blessing (rarest and most treasured power up, yet easiest to code :P )
world_.Players.Message("&f{0} has discovered the rare &aHoly Blessing&f!!!", p.Name);
if (p.Info.CTFBlueTeam)
{
world_.Players.Message("The Blue Team has been granted 1 point.");
redScore++;
}
else
{
world_.Players.Message("The Red Team has been granted 1 point.");
blueScore++;
}
foreach (Player pl in world_.Players)
{
if (pl.SupportsMessageTypes)
{
pl.Send(PacketWriter.MakeSpecialMessage((byte)2, "&cRed&f: " + redScore + ",&1 Blue&f: " + blueScore));
}
else
{
pl.Message("The score is now &cRed&f: {0} and &1Blue&f: {1}.", redScore, blueScore);
}
}
break;
default:
//no power up 4 u
break;
}
}
public static void RealmLoad(Player player, Command cmd, string fileName, string worldName)
{
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;
}
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 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();
}
public static void GunHandler(Player player, Command cmd)
{
if (player.GunMode)
{
player.GunMode = false;
try
{
foreach (Vector3I block in player.GunCache.Values)
{
player.Send(PacketWriter.MakeSetBlock(block.X, block.Y, block.Z, player.WorldMap.GetBlock(block)));
Vector3I removed;
player.GunCache.TryRemove(block.ToString(), out removed);
}
if (player.bluePortal.Count > 0)
{
int i = 0;
foreach (Vector3I block in player.bluePortal)
{
if (player.WorldMap != null && player.World.IsLoaded)
{
player.WorldMap.QueueUpdate(new BlockUpdate(null, block, player.blueOld[i]));
i++;
}
}
player.blueOld.Clear();
player.bluePortal.Clear();
}
if (player.orangePortal.Count > 0)
{
int i = 0;
foreach (Vector3I block in player.orangePortal)
{
if (player.WorldMap != null && player.World.IsLoaded)
{
player.WorldMap.QueueUpdate(new BlockUpdate(null, block, player.orangeOld[i]));
i++;
}
}
player.orangeOld.Clear();
player.orangePortal.Clear();
}
player.Message("&SGunMode deactivated");
}
catch (Exception ex)
{
Logger.Log(LogType.SeriousError, "" + ex);
}
}
else
{
if (!player.World.gunPhysics)
{
player.Message("&WGun physics are disabled on this world");
return;
}
player.GunMode = true;
GunGlassTimer timer = new GunGlassTimer(player);
timer.Start();
player.Message("&SGunMode activated. Fire at will!");
}
}
void Draw(Player player, Command command, DrawMode mode)
{
if (!player.Can(Permissions.Draw))
{
world.NoAccessMessage(player);
return;
}
if (player.drawingInProgress)
{
player.Message("Another draw command is already in progress. Please wait.");
return;
}
string blockName = command.Next();
Block block;
if (blockName == null || blockName == "")
{
if (mode == DrawMode.Cuboid)
{
player.Message("Usage: " + Color.Help + "/cuboid blockName" + Color.Sys + " or " + Color.Help + "/cub blockName");
}
else
{
player.Message("Usage: " + Color.Help + "/ellipsoid blockName" + Color.Sys + " or " + Color.Help + "/ell blockName");
}
return;
}
try {
block = Map.GetBlockByName(blockName);
} catch (Exception) {
player.Message("Unknown block name: " + blockName);
return;
}
player.tag = block;
Permissions permission = Permissions.Build;
switch (block)
{
case Block.Admincrete: permission = Permissions.PlaceAdmincrete; break;
case Block.Air: permission = Permissions.Delete; break;
case Block.Water:
case Block.StillWater: permission = Permissions.PlaceWater; break;
case Block.Lava:
case Block.StillLava: permission = Permissions.PlaceLava; break;
}
if (!player.Can(permission))
{
player.Message("You are not allowed to draw with this block.");
return;
}
player.marksExpected = 2;
player.markCount = 0;
player.marks.Clear();
player.Message(mode.ToString() + ": Place a block or type /mark to use your location.");
if (mode == DrawMode.Cuboid)
{
player.selectionCallback = DrawCuboid;
}
else
{
player.selectionCallback = DrawEllipsoid;
}
}
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 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.");
}
}
}
