public void OnChat(ServerChatEventArgs e)
{
if (e.Handled)
{
return;
}
if (e.Text == "/")
{
e.Handled = true;
return;
}
var ePly = esPlayers[e.Who];
var tPly = TShock.Players[e.Who];
if (ePly.HasNickName && !e.Text.StartsWith("/") && !tPly.mute)
{
e.Handled = true;
string nick = Config.PrefixNicknamesWith + ePly.Nickname;
TShock.Utils.Broadcast(String.Format(TShock.Config.ChatFormat, tPly.Group.Name, tPly.Group.Prefix, nick, tPly.Group.Suffix, e.Text),
tPly.Group.R, tPly.Group.G, tPly.Group.B);
}
else if (ePly.HasNickName && e.Text.StartsWith("/me ") && !tPly.mute)
{
e.Handled = true;
string nick = Config.PrefixNicknamesWith + ePly.Nickname;
TShock.Utils.Broadcast(string.Format("*{0} {1}", nick, e.Text.Remove(0, 4)), 205, 133, 63);
}
}
void OnChat(ServerChatEventArgs args)
{
if ((args.Text.ToUpper() == args.Text) && (args.Text.Length > 10))
{
TShock.Players[args.Who].SendErrorMessage("Please do not speak in all-caps, it is against the rules.");
args.Handled = true;
}
}
void OnChat(ServerChatEventArgs e)
{
if (!e.Handled)
{
string text = e.Text;
if (e.Text.StartsWith("/"))
{
string[] arr = e.Text.Split(' ');
if (e.Text.StartsWith("/me ") && TShock.Players[e.Who].Group.HasPermission(Permissions.cantalkinthird))
text = e.Text.Substring(4);
else if ((e.Text.StartsWith("/tell ") || e.Text.StartsWith("/w ") || e.Text.StartsWith("/whisper ")) &&
TShock.Players[e.Who].Group.HasPermission(Permissions.whisper) && (arr.Length > 1 && !String.IsNullOrWhiteSpace(arr[1])))
{
text = e.Text.Substring(arr[0].Length + arr[1].Length + 2);
}
else if ((e.Text.StartsWith("/r ") || e.Text.StartsWith("/reply ")) &&
TShock.Players[e.Who].Group.HasPermission(Permissions.whisper))
{
text = e.Text.Substring(arr[0].Length + 1);
}
else if (e.Text.Trim().Length == 1)
text = "/";
else
return;
}
if ((DateTime.Now - Times[e.Who]).TotalSeconds > Config.Time)
{
Spams[e.Who] = 0.0;
Times[e.Who] = DateTime.Now;
}
Spams[e.Who]++;
double uniqueRatio = (double)text.GetUnique() / text.Length;
if (text.Trim().Length <= Config.ShortLength)
Spams[e.Who] += 0.5;
else if (uniqueRatio <= 0.20 || uniqueRatio >= 0.80)
Spams[e.Who] += 0.5;
if (text.UpperCount() >= Config.CapsRatio)
Spams[e.Who] += 0.5;
if (Spams[e.Who] > Config.Threshold && !TShock.Players[e.Who].Group.HasPermission("antispam.ignore"))
{
switch (Config.Action)
{
case "ignore":
default:
Times[e.Who] = DateTime.Now;
TShock.Players[e.Who].SendErrorMessage("You have been ignored for spamming.");
e.Handled = true;
break;
case "kick":
TShock.Utils.ForceKick(TShock.Players[e.Who], "Spamming");
e.Handled = true;
break;
}
}
}
}
internal bool InvokeServerChat(MessageBuffer buffer, int who, string text)
{
ServerChatEventArgs args = new ServerChatEventArgs
{
Buffer = buffer,
Who = who,
Text = text
};
this.ServerChat.Invoke(args);
return(args.Handled);
}
internal bool InvokeServerChat(MessageBuffer buffer, int who, string text, Terraria.Chat.ChatCommandId commandId)
{
ServerChatEventArgs args = new ServerChatEventArgs
{
Buffer = buffer,
Who = who,
Text = text,
CommandId = commandId
};
this.ServerChat.Invoke(args);
return(args.Handled);
}
public void OnChat(ServerChatEventArgs args)
{
if ((args.Text.StartsWith("/w ") || args.Text.StartsWith("/whisper ") || args.Text.StartsWith("/r ") || args.Text.StartsWith("/reply ")) && args.Text.Length >= 4)
{
foreach (TSPlayer ts in TShock.Players)
{
if (ts == null)
continue;
if (Spying[ts.Index])
ts.SendMessage(TShock.Players[args.Who].Name + ": " + args.Text, staffchatcolor);
}
}
}
private void ChatSent(TerrariaApi.Server.ServerChatEventArgs args)
{
TSPlayer target = TShock.Players[args.Who];
String message = args.Text.ToLower();
if (!target.HasPermission("tagblock.allow.text.color"))
{
if (message.Contains("[c:") || message.Contains("[c/") && message.Contains("]"))
{
target.SendWarningMessage("[TagBlock] You are not permitted to use the Color Tag. (Detected attempt.)");
args.Handled = true;
}
}
;
if (!target.HasPermission("tagblock.allow.text.item"))
{
if (message.Contains("[i:") || message.Contains("[i/") && message.Contains("]"))
{
target.SendWarningMessage("[TagBlock] You are not permitted to use the Item Tag. (Detected attempt.)");
args.Handled = true;
}
}
;
if (!target.HasPermission("tagblock.allow.text.achievement"))
{
if (message.Contains("[a:") || message.Contains("[a/") && message.Contains("]"))
{
target.SendWarningMessage("[TagBlock] You are not permitted to use the Achievement Tag. (Detected attempt.)");
args.Handled = true;
}
}
;
if (!target.HasPermission("tagblock.allow.text.player"))
{
if (message.Contains("[n:") || message.Contains("[n/") && message.Contains("]"))
{
target.SendWarningMessage("[TagBlock] You are not permitted to use the Player Name Tag. (Detected attempt.)");
args.Handled = true;
}
}
;
}
private void OnChat(ServerChatEventArgs e)
{
TSPlayer tSPlayer = TShock.Players[e.Who];
if (e.Text.StartsWith("/login") && !tSPlayer.IsLoggedIn && !iAgree.HasAgreed[e.Who] && HasReadRules[e.Who])
{
e.Handled = true;
tSPlayer.SendErrorMessage("Before logging in you have to confirm you have read the /rules, to do this type /iagree");
}
if (e.Text.StartsWith("/rules"))
{
HasReadRules[e.Who] = true;
}
if (!e.Text.StartsWith("/"))
{
if (!tSPlayer.IsLoggedIn)
{
e.Handled = true;
tSPlayer.SendErrorMessage("You can only talk when registered & logged in!");
tSPlayer.SendErrorMessage("Please follow the instructions on the sign on how to register & log in!");
tSPlayer.SendErrorMessage("Trouble finding the sign/too lazy to read? Short instructions: /helpme");
}
else if (!tSPlayer.Group.HasPermission("iagree.bypass.chat") && e.Text.Length >= 10)
{
int num = 0;
char[] array = e.Text.ToCharArray();
for (int i = 0; i < array.Length; i++)
{
if (char.IsUpper(array[i]))
{
num++;
}
}
if (100 / e.Text.Length * num > 25)
{
e.Handled = true;
tSPlayer.SendErrorMessage("Your message has been ignored for containing more than 25% caps!");
}
}
}
}
void OnChat(ServerChatEventArgs e)
{
if (!e.Handled)
{
string text = e.Text;
if (e.Text.StartsWith(Commands.Specifier) || e.Text.StartsWith(Commands.SilentSpecifier))
return;
if ((DateTime.Now - Times[e.Who]).TotalSeconds > Config.Time)
{
Spams[e.Who] = 0.0;
Times[e.Who] = DateTime.Now;
}
if (text.Trim().Length <= Config.ShortLength)
Spams[e.Who] += Config.ShortWeight;
else if ((double)text.Where(c => Char.IsUpper(c)).Count() / text.Length >= Config.CapsRatio)
Spams[e.Who] += Config.CapsWeight;
else
Spams[e.Who] += Config.NormalWeight;
if (Spams[e.Who] > Config.Threshold && !TShock.Players[e.Who].Group.HasPermission("antispam.ignore"))
{
switch (Config.Action.ToLower())
{
case "ignore":
default:
Times[e.Who] = DateTime.Now;
TShock.Players[e.Who].SendErrorMessage("You have been ignored for spamming.");
e.Handled = true;
return;
case "kick":
TShock.Utils.ForceKick(TShock.Players[e.Who], "Spamming", false, true);
e.Handled = true;
return;
}
}
}
}
private void Actionfor(ServerChatEventArgs args)
{
var ignored = new List<string>();
var player = TShock.Players[args.Who];
if (!args.Text.ToLower().StartsWith("/") || args.Text.ToLower().StartsWith("/w") ||
args.Text.ToLower().StartsWith("/r") || args.Text.ToLower().StartsWith("/me") ||
args.Text.ToLower().StartsWith("/c") || args.Text.ToLower().StartsWith("/party"))
{
foreach (string Word in config.BanWords)
{
if (player.Group.HasPermission("caw.filterbypass"))
{
args.Handled = false;
}
else if (args.Text.ToLower().Contains(Word))
{
switch (config.ActionForBannedWord)
{
case "kick":
args.Handled = true;
TShock.Utils.Kick(player, config.KickMessage, true, false);
break;
case "ignore":
args.Handled = true;
ignored.Add(Word);
break;
case "censor":
args.Handled = true;
var text = args.Text;
text = args.Text.Replace(Word, new string('*', Word.Length));
TSPlayer.All.SendMessage(player.Group.Prefix + player.Name + ": " + text, player.Group.R,player.Group.G,player.Group.B);
break;
case "donothing":
args.Handled = false;
break;
}
}
}
if (ignored.Count > 0)
{
player.SendErrorMessage("Your message has been ignored for saying: " + string.Join(", ", ignored));
}
}
else
{
args.Handled = false;
}
}
public void OnChat(ServerChatEventArgs args)
{
string[] Groups = new string[0];
string[] Messages = new string[0];
float[] Colour = new float[0];
var PlayerGroup = TShock.Players[args.Who].Group.Name;
lock (Config.Broadcasts)
foreach (var broadcast in Config.Broadcasts)
{
if (broadcast == null || !broadcast.Enabled ||
(broadcast.TriggerToWholeGroup && !broadcast.Groups.Contains(PlayerGroup)))
{
continue;
}
foreach (string Word in broadcast.TriggerWords)
{
if (args.Text.Contains(Word))
{
if (broadcast.TriggerToWholeGroup && broadcast.Groups.Length > 0)
{
Groups = broadcast.Groups;
}
Messages = broadcast.Messages;
Colour = broadcast.ColorRGB;
break;
}
}
}
if (Groups.Length > 0)
{
BroadcastToGroups(Groups, Messages, Colour);
}
else
{
BroadcastToPlayer(args.Who, Messages, Colour);
}
}
private void OnChat(ServerChatEventArgs args)
{
var message = TShock.Players[args.Who].Name + ": " + args.Text;
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "TShockAdminChat", routingKey: "", basicProperties: null, body: body);
}
void OnChat(ServerChatEventArgs e)
{
if (e.Handled)
return;
// A quick check to reduce DB work when this feature isn't in use
if (String.IsNullOrWhiteSpace(Config.ContributorChatFormat))
return;
var player = TShock.Players[e.Who];
if (player == null || !player.Active || !player.IsLoggedIn || !player.ContainsData(Contributor.DataKey))
return;
if (e.Text.Length > 500)
return;
// If true, the message is a command, so we skip it
if ((e.Text.StartsWith(TShockAPI.Commands.Specifier) || e.Text.StartsWith(TShockAPI.Commands.SilentSpecifier))
&& !String.IsNullOrWhiteSpace(e.Text.Substring(1)))
return;
// Player needs to be able to talk, not be muted, and must be logged in
if (!player.HasPermission(TShockAPI.Permissions.canchat) || player.mute || !player.IsLoggedIn)
return;
// At this point, ChatAboveHeads is not supported, but it could be a thing in the future
if (!TShock.Config.EnableChatAboveHeads)
{
Contributor con = player.GetData<Contributor>(Contributor.DataKey);
Tier tier = Tiers.Get(con.Tier);
/* Contributor chat format:
{0} - group name
{1} - group prefix
{2} - player name
{3} - group suffix
{4} - message text
{5} - tier shortname
{6} - tier name
{7} - webID
*/
var text = String.Format(Config.ContributorChatFormat, player.Group.Name, player.Group.Prefix, player.Name,
player.Group.Suffix, e.Text, tier.ShortName ?? "", tier.Name ?? "", con.XenforoId ?? -1);
PlayerHooks.OnPlayerChat(player, e.Text, ref text);
Color? color = con.ChatColor;
if (!color.HasValue)
{
#region DEBUG
#if DEBUG
TShock.Log.ConsoleInfo("OnChat: Contributor color was null");
#endif
#endregion
// If the contributor doesn't have a custom chat color, check their tier
color = tier.ChatColor;
if (!color.HasValue)
{
// As neither the tier nor the contributor have a custom chat color, use the group's default
color = new Color(player.Group.R, player.Group.G, player.Group.B);
}
}
TShock.Utils.Broadcast(text, color.Value.R, color.Value.G, color.Value.B);
#region
#if DEBUG
TShock.Log.ConsoleInfo("OnChat: Contributor was handled by CTRS");
#endif
#endregion
e.Handled = true;
}
}
private void OnChat(ServerChatEventArgs e)
{
TSPlayer ply = TShock.Players[e.Who];
if (e.Text.StartsWith("/"))
{
e.Handled = false;
}
else if (Moderated)
{
if (ply.Group.HasPermission("chat.mod") || ply.Group.HasPermission("chat.admin"))
{
e.Handled = false;
}
else
{
e.Handled = true;
ply.SendErrorMessage("You do not have the permission to talk!");
}
}
else if (RawText)
{
e.Handled = true;
TSPlayer.All.SendMessageFromPlayer(e.Text, 255, 255, 255, e.Who);
}
else if (CName)
{
e.Handled = true;
TSPlayer.All.SendInfoMessage(CPrefix + ": " + e.Text);
}
}
private void OnChat(ServerChatEventArgs e)
{
if (e.Handled || !e.Text.StartsWith("/"))
return;
foreach (var command in getConfig.commands)
{
if ((e.Text == command.command || e.Text.StartsWith(command.command + " ")) && command.file != "")
{
e.Handled = true;
TShock.Log.Info("{0} executed: {1}".SFormat(TShock.Players[e.Who].Name, command.command));
ShowFile(command, e.Text, TShock.Players[e.Who]);
break;
}
}
}
void OnChat(ServerChatEventArgs e)
{
TSPlayer tsPlr = TShock.Players[e.Who];
if (!IrcClient.IsConnected)
{
TShock.Log.ConsoleInfo("WOOP WOOP");
Connect();
}
else if (e.Text != null && !e.Text.StartsWith(TShock.Config.CommandSpecifier) && !e.Text.StartsWith(TShock.Config.CommandSilentSpecifier) && tsPlr != null &&
!tsPlr.mute && tsPlr.Group.HasPermission(Permissions.canchat) && !String.IsNullOrEmpty(Config.ServerChatMessageFormat) &&
!Config.IgnoredServerChatRegexes.Any(s => Regex.IsMatch(e.Text, s)))
{
SendMessage(Config.Channel, String.Format(Config.ServerChatMessageFormat, tsPlr.Group.Prefix, tsPlr.Name, e.Text, tsPlr.Group.Suffix));
}
}
void OnChat(ServerChatEventArgs args)
{
TSPlayer ts = TShock.Players[args.Who];
if (ts.mute || !ts.IsLoggedIn)
return;
Clan Myclan = ClanManager.FindClanByPlayer(ts);
if (Myclan == null)
return;
if (args.Text.StartsWith(TShock.Config.CommandSpecifier))
return;
if(!ts.Group.HasPermission(Permission.Chat) || !ts.Group.HasPermission(Permission.Use))
{
Myclan.OnlineClanMembers[ts.Index].DefaultToClanChat = false;
return;
}
if (Myclan.OnlineClanMembers[ts.Index].DefaultToClanChat)
{
args.Handled = true;
Myclan.Broadcast(string.Format("[Clanchat] {0} - {1}: {2}", Myclan.Name, ts.Name, string.Join(" ", args.Text)));
}
}
public void OnChat(ServerChatEventArgs args)
{
var player = Players[args.Who];
if (player.IdleTime > 0)
player.IdleTime = 0;
}
///<summary>
/// This method is for handling prefix and suffix in chat.
///</summary>
///<param name="args">Containing event data.</param>
private void OnChat(ServerChatEventArgs args)
{
if (args.Handled)
return;
var tsplr = TShock.Players[args.Who];
string tsplr_group_prefix = tsplr.Group.Prefix;
string tsplr_group_suffix = tsplr.Group.Suffix;
string tsplr_group_name = tsplr.Group.Name;
string tsplr_name = tsplr.Name;
byte tsplr_group_r = tsplr.Group.R;
byte tsplr_group_g = tsplr.Group.G;
byte tsplr_group_b = tsplr.Group.B;
if (iSettings.AsPrefix == true) {
string temp1 = string.Format(iSettings.PrefixString, this.myPlayersData[tsplr.Index]);
tsplr_group_prefix = tsplr.Group.Prefix.Replace("%TSGeoIP-CC-Prefix", temp1);
} else {
tsplr_group_prefix = tsplr.Group.Prefix.Replace("%TSGeoIP-CC-Prefix", string.Empty);
}
if (iSettings.AsSuffix == true) {
string temp2 = string.Format(iSettings.SuffixString, this.myPlayersData[tsplr.Index]);
tsplr_group_suffix = tsplr.Group.Suffix.Replace("%TSGeoIP-CC-Suffix", temp2);
} else {
tsplr_group_suffix = tsplr.Group.Suffix.Replace("%TSGeoIP-CC-Suffix", string.Empty);
}
if (tsplr == null) {
args.Handled = true;
return;
}
if (args.Text.Length > 500) {
TShock.Utils.Kick(tsplr, "Crash attempt via long chat packet.", true);
args.Handled = true;
return;
}
//SA1119
if ((!args.Text.StartsWith(TShock.Config.CommandSpecifier) && !args.Text.StartsWith(TShock.Config.CommandSilentSpecifier))) {
if (!tsplr.Group.HasPermission(Permissions.canchat)) {
args.Handled = true;
} else if (tsplr.mute) {
tsplr.SendErrorMessage("You are muted!");
args.Handled = true;
} else if (!TShock.Config.EnableChatAboveHeads) {
var text = string.Format(TShock.Config.ChatFormat, tsplr_group_name, tsplr_group_prefix, tsplr_name, tsplr_group_suffix, args.Text);
TShockAPI.Hooks.PlayerHooks.OnPlayerChat(tsplr, args.Text, ref text);
TShock.Utils.Broadcast(text, tsplr_group_r, tsplr_group_g, tsplr_group_b);
args.Handled = true;
} else {
Player ply = Main.player[args.Who];
string name = ply.name;
ply.name = string.Format(TShock.Config.ChatAboveHeadsFormat, tsplr_group_name, tsplr_group_prefix, tsplr_name, tsplr_group_suffix);
NetMessage.SendData((int)PacketTypes.PlayerInfo, -1, -1, ply.name, args.Who, 0, 0, 0, 0);
ply.name = name;
var text = args.Text;
TShockAPI.Hooks.PlayerHooks.OnPlayerChat(tsplr, args.Text, ref text);
NetMessage.SendData((int)PacketTypes.ChatText, -1, args.Who, text, args.Who, tsplr_group_r, tsplr_group_g, tsplr_group_b);
NetMessage.SendData((int)PacketTypes.PlayerInfo, -1, -1, name, args.Who, 0, 0, 0, 0);
string msg = string.Format("<{0}> {1}", string.Format(TShock.Config.ChatAboveHeadsFormat, tsplr_group_name, tsplr_group_prefix, tsplr_name, tsplr_group_suffix), text);
tsplr.SendMessage(msg, tsplr_group_r, tsplr_group_g, tsplr_group_b);
TSPlayer.Server.SendMessage(msg, tsplr_group_r, tsplr_group_g, tsplr_group_b);
TShock.Log.Info("Broadcast: {0}", msg);
args.Handled = true;
}
}
}
private void OnChat(ServerChatEventArgs args)
{
if (!args.Text.StartsWith("/vote"))
return;
var player = TShock.Players[args.Who];
if (player == null)
{
args.Handled = true;
return;
}
Match M = Regex.Match(args.Text, "^/vote(?: (.*))?$", RegexOptions.IgnoreCase);
if (M.Success)
{
if (TSWConfig.RequirePermission && !player.Group.HasPermission(TSWConfig.PermissionName))
{
player.SendSuccessMessage("[TServerWeb] You don't have permission to vote!");
return;
}
CommandArgs e = new CommandArgs(args.Text, player, new List<string>());
string Args = M.Groups[1].Value;
if (!IPs.ContainsKey(player.IP)) IPs.Add(player.IP, new VoteIP(DateTime.Now));
if (!string.IsNullOrWhiteSpace(Args))
{
e.Parameters.Add(Args);
TSPlayer.Server.SendMessage(player.Name + " has entered /vote captcha.", 255, 255, 255);
Vote(e);
args.Handled = true;
return;
}
TSPlayer.Server.SendMessage(player.Name + " executed: /vote.", 255, 255, 255);
Vote(e);
args.Handled = true;
}
}
public void OnChat(ServerChatEventArgs args)
{
var Start = DateTime.Now;
string[] Groups = new string[0];
string[] Messages = new string[0];
float[] Colour = new float[0];
var PlayerGroup = TShock.Players[args.Who].Group.Name;
lock (Config.Broadcasts)
foreach (var broadcast in Config.Broadcasts)
{
if (Timeout(Start)) return;
if (broadcast == null || !broadcast.Enabled || !broadcast.Groups.Contains(PlayerGroup)) continue;
string[] msgs = broadcast.Messages;
for (int i = 0; i < msgs.Length; i++)
{
msgs[i] = msgs[i].Replace("{player}", TShock.Players[args.Who].Name);
}
foreach (string Word in broadcast.TriggerWords)
{
if (Timeout(Start)) return;
if (args.Text.Contains(Word))
{
if (broadcast.TriggerToWholeGroup && broadcast.Groups.Length > 0)
{
Groups = broadcast.Groups;
}
Messages = broadcast.Messages;
Colour = broadcast.ColorRGB;
break;
}
}
}
bool all = false;
foreach (string i in Groups)
{
if (i == "*")
all = true;
}
if (all)
{
Groups = new string[1] { "all" };
}
if (Groups.Length > 0)
{
BroadcastToGroups(Groups, Messages, Colour);
}
else
{
BroadcastToPlayer(args.Who, Messages, Colour);
}
}
private void OnChat(ServerChatEventArgs e)
{
var player = TShock.Players[e.Who];
var text = e.Text;
Encoding srcEncodingFormat = Encoding.GetEncoding("windows-1252");
byte[] originalByteString = srcEncodingFormat.GetBytes(text);
if (!IsUTF8Bytes(originalByteString))
{
text = Encoding.GetEncoding("windows-1251").GetString(originalByteString);
}
if (!text.StartsWith("/") & Client.IsConnected)
{
for (int i = 0; i < admins.Length; i++)
{
if(seechat[i])
Friends.SendChatMessage(admins[i], EChatEntryType.ChatMsg, String.Format(TShock.Config.ChatFormat, player.Group.Name, player.Group.Prefix, player.Name, player.Group.Suffix, text));
}
}
}
void OnChat(ServerChatEventArgs args)
{
TSPlayer ts = TShock.Players[args.Who];
if (ts.mute || !ts.IsLoggedIn)
return;
Clan Myclan = ClanManager.FindClanByPlayer(ts);
if (Myclan == null)
return;
if (args.Text.StartsWith(TShock.Config.CommandSpecifier))
return;
if (!ts.Group.HasPermission(Permission.Chat) || !ts.Group.HasPermission(Permission.Use)) {
Myclan.OnlineClanMembers.Where(x => x.Index == ts.Index).First().DefaultToClanChat = false;
return;
}
if (Myclan.OnlineClanMembers.Where(x => x.Index == ts.Index).First().DefaultToClanChat) {
args.Handled = true;
string msg = string.Format("[Clan] {0} - {1}: {2}", Myclan.Tag, ts.Name, string.Join(" ", args.Text));
Myclan.Broadcast(msg);
TShock.Utils.SendLogs(msg, Color.PaleVioletRed);
}
}
private void ShadowDodgeCommandBlock(ServerChatEventArgs args)
{
if (args.Handled)
{
return;
}
TSPlayer player = TShock.Players[args.Who];
if (player == null)
{
args.Handled = true;
return;
}
if (config.BlockShadowDodgeBuff)
{
if (args.Text.ToLower().StartsWith("/buff") && args.Text.ToLower().Contains("shadow d") ||
args.Text.ToLower().StartsWith("/buff") && args.Text.ToLower().Contains("\"shadow d") ||
args.Text.ToLower().StartsWith("/buff") && args.Text.ToLower().Contains("59"))
{
if (player.Group.HasPermission("caw.shadowbypass"))
{
args.Handled = false;
}
else
{
args.Handled = true;
player.SendInfoMessage("Shadow Dodge is not a buff you can use on this server through commands.");
}
}
}
}
void OnChat(ServerChatEventArgs e)
{
string text = e.Text;
if (!text.StartsWith("/") || text.StartsWith("/me"))
{
TSPlayer plr = TShock.Players[e.Who];
if (EBUtils.IsPlayerMuted(plr.Name))
{
plr.SendMessage("You are muted!", Color.Red);
e.Handled = true;
}
}
}
internal bool InvokeServerChat(MessageBuffer buffer, int who, string text)
{
ServerChatEventArgs args = new ServerChatEventArgs
{
Buffer = buffer,
Who = who,
Text = text
};
this.ServerChat.Invoke(args);
return args.Handled;
}
private void OnChat(ServerChatEventArgs args)
{
if (args.Handled)
return;
TSPlayer tsplr = TShock.Players[args.Who];
if (!args.Text.StartsWith("/") && !tsplr.mute && tsplr.IsLoggedIn && Players.ContainsKey(tsplr.User.ID)) {
string prefix = Players[tsplr.User.ID].Prefix != null ? Players[tsplr.User.ID].Prefix : tsplr.Group.Prefix;
string suffix = Players[tsplr.User.ID].Suffix != null ? Players[tsplr.User.ID].Suffix : tsplr.Group.Suffix;
Color color = Players[tsplr.User.ID].ChatColor != string.Format("000,000,000") ?
new Color(Players[tsplr.User.ID].R, Players[tsplr.User.ID].G, Players[tsplr.User.ID].B) :
new Color(tsplr.Group.R, tsplr.Group.G, tsplr.Group.B);
if (!TShock.Config.EnableChatAboveHeads) {
TShock.Utils.Broadcast(string.Format(TShock.Config.ChatFormat, tsplr.Group.Name, prefix, tsplr.Name, suffix, args.Text), color);
}
else {
Player ply = Main.player[args.Who];
string name = ply.name;
ply.name = String.Format(TShock.Config.ChatAboveHeadsFormat, tsplr.Group.Name, prefix, tsplr.Name, suffix);
NetMessage.SendData((int)PacketTypes.PlayerInfo, -1, -1, ply.name, args.Who, 0, 0, 0, 0);
ply.name = name;
var text = args.Text;
NetMessage.SendData((int)PacketTypes.ChatText, -1, args.Who, text, args.Who, color.R, color.G, color.B);
NetMessage.SendData((int)PacketTypes.PlayerInfo, -1, -1, name, args.Who, 0, 0, 0, 0);
string msg = String.Format("<{0}> {1}",
String.Format(TShock.Config.ChatAboveHeadsFormat, tsplr.Group.Name, prefix, tsplr.Name, suffix),
text);
tsplr.SendMessage(msg, color.R, color.G, color.B);
TSPlayer.Server.SendMessage(msg, color.R, color.G, color.B);
TShock.Log.Info("Broadcast: {0}", msg);
args.Handled = true;
}
args.Handled = true;
}
}
public void OnChat(ServerChatEventArgs args)
{
TSPlayer sender = TShock.Players[args.Who];
if (!args.Text.StartsWith("/") && !sender.mute && sender.Group.HasPermission("tshock.canchat"))
{
for (int i = 0; i < TShock.Players.Length; i++)
{
TSPlayer ts = TShock.Players[i];
if (ts == null)
continue;
if (_IgnoreAll[i])
{
if (!sender.Group.HasPermission(Permission_NoIgnore))
continue;
}
if (IgnoreList.ContainsKey(i))
{
if (IgnoreList[i].Contains(sender.IP) && !sender.Group.HasPermission(Permission_NoIgnore))
continue;
}
args.Handled = true;
var text = String.Format(TShock.Config.ChatFormat, sender.Group.Name, sender.Group.Prefix, sender.Name, sender.Group.Suffix, args.Text);
ts.SendMessage(text, new Color(sender.Group.R, sender.Group.G, sender.Group.B));
}
}
}
public void OnChat(ServerChatEventArgs args)
{
var Mplayer = Utils.GetPlayers(args.Who);
if (Utils.findIfPlayingCommand(args.Text) && !TShock.Players[args.Who].Group.HasPermission("ghostmode"))
{
string sb = "";
foreach (TSPlayer player in TShock.Players)
{
var ply = Utils.GetPlayers(player.Index);
if (player != null && player.Active && !ply.isGhost)
{
if (sb.Length != 0)
{
sb += ", ";
}
sb += player.Name;
}
}
TShock.Players[args.Who].SendMessage(string.Format("Current players: {0}.", sb), 255, 240, 20);
args.Handled = true;
}
if ((muteAll) && (!TShock.Players[args.Who].Group.HasPermission("mute")) && args.Text.StartsWith("/me"))
{
TShock.Players[args.Who].SendMessage("You cannot use the /me command, you are muted.", Color.Red);
args.Handled = true;
return;
}
if (args.Text.StartsWith("/tp "))
{
string tempText = args.Text;
tempText = tempText.Remove(0, 1);
Utils.parseParameters(tempText);
}
if (muteAll && !TShock.Players[args.Who].Group.HasPermission("mute"))
{
var tsplr = TShock.Players[args.Who];
if (args.Text.StartsWith("/"))
{
Commands.HandleCommand(tsplr, args.Text);
}
else
{
tsplr.SendErrorMessage("The server has been muted: " + config.muteAllReason);
}
args.Handled = true;
}
}
private void OnChat(ServerChatEventArgs args)
{
TSPlayer player = TShock.Players[args.Who];
if (player == null)
{
return;
}
//Check if the provided text matches any of the defined regexes
Regex regex = Regexes.Keys.FirstOrDefault(r => r.IsMatch(args.Text));
if (regex == null)
{
return;
}
Match match = regex.Match(args.Text);
int ID = EmoteBubble.AssignNewID();
if (!String.IsNullOrEmpty(match.Groups["spoken"].Value))
{
args.Handled = true;
}
NetMessage.SendData(91, -1, -1, "", ID, 1, args.Who, 600, Regexes[regex].EmoteID);
}
/// <summary>OnChat - Fired when a player chats. Used for handling chat and commands.</summary>
/// <param name="args">args - The ServerChatEventArgs object.</param>
private void OnChat(ServerChatEventArgs args)
{
if (args.Handled)
return;
var tsplr = Players[args.Who];
if (tsplr == null)
{
args.Handled = true;
return;
}
if (args.Text.Length > 500)
{
Utils.Kick(tsplr, "Crash attempt via long chat packet.", true);
args.Handled = true;
return;
}
if ((args.Text.StartsWith(Config.CommandSpecifier) || args.Text.StartsWith(Config.CommandSilentSpecifier))
&& !string.IsNullOrWhiteSpace(args.Text.Substring(1)))
{
try
{
args.Handled = Commands.HandleCommand(tsplr, args.Text);
}
catch (Exception ex)
{
Log.ConsoleError("An exeption occurred executing a command.");
Log.Error(ex.ToString());
}
}
else
{
if (!tsplr.Group.HasPermission(Permissions.canchat))
{
args.Handled = true;
}
else if (tsplr.mute)
{
tsplr.SendErrorMessage("You are muted!");
args.Handled = true;
}
else if (!TShock.Config.EnableChatAboveHeads)
{
var text = String.Format(Config.ChatFormat, tsplr.Group.Name, tsplr.Group.Prefix, tsplr.Name, tsplr.Group.Suffix,
args.Text);
Hooks.PlayerHooks.OnPlayerChat(tsplr, args.Text, ref text);
Utils.Broadcast(text, tsplr.Group.R, tsplr.Group.G, tsplr.Group.B);
args.Handled = true;
}
else
{
Player ply = Main.player[args.Who];
string name = ply.name;
ply.name = String.Format(Config.ChatAboveHeadsFormat, tsplr.Group.Name, tsplr.Group.Prefix, tsplr.Name, tsplr.Group.Suffix);
NetMessage.SendData((int)PacketTypes.PlayerInfo, -1, -1, ply.name, args.Who, 0, 0, 0, 0);
ply.name = name;
var text = args.Text;
Hooks.PlayerHooks.OnPlayerChat(tsplr, args.Text, ref text);
NetMessage.SendData((int)PacketTypes.ChatText, -1, args.Who, text, args.Who, tsplr.Group.R, tsplr.Group.G, tsplr.Group.B);
NetMessage.SendData((int)PacketTypes.PlayerInfo, -1, -1, name, args.Who, 0, 0, 0, 0);
string msg = String.Format("<{0}> {1}",
String.Format(Config.ChatAboveHeadsFormat, tsplr.Group.Name, tsplr.Group.Prefix, tsplr.Name, tsplr.Group.Suffix),
text);
tsplr.SendMessage(msg, tsplr.Group.R, tsplr.Group.G, tsplr.Group.B);
TSPlayer.Server.SendMessage(msg, tsplr.Group.R, tsplr.Group.G, tsplr.Group.B);
Log.Info("Broadcast: {0}", msg);
args.Handled = true;
}
}
}
public void OnChat(ServerChatEventArgs args)
{
var Mplayer = Utils.GetPlayers(args.Who);
if (muteAll && !TShock.Players[args.Who].Group.HasPermission(Permissions.mute))
{
var tsplr = TShock.Players[args.Who];
if (args.Text.StartsWith(TShock.Config.CommandSpecifier) || args.Text.StartsWith(TShock.Config.CommandSilentSpecifier))
{
Commands.HandleCommand(tsplr, args.Text);
}
else
{
tsplr.SendErrorMessage("The server has been muted: " + config.muteAllReason);
}
args.Handled = true;
}
}
private void OnChat(ServerChatEventArgs args)
{
foreach (string cmd in config.unAllowedCommandsWhileImprisoned)
{
if (args.Text.StartsWith("/{0}".SFormat(cmd)) && Prisoners.Contains(TShock.Players[args.Who].IP))
{
TShock.Players[args.Who].SendErrorMessage("You cannot use this command while imprisoned.");
args.Handled = true;
}
}
}
