public static bool SendCustom(Player player, string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recepientList = Server.Players.Can(Permission.ReadCustomChat)
.NotIgnoring(player);
string formattedMessage = String.Format(Color.Custom + "({2}){0}&b: {1}",
player.ClassyName,
rawMessage, ConfigKey.CustomChatName.GetString());
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Staff,
recepientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.GlobalChat, "({2}){0}: {1}", player.Name, rawMessage, ConfigKey.CustomChatName.GetString());
return(true);
}
/// <summary> Sends a global announcement (/Say). </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 SendSay([NotNull] Player player, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recipientList = Server.Players;
string formattedMessage = Color.Say + rawMessage;
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Say,
recipientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.GlobalChat,
"(say){0}: {1}", player.Name, rawMessage);
return(true);
}
/// <summary> Sends a staff message (/Staff). </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 SendStaff([NotNull] Player player, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recipientList = Server.Players.Can(Permission.ReadStaffChat)
.NotIgnoring(player)
.Union(player);
string formattedMessage = String.Format("&P(staff){0}&P: {1}",
player.ClassyName,
rawMessage);
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Staff,
recipientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.GlobalChat,
"(staff){0}: {1}", player.Name, rawMessage);
return(true);
}
/// <summary> Sends an action message (/Me). </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 SendMe([NotNull] Player player, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recipientList = Server.Players.NotIgnoring(player);
string formattedMessage = String.Format("&M*{0} {1}",
player.Name,
rawMessage);
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Me,
recipientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.GlobalChat,
"(me){0}: {1}", player.Name, rawMessage);
return(true);
}
/// <summary> Sends a private message (PM). Does NOT send a copy of the message to the sender. </summary>
/// <param name="from"> Sender player. </param>
/// <param name="to"> Recepient player. </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 SendPM([NotNull] Player from, [NotNull] Player to, [NotNull] string rawMessage)
{
if (from == null)
{
throw new ArgumentNullException("from");
}
if (to == null)
{
throw new ArgumentNullException("to");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recepientList = new[] { to };
string formattedMessage = String.Format("&Pfrom {0}: {1}",
from.Name, rawMessage);
var e = new ChatSendingEventArgs(from,
rawMessage,
formattedMessage,
ChatMessageType.PM,
recepientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.PrivateChat,
"{0} to {1}: {2}",
from.Name, to.Name, rawMessage);
return(true);
}
static void RaiseSentEvent([NotNull] ChatSendingEventArgs args, int recipientCount)
{
var h = Sent;
if (h != null)
{
h(null, new ChatSentEventArgs(args, recipientCount));
}
}
/// <summary> Sends a global (white) chat as specified message type</summary>
/// <param name="player"> Player writing the message. </param>
/// <param name="rawMessage"> Message text. </param>
/// <param name="type">MessageType</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, MessageType type)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
if (!MessageTypeUtil.Enabled() || rawMessage.Length >= 64)
{
type = MessageType.Chat;
}
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 = FormatMessage(rawMessage, player);
var recepientList = Server.Players.NotIgnoring(player); //if (player.World.WorldOnlyChat) recepientList = player.World.Players.NotIgnoring(player);
string formattedMessage = $"{player.ClassyName}&F: {rawMessage}";
if (!MessageTypeUtil.Enabled() || rawMessage.Length >= 64)
{
type = MessageType.Chat;
}
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Global,
recepientList,
type);
if (!SendInternal(e))
{
return(false);
}
Network.Remote.Server.Chats.Add(
new ServerLog
{
Sender = player.Name,
Message = OriginalMessage,
ChatMode = ""
}
);
Logger.Log(LogType.GlobalChat,
"{0}: {1}", player.Name, OriginalMessage);
return(true);
}
static void RaiseSentEvent(ChatSendingEventArgs args, int recipientCount)
{
var h = Sent;
if (h != null)
{
h(null, new ChatSentEventArgs(args.Player, args.Message, args.FormattedMessage,
args.MessageType, args.RecipientList, recipientCount));
}
}
static bool RaiseSendingEvent(ChatSendingEventArgs args)
{
var h = Sending;
if (h == null)
{
return(false);
}
h(null, args);
return(args.Cancel);
}
static bool RaiseSendingEvent([NotNull] ChatSendingEventArgs args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
var h = Sending;
if (h == null)
{
return(false);
}
h(null, args);
return(args.Cancel);
}
/// <summary> Sends a world-specific message (!World message). </summary>
/// <param name="player"> Player writing the message. </param>
/// <param name="world"> Target world. </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 SendWorld([NotNull] Player player, [NotNull] World world, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (world == null)
{
if (player.World == null)
{
player.Message("Please specify a world name when using WorldChat from console.");
return(false);
}
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recepientList = world.Players.NotIgnoring(player).Union(player);
rawMessage = FormatMessage(rawMessage, player);
string formattedMessage = $"&P({world.ClassyName}&P){player.Name}: {rawMessage}";
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.World, recepientList,
MessageType.Chat);
if (!SendInternal(e))
{
return(false);
}
Network.Remote.Server.Chats.Add(
new ServerLog
{
Sender = player.Name,
Message = rawMessage,
ChatMode = $"World: {world.Name}"
}
);
Logger.Log(LogType.GlobalChat, "({0}){1}: {2}", world.Name, player.Name, rawMessage);
return(true);
}
/// <summary> Sends a rank-wide message (@@Rank message). </summary>
/// <param name="player"> Player writing the message. </param>
/// <param name="rank"> Target rank. </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 SendRank([NotNull] Player player, [NotNull] Rank rank, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rank == null)
{
throw new ArgumentNullException("rank");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recepientList = rank.Players.NotIgnoring(player).Union(player);
rawMessage = FormatMessage(rawMessage, player);
string formattedMessage = $"&P({rank.ClassyName}&P){player.Name}: {rawMessage}";
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Rank,
recepientList,
MessageType.Chat);
if (!SendInternal(e))
{
return(false);
}
Network.Remote.Server.Chats.Add(
new ServerLog
{
Sender = player.Name,
Message = rawMessage,
ChatMode = $"Rank: {rank.Name}"
}
);
Logger.Log(LogType.RankChat,
"(rank {0}){1}: {2}",
rank.Name, player.Name, rawMessage);
return(true);
}
/// <summary> Sends a private message (PM). Does NOT send a copy of the message to the sender. </summary>
/// <param name="from"> Sender player. </param>
/// <param name="to"> Recepient player. </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 SendPM([NotNull] Player from, [NotNull] Player to, [NotNull] string rawMessage)
{
if (from == null)
{
throw new ArgumentNullException("from");
}
if (to == null)
{
throw new ArgumentNullException("to");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recepientList = new[] { to };
string formattedMessage = $"&Pfrom {from.Name}: {rawMessage}";
var e = new ChatSendingEventArgs(from,
rawMessage,
formattedMessage,
ChatMessageType.PM,
recepientList,
MessageType.Chat);
if (!SendInternal(e))
{
return(false);
}
Network.Remote.Server.Chats.Add(
new ServerLog
{
Sender = from.Name,
Message = rawMessage,
ChatMode = $"PM: {to.Name}"
}
);
Logger.Log(LogType.PrivateChat,
"{0} to {1}: {2}",
from.Name, to.Name, rawMessage);
return(true);
}
/// <summary> Sends a staff message (/Staff). </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 SendStaff([NotNull] Player player, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recepientList = PlayerEnumerable.Can(Server.Players, Permission.ReadStaffChat)
.NotIgnoring(player)
.Union(player);
rawMessage = FormatMessage(rawMessage, player);
string formattedMessage = $"&P(staff){player.ClassyName}&P: {rawMessage}";
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Staff,
recepientList,
MessageType.Chat);
if (!SendInternal(e))
{
return(false);
}
Network.Remote.Server.Chats.Add(
new ServerLog
{
Sender = player.Name,
Message = rawMessage,
ChatMode = "Staff"
}
);
Logger.Log(LogType.GlobalChat,
"(staff){0}: {1}", player.Name, rawMessage);
return(true);
}
/// <summary> Sends a global announcement (/Say). </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 SendSay([NotNull] Player player, [NotNull] string rawMessage, MessageType type)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
if (!MessageTypeUtil.Enabled() || rawMessage.Length >= 64)
{
type = MessageType.Chat;
}
var recepientList = Server.Players.NotIgnoring(player);
rawMessage = FormatMessage(rawMessage, player);
string formattedMessage = Color.Say + rawMessage;
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Say,
recepientList,
type);
if (!SendInternal(e))
{
return(false);
}
Network.Remote.Server.Chats.Add(
new ServerLog
{
Sender = player.Name,
Message = rawMessage,
ChatMode = "Say"
}
);
Logger.Log(LogType.GlobalChat,
"(say){0}: {1}", player.Name, rawMessage);
return(true);
}
static bool SendInternal([NotNull] ChatSendingEventArgs e)
{
if (RaiseSendingEvent(e))
{
return(false);
}
Player[] players = e.RecipientList.ToArray();
int recipients = players.Message(e.FormattedMessage);
// Only increment the MessagesWritten count if someone other than
// the player was on the recipient list.
if (players.Length > 1 || (players.Length == 1 && players[0] != e.Player))
{
e.Player.Info.ProcessMessageWritten();
}
RaiseSentEvent(e, recipients);
return(true);
}
/// <summary> Sends a rank-wide message (@@Rank message). </summary>
/// <param name="player"> Player writing the message. </param>
/// <param name="rank"> Target rank. </param>
/// <param name="rawMessage"> Message text. </param>
/// <returns> True if message was sent, false if it was canceled by an event callback. </returns>
/// <exception cref="ArgumentNullException"> If player, rank, or rawMessage is null. </exception>
public static bool SendRank([NotNull] Player player, [NotNull] Rank rank, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rank == null)
{
throw new ArgumentNullException("rank");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recipientList = rank.Players
.NotIgnoring(player)
.Union(player)
.Union(Server.Players.Spectating(player));
string formattedMessage = String.Format("&P({0}&P){1}: {2}",
rank.ClassyName,
player.Name,
rawMessage);
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Rank,
recipientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.RankChat,
"(rank {0}){1}: {2}",
rank.Name, player.Name, rawMessage);
return(true);
}
/// <summary> Sends world/local chat message. </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 canceled by an event callback. </returns>
/// <exception cref="ArgumentNullException"> If player or rawMessage is null. </exception>
public static bool SendWorld([NotNull] Player player, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
World playerWorld = player.World;
if (playerWorld == null)
{
PlayerOpException.ThrowNoWorld(player);
}
var recipientList = playerWorld.Players
.NotIgnoring(player);
string formattedMessage = String.Format("({0}&F){1}: {2}",
playerWorld.ClassyName,
player.ClassyName,
rawMessage);
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.World,
recipientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.GlobalChat,
"(world {0}){1}: {2}",
playerWorld.Name, player.Name, rawMessage);
return(true);
}
/// <summary> Sends an action message (/Me). </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 SendMe([NotNull] Player player, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recepientList = Server.Players.NotIgnoring(player);
rawMessage = FormatMessage(rawMessage, player);
string formattedMessage = $"&M*{player.Name} {rawMessage}";
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.Me,
recepientList,
MessageType.Chat);
if (!SendInternal(e))
{
return(false);
}
Network.Remote.Server.Chats.Add(
new ServerLog
{
Sender = player.Name,
Message = rawMessage,
ChatMode = "Me"
}
);
Logger.Log(LogType.GlobalChat,
"(me){0}: {1}", player.Name, rawMessage);
return(true);
}
static bool SendInternal([NotNull] ChatSendingEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (RaiseSendingEvent(e))
{
return(false);
}
int recepients = e.RecepientList.Message(e.FormattedMessage);
// Only increment the MessagesWritten count if someone other than
// the player was on the recepient list.
if (recepients > 1 || (recepients == 1 && e.RecepientList.First() != e.Player))
{
e.Player.Info.ProcessMessageWritten();
}
RaiseSentEvent(e, recepients);
return(true);
}
/// <summary> Sends a world-specific message (!World message). </summary>
/// <param name="player"> Player writing the message. </param>
/// <param name="world"> Target world. </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 SendWorld([NotNull] Player player, [NotNull] World world, [NotNull] string rawMessage)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (world == null)
{
if (player.World == null)
{
player.Message("Please specify a world name when using WorldChat from console.");
return(false);
}
}
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
var recepientList = world.Players.NotIgnoring(player).Union(player);
string formattedMessage = String.Format("&P({0}&P){1}: {2}", world.ClassyName, player.Name, rawMessage);
var e = new ChatSendingEventArgs(player,
rawMessage,
formattedMessage,
ChatMessageType.World, recepientList);
if (!SendInternal(e))
{
return(false);
}
Logger.Log(LogType.GlobalChat, "({0}){1}: {2}", world.Name, player.Name, rawMessage);
return(true);
}
/// <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", "Hello my name is " + player.ClassyName);
rawMessage = rawMessage.Replace("$kicks", "I have kicked " + player.Info.TimesKickedOthers.ToString() + " players.");
rawMessage = rawMessage.Replace("$bans", "I have banned " + player.Info.TimesBannedOthers.ToString() + " players.");
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());
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);
}
/// <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);
}
