| public static ParseCommand ( [ player, [ cmd, bool fromConsole ) : bool | ||
| player | [ | Player who issued the command. |
| cmd | [ | Command to be parsed and executed. |
| fromConsole | bool | Whether this command is being called from a non-player (e.g. Console). |
| return | bool | |
static void ConfirmCommandCallback([NotNull] Player player, [NotNull] object tag, bool fromConsole)
{
if (player == null)
{
throw new ArgumentNullException("player");
}
if (tag == null)
{
throw new ArgumentNullException("tag");
}
CommandReader cmd = (CommandReader)tag;
cmd.Rewind();
cmd.IsConfirmed = true;
CommandManager.ParseCommand(player, cmd, fromConsole);
}
void HandleCommandMessage([NotNull] string rawMessage, bool fromConsole)
{
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
if (rawMessage.EndsWith("//"))
{
rawMessage = rawMessage.Substring(0, rawMessage.Length - 1);
}
CommandReader cmd = new CommandReader(rawMessage);
if (cmd.Descriptor == null)
{
MessageNow("Unknown command \"{0}\". See &H/Commands", cmd.Name);
}
else if (Info.IsFrozen && !cmd.Descriptor.UsableByFrozenPlayers)
{
MessageNow("&WYou cannot use this command while frozen.");
}
else
{
if (!cmd.Descriptor.DisableLogging)
{
Logger.Log(LogType.UserCommand,
"{0}: {1}",
Name,
rawMessage);
}
if (cmd.Descriptor.RepeatableSelection)
{
selectionRepeatCommand = cmd;
}
SendToSpectators(cmd.RawMessage);
CommandManager.ParseCommand(this, cmd, fromConsole);
if (!cmd.Descriptor.NotRepeatable)
{
LastCommand = cmd;
}
}
}
// Parses message incoming from the player
public void ParseMessage(string rawMessage, bool fromConsole)
{
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
if (partialMessage != null)
{
rawMessage = partialMessage + rawMessage;
partialMessage = null;
}
switch (CommandManager.GetMessageType(rawMessage))
{
case MessageType.Chat: {
if (!Can(Permission.Chat))
{
return;
}
if (Info.IsMuted)
{
MutedMessage();
return;
}
if (DetectChatSpam())
{
return;
}
if (World != null && !World.FireSentMessageEvent(this, ref rawMessage) ||
!Server.FireSentMessageEvent(this, ref rawMessage))
{
return;
}
Info.LinesWritten++;
Logger.Log("{0}: {1}", LogType.GlobalChat, Name, rawMessage);
// Escaped slash removed AFTER logging, to avoid confusion with real commands
if (rawMessage.StartsWith("//"))
{
rawMessage = rawMessage.Substring(1);
}
if (rawMessage.EndsWith("//"))
{
rawMessage = rawMessage.Substring(0, rawMessage.Length - 1);
}
if (Can(Permission.UseColorCodes) && rawMessage.Contains("%"))
{
rawMessage = Color.ReplacePercentCodes(rawMessage);
}
Server.SendToAllExceptIgnored(this, "{0}{1}: {2}", Console,
GetClassyName(), Color.White, rawMessage);
} break;
case MessageType.Command: {
if (rawMessage.EndsWith("//"))
{
rawMessage = rawMessage.Substring(0, rawMessage.Length - 1);
}
Logger.Log("{0}: {1}", LogType.UserCommand,
Name, rawMessage);
Command cmd = new Command(rawMessage);
LastCommand = cmd;
CommandManager.ParseCommand(this, cmd, fromConsole);
} break;
case MessageType.RepeatCommand: {
if (LastCommand == null)
{
Message("No command to repeat.");
}
else
{
LastCommand.Rewind();
Logger.Log("{0}: repeat {1}", LogType.UserCommand,
Name, LastCommand.Message);
Message("Repeat: {0}", LastCommand.Message);
CommandManager.ParseCommand(this, LastCommand, fromConsole);
}
} break;
case MessageType.PrivateChat: {
if (!Can(Permission.Chat))
{
return;
}
if (Info.IsMuted)
{
MutedMessage();
return;
}
if (DetectChatSpam())
{
return;
}
if (rawMessage.EndsWith("//"))
{
rawMessage = rawMessage.Substring(0, rawMessage.Length - 1);
}
string otherPlayerName, messageText;
if (rawMessage[1] == ' ')
{
otherPlayerName = rawMessage.Substring(2, rawMessage.IndexOf(' ', 2) - 2);
messageText = rawMessage.Substring(rawMessage.IndexOf(' ', 2) + 1);
}
else
{
otherPlayerName = rawMessage.Substring(1, rawMessage.IndexOf(' ') - 1);
messageText = rawMessage.Substring(rawMessage.IndexOf(' ') + 1);
}
if (messageText.Contains("%") && Can(Permission.UseColorCodes))
{
messageText = Color.ReplacePercentCodes(messageText);
}
// first, find ALL players (visible and hidden)
Player[] allPlayers = Server.FindPlayers(otherPlayerName);
// if there is more than 1 target player, exclude hidden players
if (allPlayers.Length > 1)
{
allPlayers = Server.FindPlayers(this, otherPlayerName);
}
if (allPlayers.Length == 1)
{
Player target = allPlayers[0];
if (target.IsIgnoring(Info))
{
if (CanSee(target))
{
MessageNow("&WCannot PM {0}&W: you are ignored.", target.GetClassyName());
}
}
else
{
Logger.Log("{0} to {1}: {2}", LogType.PrivateChat,
Name, target.Name, messageText);
target.Message("{0}from {1}: {2}",
Color.PM, Name, messageText);
if (CanSee(target))
{
Message("{0}to {1}: {2}",
Color.PM, target.Name, messageText);
}
else
{
NoPlayerMessage(otherPlayerName);
}
}
}
else if (allPlayers.Length == 0)
{
NoPlayerMessage(otherPlayerName);
}
else
{
ManyMatchesMessage("player", allPlayers);
}
} break;
case MessageType.RankChat: {
if (!Can(Permission.Chat))
{
return;
}
if (Info.IsMuted)
{
MutedMessage();
return;
}
if (DetectChatSpam())
{
return;
}
if (rawMessage.EndsWith("//"))
{
rawMessage = rawMessage.Substring(0, rawMessage.Length - 1);
}
string rankName = rawMessage.Substring(2, rawMessage.IndexOf(' ') - 2);
Rank rank = RankManager.FindRank(rankName);
if (rank != null)
{
Logger.Log("{0} to rank {1}: {2}", LogType.RankChat,
Name, rank.Name, rawMessage);
string messageText = rawMessage.Substring(rawMessage.IndexOf(' ') + 1);
if (messageText.Contains("%") && Can(Permission.UseColorCodes))
{
messageText = Color.ReplacePercentCodes(messageText);
}
string formattedMessage = String.Format("{0}({1}{2}){3}{4}: {5}",
rank.Color,
(ConfigKey.RankPrefixesInChat.GetBool() ? rank.Prefix : ""),
rank.Name,
Color.PM,
Name,
messageText);
Server.SendToRank(this, formattedMessage, rank);
if (Info.Rank != rank)
{
Message(formattedMessage);
}
}
else
{
Message("No rank found matching \"{0}\"", rankName);
}
} break;
case MessageType.Confirmation: {
if (CommandToConfirm != null)
{
if (DateTime.UtcNow.Subtract(CommandToConfirmDate).TotalSeconds < ConfirmationTimeout)
{
CommandToConfirm.IsConfirmed = true;
CommandManager.ParseCommand(this, CommandToConfirm, fromConsole);
CommandToConfirm = null;
}
else
{
MessageNow("Confirmation timed out. Enter the command again.");
}
}
else
{
MessageNow("There is no command to confirm.");
}
} break;
case MessageType.PartialMessage:
partialMessage = rawMessage.Substring(0, rawMessage.Length - 1);
MessageNow("Partial: &F{0}", partialMessage);
break;
case MessageType.Invalid: {
Message("Unknown command.");
} break;
}
}
/// <summary> Parses a message on behalf of this player. </summary>
/// <param name="rawMessage"> Message to parse. </param>
/// <param name="fromConsole"> Whether the message originates from console. </param>
/// <exception cref="ArgumentNullException"> rawMessage is null. </exception>
public void ParseMessage([NotNull] string rawMessage, bool fromConsole)
{
if (rawMessage == null)
{
throw new ArgumentNullException("rawMessage");
}
// handle canceling selections and partial messages
if (rawMessage.StartsWith("/nvm", StringComparison.OrdinalIgnoreCase) ||
rawMessage.StartsWith("/cancel", StringComparison.OrdinalIgnoreCase))
{
if (partialMessage != null)
{
MessageNow("Partial message cancelled.");
partialMessage = null;
}
else if (IsMakingSelection)
{
SelectionCancel();
MessageNow("Selection cancelled.");
}
else
{
MessageNow("There is currently nothing to cancel.");
}
return;
}
if (partialMessage != null)
{
rawMessage = partialMessage + rawMessage;
partialMessage = null;
}
// replace %-codes with &-codes
if (Can(Permission.UseColorCodes))
{
rawMessage = Chat.ReplacePercentColorCodes(rawMessage, true);
}
// replace emotes
if (Can(Permission.UseEmotes))
{
rawMessage = Chat.ReplaceEmoteKeywords(rawMessage);
}
rawMessage = Chat.UnescapeBackslashes(rawMessage);
switch (Chat.GetRawMessageType(rawMessage))
{
case RawMessageType.Chat:
HandleChatMessage(rawMessage);
break;
case RawMessageType.Command:
HandleCommandMessage(rawMessage, fromConsole);
break;
case RawMessageType.PrivateChat:
HandlePrivateChatMessage(rawMessage);
break;
case RawMessageType.RankChat:
HandleRankChatMessage(rawMessage);
break;
case RawMessageType.RepeatCommand:
if (LastCommand == null)
{
Message("No command to repeat.");
}
else
{
if (Info.IsFrozen && (LastCommand.Descriptor == null ||
!LastCommand.Descriptor.UsableByFrozenPlayers))
{
MessageNow("&WYou cannot use this command while frozen.");
return;
}
LastCommand.Rewind();
Logger.Log(LogType.UserCommand,
"{0} repeated: {1}",
Name,
LastCommand.RawMessage);
Message("Repeat: {0}", LastCommand.RawMessage);
SendToSpectators(LastCommand.RawMessage);
CommandManager.ParseCommand(this, LastCommand, fromConsole);
}
break;
case RawMessageType.Confirmation:
if (Info.IsFrozen)
{
MessageNow("&WYou cannot use any commands while frozen.");
return;
}
if (ConfirmCallback != null)
{
if (DateTime.UtcNow.Subtract(ConfirmRequestTime) < ConfirmationTimeout)
{
Logger.Log(LogType.UserCommand, "{0}: /ok", Name);
SendToSpectators("/ok");
ConfirmCallback(this, ConfirmParameter, fromConsole);
ConfirmCancel();
}
else
{
MessageNow("Confirmation timed out. Enter the command again.");
}
}
else
{
MessageNow("There is no command to confirm.");
}
break;
case RawMessageType.PartialMessage:
partialMessage = rawMessage.Substring(0, rawMessage.Length - 1);
MessageNow("Partial: &F{0}", partialMessage);
break;
case RawMessageType.Invalid:
MessageNow("Could not parse message.");
break;
}
}
