private void Callbacks_PlayerChat(object sender, PlayerChatEventArgs e)
{
RunCatchLog(() =>
{
if (CheckForServerRankCommand(e))
{
return;
}
if (CheckForNextServerRankCommand(e))
{
return;
}
if (CheckForInfoCommand(e))
{
return;
}
if (CheckForSelectUndrivenTracksCommand(e))
{
return;
}
if (CheckForLastSeenCommand(e))
{
return;
}
}, "Error in Callbacks_PlayerChat Method.", true);
}
private bool CheckForDeleteCheaterCommand(PlayerChatEventArgs args)
{
if (args.IsServerMessage || args.Text.IsNullOrTimmedEmpty())
{
return(false);
}
ServerCommand command = ServerCommand.Parse(args.Text);
if (!command.Is(Command.DeleteCheater) || command.PartsWithoutMainCommand.Count == 0)
{
return(false);
}
string login = command.PartsWithoutMainCommand[0];
if (!LoginHasRight(args.Login, true, Command.DeleteCheater))
{
return(true);
}
if (PlayerAdapter.RemoveAllStatsForLogin(login))
{
SendFormattedMessageToLogin(args.Login, Settings.CheaterDeletedMessage, "Login", login);
DetermineLocalRecords();
OnLocalRecordsDetermined(new List <RankEntry>(LocalRecords));
}
else
{
SendFormattedMessageToLogin(args.Login, Settings.CheaterDeletionFailedMessage, "Login", login);
}
return(true);
}
private bool CheckForTMXInfoCommand(PlayerChatEventArgs e)
{
ServerCommand command = ServerCommand.Parse(e.Text);
if (command.Is(Command.TMXInfo))
{
if (command.PartsWithoutMainCommand.Count > 0)
{
string trackID = command.PartsWithoutMainCommand[0];
TMXInfo tmxInfo = TMXInfo.Retrieve(trackID);
if (tmxInfo != null && !tmxInfo.Erroneous)
{
SendFormattedMessageToLogin(e.Login, "{[#ServerStyle]}> {[#MessageStyle]}[TMX-Info] Name: {[#HighlightStyle]}{[Name]}{[#MessageStyle]}, Author: {[#HighlightStyle]}{[Author]}{[#MessageStyle]}, Environment: {[#HighlightStyle]}{[Env]}", "Name", tmxInfo.Name, "Author", tmxInfo.Author, "Env", tmxInfo.Environment);
}
else
{
SendFormattedMessageToLogin(e.Login, "{[#ServerStyle]}> {[#ErrorStyle]}Could not retrieve trackinfo for trackid " + trackID);
}
}
return(true);
}
return(false);
}
private void Callbacks_PlayerChat(object sender, PlayerChatEventArgs e)
{
RunCatchLog(() =>
{
if (!ServerCommand.Parse(e.Text).Is(Command.ReadClanTagSettings))
{
return;
}
if (!LoginHasRight(e.Login, true, Command.ReadClanTagSettings))
{
return;
}
try
{
ReadConfigValues();
SendFormattedMessageToLogin(e.Login, "{[#ServerStyle]}> {[#MessageStyle]} Successfully read clan tag settings file.");
}
catch (Exception)
{
SendFormattedMessageToLogin(e.Login, "{[#ServerStyle]}> {[#ErrorStyle]}Error reading clan tag settings file. Please view log for a detailed error description.");
}
}, "Error in Callbacks_PlayerChat Method.", true);
}
private void OnPlayerChat(PlayerChatEventArgs args)
{
if (!args.Player.mute)
{
Discord.Send($"{args.TShockFormattedText.ParseText()}");
}
}
private bool CheckForGetMySpectatorsCommand(PlayerChatEventArgs e)
{
if (ServerCommand.Parse(e.Text).Is(Command.GetMySpectators))
{
if (!LoginHasRight(e.Login, true, Command.GetMySpectators))
{
return(true);
}
List <string> spectators = Context.PlayerSettings.GetAsList(playerSettings => playerSettings.SpectatorStatus.IsSpectator && playerSettings.SpectatorStatus.CurrentPlayerTargetID == e.PlayerID)
.Select(playerSettings => StripTMColorsAndFormatting(playerSettings.NickName) + "[{[#HighlightStyle]}" + playerSettings.Login + "{[#MessageStyle]}]")
.ToList();
if (spectators.Count > 0)
{
SendFormattedMessageToLogin(e.Login, "{[#ServerStyle]}> {[#HighlightStyle]}" + spectators.Count + " Spectator(s): {[#MessageStyle]}" + string.Join(", ", spectators.ToArray()));
}
else
{
SendFormattedMessageToLogin(e.Login, "{[#ServerStyle]}> Currently no one is spectating you!");
}
return(true);
}
return(false);
}
private void Callbacks_PlayerChat(object sender, PlayerChatEventArgs e)
{
RunCatchLog(() =>
{
if (e.IsServerMessage || e.Text.IsNullOrTimmedEmpty())
{
return;
}
if (CheckForGetAllSpectatorsCommand(e))
{
return;
}
if (CheckForGetMySpectatorsCommand(e))
{
return;
}
if (CheckForKickAllSpectatorsCommand(e))
{
return;
}
if (CheckForKickMySpectatorsCommand(e))
{
return;
}
}, "Error in Callbacks_PlayerChat Method.", true);
}
private bool CheckForSelectUndrivenTracksCommand(PlayerChatEventArgs args)
{
ServerCommand serverCommand = ServerCommand.Parse(args.Text);
if (!serverCommand.Is(Command.SelectUndrivenTracks))
{
return(false);
}
if (!LoginHasRight(args.Login, true, Command.SelectUndrivenTracks))
{
return(true);
}
string targetLogin = args.Login;
if (serverCommand.HasFurtherParts)
{
targetLogin = serverCommand.PartsWithoutMainCommand[0];
}
PlayerSettings playerSettings = GetPlayerSettings(targetLogin);
if (playerSettings == null)
{
SendNoPlayerWithLoginMessageToLogin(args.Login, targetLogin);
return(true);
}
SelectUndrivenTracks(args.Login, targetLogin);
return(true);
}
public void ChatReceived(object sender, PlayerChatEventArgs e)
{
if (e.Message == ".webui stop")
{
OnStop(null, null);
}
}
private void Callbacks_PlayerChat(object sender, PlayerChatEventArgs e)
{
if (!Settings.ResetOnChat || e.IsServerMessage)
{
return;
}
RunCatchLog(() => ResetValues(e.Login), "Error in Callbacks_PlayerChat Method.", true);
}
void demoParser_PlayerChat(object sender, PlayerChatEventArgs e)
{
Dispatcher.Invoke(new Action(() =>
{
this.textblockContent.Text += String.Format("[{0}] {1} > {2}", (e.TeamOnly) ? "t_say" : "say", e.Player.Name, e.Message) + Environment.NewLine;
this.scrollViewer.ScrollToBottom();
}
));
}
private void Callbacks_PlayerChat(object sender, PlayerChatEventArgs e)
{
RunCatchLog(() =>
{
if (CheckForTopSumsCommand(e))
{
return;
}
}, "Error in Callbacks_PlayerChat Method.", true);
}
private bool CheckForKickMySpectatorsCommand(PlayerChatEventArgs e)
{
if (ServerCommand.Parse(e.Text).Is(Command.KickMySpectators))
{
Context.CorePlugin.KickSpectatorsOf(e.Login, e.PlayerID);
return(true);
}
return(false);
}
private bool CheckForTopSumsCommand(PlayerChatEventArgs args)
{
if (!ServerCommand.Parse(args.Text).Is(Command.TopSums))
{
return(false);
}
SendTopSumsPageToLogin(args.Login, 0);
return(true);
}
private bool CheckForNextServerRankCommand(PlayerChatEventArgs args)
{
if (!ServerCommand.Parse(args.Text).Is(Command.NextRank))
{
return(false);
}
SendNextServerRankMessageToLogin(args.Login);
return(true);
}
private bool CheckForInfoCommand(PlayerChatEventArgs args)
{
if (!ServerCommand.Parse(args.Text).Is(Command.Info))
{
return(false);
}
SendInfoMessageToLogin(args.Login);
return(true);
}
private void Callbacks_PlayerChat(object sender, PlayerChatEventArgs e)
{
RunCatchLog(() =>
{
ServerCommand command = ServerCommand.Parse(e.Text);
if (command != null)
{
HandleCommand(e.Login, command);
}
}, "Errror in Callbacks_PlayerChat", true);
}
public static bool PlayerChat(SteamPlayer steamPlayer, ref byte modeByte, ref EChatMode mode, ref Color color, ref string text)
{
if (text.StartsWith("@") && steamPlayer.isAdmin)
{
// Send the admin command through.
return(false);
}
if (text.StartsWith("/"))
{
SysConsole.Output(OutputType.CLIENTINFO, "Player [" + steamPlayer.player.name + "] executing player command: " + text);
string cmd = text.Substring(1);
int splitPos = cmd.IndexOf(' ');
string args = "";
if (splitPos > 0)
{
args = cmd.Substring(splitPos + 1);
cmd = cmd.Substring(0, splitPos);
}
for (int i = 0; i < Instance.PlayerCommands.Count; i++)
{
if (Instance.PlayerCommands[i].check(steamPlayer.playerID.steamID, cmd, args))
{
return(true);
}
}
// TODO: if (CVars.g_showinvalidplayercommand.ValueB)
ChatManager.manager.channel.send("tellChat", steamPlayer.playerID.steamID, ESteamPacket.UPDATE_UNRELIABLE_BUFFER, steamPlayer.playerID.steamID, (byte)0, Color.red, "Unknown command!");
// Processed a local command.
return(true);
}
color = Color.white;
if (steamPlayer.isAdmin)
{
color = Palette.ADMIN;
}
else if (steamPlayer.isPro)
{
color = Palette.PRO;
}
PlayerChatEventArgs evt = new PlayerChatEventArgs();
evt.Player = new PlayerTag(steamPlayer);
evt.ChatMode = new TextTag(mode.ToString());
evt.Text = new TextTag(text);
evt.Color = new ColorTag(color);
UnturnedFreneticEvents.OnPlayerChat.Fire(evt);
mode = (EChatMode)Enum.Parse(typeof(EChatMode), evt.ChatMode.ToString().ToUpper());
modeByte = (byte)mode;
text = evt.Text.ToString();
color = evt.Color.Internal;
return(evt.Cancelled);
}
/// <summary>
/// Called when a chat message is intercepted
/// </summary>
/// <param name="args">event arguments passed by hook</param>
//private void OnChat(ServerChatEventArgs args)
private void OnChat(PlayerChatEventArgs args)
{
// Do not relay game chat to Discord if this option is enabled
if (Config.SilenceChat)
{
return;
}
// PlayerHooks.OnPlayerChat() already handles filtering commands and muted players.
// Do not relay commands or messages from muted players
//if(args.Text.StartsWith(TShock.Config.CommandSpecifier, StringComparison.InvariantCulture) || args.Text.StartsWith(TShock.Config.CommandSilentSpecifier, StringComparison.InvariantCulture) || TShock.Players[args.Who].mute)
// return;
// Attempt to convert any channel mentions
//string modifiedMessage = args.Text;
string modifiedMessage = args.RawText;
if (Regex.IsMatch(modifiedMessage, @"#.+"))
{
modifiedMessage = Util.ConvertChannelMentions(modifiedMessage, discord.Client);
}
// Attempt to convert any role/user mentions
if (Regex.IsMatch(modifiedMessage, @"@.+"))
{
modifiedMessage = Util.ConvertRoleUserMentions(modifiedMessage, discord.Client);
}
// Check for game items and convert them to friendly names if found
if (Regex.IsMatch(modifiedMessage, @"\[i(/p[0-9]+)?(/s[0-9]+)?:([0-9]+)\]"))
{
modifiedMessage = Util.ConvertItems(modifiedMessage);
}
// Convert emoticons to emojis if enabled
if (Config.ConvertEmoticons)
{
modifiedMessage = Util.ConvertEmoticons(modifiedMessage);
}
if (Config.LogChat)
{
//Util.Log($"{TShock.Players[args.Who].Name} said: {modifiedMessage}", Util.Severity.Info);
Util.Log($"{args.Player.Name} said: {modifiedMessage}", Util.Severity.Info);
}
//discord.Send($"**<{TShock.Players[args.Who].Name}>** {modifiedMessage}");
string text = Config.PlayerText.Replace("$player_name", args.Player.Name);
text = text.Replace("$group_name", args.Player.Group.Name);
text = text.Replace("$message", modifiedMessage);
discord.Send(text);
}
private void OnChat(PlayerChatEventArgs args)
{
if (!Config.SendChat)
{
return;
}
if (args.Handled)
{
return;
}
RestHelper.SendChatMessage(args.Player, args.TShockFormattedText);
}
private void Callbacks_PlayerChat(object sender, PlayerChatEventArgs e)
{
RunCatchLog(() =>
{
if (CheckForDeleteCheaterCommand(e))
{
return;
}
if (CheckForListLocalLoginsCommand(e))
{
return;
}
}, "Error in Callbacks_PlayerChat Method.", true);
}
private void OnPlayerChat(PlayerChatEventArgs args)
{
var player = args.Player;
if (player.HasPermission("leveling.noprefix"))
{
return;
}
var session = GetOrCreateSession(player);
args.TShockFormattedText = string.Format(TShock.Config.ChatFormat, player.Group.Name,
player.Group.Prefix + session.Level.Prefix, player.Name,
player.Group.Suffix,
args.RawText);
}
private void OnPlayerChat(PlayerChatEventArgs e)
{
//don't check commands
if (e.RawText.StartsWith(Commands.Specifier))
{
return;
}
if (!e.Player.HasPermission(SkillPermission))
{
return;
}
var session = Session.GetOrCreateSession(e.Player);
if (session.TriggerWordsToSkillDefinitions.Count > 0)
{
foreach (var kvp in session.TriggerWordsToSkillDefinitions)
{
var triggerWord = kvp.Key;
var definition = kvp.Value;
if (e.RawText.Contains(triggerWord))
{
//can we use this skill?
if (definition.PermissionsToUse != null && !PlayerFunctions.PlayerHasPermission(e.Player, definition.PermissionsToUse))
{
continue;
}
if (!session.IsSkillReady(definition.Name))
{
continue;
}
if (session.PlayerSkillInfos.TryGetValue(definition.Name, out var playerSkillInfo))
{
CustomSkillRunner.AddActiveSkill(e.Player, definition, playerSkillInfo.CurrentLevel);
return;
}
}
}
}
//Debug.Print($"Chat: raw: {e.RawText}");
//Debug.Print($"Chat: formatted: {e.TShockFormattedText}");
}
private void TextPacketHandle(TextPacket pk)
{
if (pk.Type == TextPacket.TYPE_CHAT)
{
string message = pk.Message.Trim();
if (message != "" && message.Length < 256)
{
PlayerChatEventArgs playerChatEvent = new PlayerChatEventArgs(this, message);
PlayerEvents.OnPlayerChat(playerChatEvent);
if (playerChatEvent.IsCancel)
{
return;
}
message = $"<{this.Name}§f> {playerChatEvent.Message}§f";
Server.Instance.BroadcastChat(message);
}
}
}
void OnChat(PlayerChatEventArgs args)
{
if (Config.Chat)
{
if (string.IsNullOrWhiteSpace(args.RawText))
{
return;
}
string msg = string.Format(Discord.Config.TerrariaToDiscordFormat,
args.Player.Group.Prefix,
args.Player.Name,
(string.IsNullOrWhiteSpace(args.Player.Group.Suffix))?"":args.Player.Group.Suffix,
args.RawText);
Bridge.SendMessage(msg);
}
}
//[EventAttribute(Type = typeof(EventHandler<PlayerChatEventArgs>))]
//[EventAttribute(Type = typeof(PlayerChatEventArgs))]
public override void HandleMcpeText(McpeText message)
{
//base.HandleMcpeText(message);
Stopwatch watch = new Stopwatch();
watch.Start();
if (message.type == (byte)McpeText.ChatTypes.Chat)
{
PlayerChatEventArgs chatEvent = new PlayerChatEventArgs(this, message.message, null);
if (chatEvent.OnCallEvent())
{
//Level.BroadcastMessage(chatEvent.GetMessage());
base.HandleMcpeText(message);
}
}
watch.Stop();
Console.WriteLine(message.GetType() + " в Тиках :" + watch.ElapsedTicks + "\r\n");
Console.WriteLine(message.GetType() + " в MS :" + watch.ElapsedMilliseconds + "\r\n");
}
private void Callbacks_PlayerChat(object sender, PlayerChatEventArgs e)
{
RunCatchLog(() =>
{
if (e.IsServerMessage || e.Text.IsNullOrTimmedEmpty())
{
return;
}
if (e.IsRegisteredCommand && CheckForReadSettingsCommand(e))
{
return;
}
if (e.IsRegisteredCommand)
{
return;
}
foreach (string phrase in Phrases)
{
string regexPattern = @"\b" + Regex.Escape(phrase) + @"\b";
if (!Regex.IsMatch(e.Text, regexPattern, RegexOptions.Singleline | RegexOptions.IgnoreCase))
{
continue;
}
ChatBotAnswer answer = Answers[phrase];
if (answer.Wisper)
{
SendFormattedMessageToLogin(e.Login, string.Format("{0}{1}", Botname, answer.Answer));
}
else
{
SendFormattedMessage(string.Format("{0}{1}", Botname, answer.Answer));
}
break;
}
}, "Error in Callbacks_PlayerChat Method.", true);
}
private void Callbacks_PlayerChat(object sender, PlayerChatEventArgs e)
{
RunCatchLog(() =>
{
if (e.IsServerMessage || e.Text.IsNullOrTimmedEmpty())
{
return;
}
if (CheckForTMXInfoCommand(e))
{
return;
}
if (CheckForTMXAddTrackCommand(e))
{
return;
}
}, "Error in Callbacks_PlayerChat Method.", true);
}
private bool CheckForReadSettingsCommand(PlayerChatEventArgs e)
{
if (ServerCommand.Parse(e.Text).Is(Command.ReadChatBotSettings))
{
if (!LoginHasRight(e.Login, true, Command.ReadChatBotSettings))
{
return(true);
}
if (ReadSettings())
{
SendFormattedMessageToLogin(e.Login, "{[#ServerStyle]}> {[#MessageStyle]}ChatBot-Settings successfully read!");
}
else
{
SendFormattedMessageToLogin(e.Login, "{[#ServerStyle]}> {[#ErrorStyle]}Error while reading ChatBot-Settings. See log for detailed error description.");
}
return(true);
}
return(false);
}
/// <summary>
/// Called when a chat message is intercepted
/// </summary>
/// <param name="args">event arguments passed by hook</param>
//private void OnChat(ServerChatEventArgs args)
private void OnChat(PlayerChatEventArgs args)
{
// Do not relay game chat to Discord if this option is enabled
if (Config.SilenceChat)
{
return;
}
// PlayerHooks.OnPlayerChat() already handles filtering commands and muted players.
// Do not relay commands or messages from muted players
//if(args.Text.StartsWith(TShock.Config.CommandSpecifier, StringComparison.InvariantCulture) || args.Text.StartsWith(TShock.Config.CommandSilentSpecifier, StringComparison.InvariantCulture) || TShock.Players[args.Who].mute)
// return;
// Attempt to convert any channel mentions
//string modifiedMessage = args.Text;
string modifiedMessage = args.RawText;
if (Regex.IsMatch(modifiedMessage, @"#.+"))
{
modifiedMessage = Util.ConvertChannelMentions(modifiedMessage, discord.Client);
}
// Attempt to convert any role/user mentions
if (Regex.IsMatch(modifiedMessage, @"@.+"))
{
modifiedMessage = Util.ConvertRoleUserMentions(modifiedMessage, discord.Client);
}
if (Config.LogChat)
{
//Util.Log($"{TShock.Players[args.Who].Name} said: {modifiedMessage}", Util.Severity.Info);
Util.Log($"{args.Player.Name} said: {modifiedMessage}", Util.Severity.Info);
}
//discord.Send($"**<{TShock.Players[args.Who].Name}>** {modifiedMessage}");
discord.Send($"**<{args.Player.Name}>** {modifiedMessage}");
}
static void rconClient_PlayerChat(object sender, PlayerChatEventArgs e)
{
Log.Info("PlayerChat - Source; " + e.Source + " - Player: " + e.Player.Name + " - Message: " + e.Message);
}
private void Game_OnPlayerChat(object sender, PlayerChatEventArgs e)
{
Console.WriteLine("::::chat|" + e.Player.Name + "|" + e.Message);
}
