public void Execute(ServerCore server, ClientConnection connection, string[] arguments)
{
if (arguments == null)
{
// enumerate all available commands
var result = Enumerable.ToArray <string>((from p in server.CommandsManager.Commands
where !(p is IRoleRestrictedCommand) || (p as IRoleRestrictedCommand).HasAccess(connection.UserRole)
select p.Id));
var commandsList = string.Join(", ", result);
connection.Send(new ChatMessage {
IsServerMessage = true, DisplayName = "server", Message = string.Format("Available commands: {0}.\nUse help [command_name] to get additioanl information about command", commandsList)
});
return;
}
// show details about command
var cmdName = arguments[0].ToLower();
IChatCommand c = Enumerable.FirstOrDefault <IChatCommand>(server.CommandsManager.Commands, cmd => cmd.Id == cmdName);
if (c != null)
{
connection.SendChat(string.Format("{0} - {1}", cmdName, c.Description));
}
else
{
connection.SendChat("No such command");
}
}
public void Handle(ITwitchClient client, IChatCommand command)
{
if (this.CanHandle(command))
{
this.HandleInternal(client, command);
}
}
protected override bool CanHandle(IChatCommand chatCommand)
{
return(chatCommand.Is("mode") && chatCommand.HasParameters() ||
chatCommand.Is("stop") && chatCommand.IsFromStaff() ||
chatCommand.Is("lock") && chatCommand.IsFromStaff() ||
chatCommand.Is("unlock") && chatCommand.IsFromStaff());
}
public void OnCommandReceived(IChatCommand chatCommand)
{
if (this.IsActive() && this.CanHandle(chatCommand))
{
Handle(chatCommand);
}
}
public void Execute(IChatCommand command, object parameter = null)
{
var messageCommand = command as MessageCommand;
Console.WriteLine(
$"[{messageCommand.Time.ToLongTimeString()}] {messageCommand.Message.Author.Nickname}: {messageCommand.Message.Content}");
}
private bool GetCommand(MessageCreateEventArgs args, out IChatCommand commandProvider,
IServiceScope?scope = null)
{
var provider = scope == null ? _provider : scope.ServiceProvider;
var message = args.Message.Content.Substring(1);
var command = _commands.GetCommandType(message);
if (command == null)
{
_logger.LogWarning("Couldn't find command for message '{0}'", args.Message.Content);
commandProvider = null !;
return(false);
}
var service = provider.GetService(command);
if (service is IChatCommand c)
{
commandProvider = c;
return(true);
}
// Shouldn't happen at all
_logger.LogError("Couldn't find {0} in DI context", command.Name);
commandProvider = null !;
return(false);
}
private async void HandleCommands()
{
while (true)
{
IChatCommand command = null;
if (!this.commandsQueue.IsEmpty)
{
this.commandsQueue = this.commandsQueue.Dequeue(out command);
}
try
{
var stream = this.client.GetStream();
if (command != null)
{
await stream.WriteCommandAsync(command);
}
if (stream.DataAvailable)
{
var retrievedCommand = await stream.ReadCommandAsync();
this.dispatcher.Invoke(() =>
{
retrievedCommand.Execute(this.resolver, Messages);
});
}
}
catch
{
break;
}
}
}
private static void OnModuleUseFeat()
{
NWPlayer pc = _.OBJECT_SELF;
int featID = Convert.ToInt32(NWNXEvents.GetEventData("FEAT_ID"));
if (featID != (int)Feat.ChatCommandTargeter)
{
return;
}
var target = _.StringToObject(NWNXEvents.GetEventData("TARGET_OBJECT_ID"));
var targetPositionX = (float)Convert.ToDouble(NWNXEvents.GetEventData("TARGET_POSITION_X"));
var targetPositionY = (float)Convert.ToDouble(NWNXEvents.GetEventData("TARGET_POSITION_Y"));
var targetPositionZ = (float)Convert.ToDouble(NWNXEvents.GetEventData("TARGET_POSITION_Z"));
var targetPosition = Vector3(targetPositionX, targetPositionY, targetPositionZ);
var targetArea = _.StringToObject(NWNXEvents.GetEventData("AREA_OBJECT_ID"));
var targetLocation = Location(targetArea, targetPosition, 0.0f);
string command = pc.GetLocalString("CHAT_COMMAND");
string args = pc.GetLocalString("CHAT_COMMAND_ARGS");
if (string.IsNullOrWhiteSpace(command))
{
pc.SendMessage("Please enter a chat command and then use this feat. Type /help to learn more about the available chat commands.");
return;
}
IChatCommand chatCommand = GetChatCommandHandler(command);
ProcessChatCommand(chatCommand, pc, target, targetLocation, args);
pc.DeleteLocalString("CHAT_COMMAND");
pc.DeleteLocalString("CHAT_COMMAND_ARGS");
}
/// <summary>
/// Request the text to parse and check for commands that need to be executed.
/// </summary>
/// <param name="session">Session calling this method.</param>
/// <param name="message">The message to parse.</param>
/// <returns>True if parsed or false if not.</returns>
public bool Parse(Session session, string message)
{
if (!message.StartsWith(this._prefix))
{
return(false);
}
message = message.Substring(1, message.Length - 1);
string[] MsgSplit = message.Split(' ');
if (MsgSplit.Length == 0)
{
return(false);
}
IChatCommand command = this._commands.Where(cmd => cmd.Name.Equals(MsgSplit[0].ToLower())).FirstOrDefault();
if (command == null)
{
return(false);
}
if (!session.Player.HasPermission("cmd_" + command.Name))
{
return(false);
}
command.Handle(session, MsgSplit.Skip(1).ToArray());
session.Player.CurrentRoom.EntityManager.Send(new RoomUserTypingComposer(session.Player.Entity, false));
return(true);
}
private static void OnModuleUseFeat()
{
NWPlayer pc = Object.OBJECT_SELF;
int featID = NWNXEvents.OnFeatUsed_GetFeatID();
if (featID != (int)CustomFeatType.ChatCommandTargeter)
{
return;
}
var target = NWNXEvents.OnFeatUsed_GetTarget();
var targetLocation = NWNXEvents.OnFeatUsed_GetTargetLocation();
string command = pc.GetLocalString("CHAT_COMMAND");
string args = pc.GetLocalString("CHAT_COMMAND_ARGS");
if (string.IsNullOrWhiteSpace(command))
{
pc.SendMessage("Please enter a chat command and then use this feat. Type /help to learn more about the available chat commands.");
return;
}
IChatCommand chatCommand = GetChatCommandHandler(command);
ProcessChatCommand(chatCommand, pc, target, targetLocation, args);
pc.DeleteLocalString("CHAT_COMMAND");
pc.DeleteLocalString("CHAT_COMMAND_ARGS");
}
public ChatCommandProcessor AddDefaultCommand <T>() where T : IChatCommand, new()
{
AddCommand <T>();
ChatCommandId key = ChatCommandId.FromType <T>();
_defaultCommand = _commands[key];
return(this);
}
private void OnChatCommandReceived(object sender, OnChatCommandReceivedArgs e)
{
IChatCommand chatCommand = e.Command.Wrap();
foreach (ITwitchCommandListener listener in this.commandListeners)
{
listener.OnCommandReceived(chatCommand);
}
}
public static async Task WriteCommandAsync(this NetworkStream stream, IChatCommand command)
{
var commandBytes = command.SerializeToByteArray();
var commandSizeBytes = BitConverter.GetBytes(commandBytes.Length);
await stream.WriteAsync(commandSizeBytes, 0, commandSizeBytes.Length);
await stream.WriteAsync(commandBytes, 0, commandBytes.Length);
}
public void Execute(IChatCommand command, object parameter = null)
{
var messageCommand = command as MessageCommand;
var list = parameter as ICollection <ChatMessage>;
var message = new ChatTextMessage(messageCommand.Message.Author.Nickname, messageCommand.Message.Content);
list.Add(message);
}
public void RegisterCommand(IChatCommand command)
{
if (_commands.ContainsKey(command.Id))
{
throw new InvalidOperationException("Command with such id is already registered");
}
_commands.Add(command.Id, command);
}
protected override void Handle(IChatCommand chatCommand)
{
int spriteIndex;
if (int.TryParse(chatCommand.ArgumentsAsList[0], out spriteIndex))
{
this.UpdateSprite(spriteIndex);
}
}
protected override void Handle(IChatCommand chatCommand)
{
float newMovementSpeed;
if (float.TryParse(chatCommand.ArgumentsAsList[0], out newMovementSpeed))
{
this.UpdateMovementSpeed(newMovementSpeed);
}
}
public bool AddCommand(IChatCommand command)
{
if (_chatCommandsDictionary.ContainsKey(command.Command))
{
return(false);
}
_chatCommandsDictionary.Add(command.Command, command);
return(true);
}
public bool RemoveCommand(IChatCommand command)
{
if (!_chatCommandsDictionary.ContainsValue(command))
{
return(false);
}
_chatCommandsDictionary.Remove(command.Command);
return(true);
}
private void SpawnPotato(IChatCommand chatCommand)
{
Vector2 spawnPosition = GetRandomSpawnPosition();
GameObject potato = Instantiate(this.potatoPrefab, spawnPosition, Quaternion.identity);
potato.GetComponent <PotatoController>().SetName(chatCommand.ChatMessage.Username);
potato.GetComponent <PotatoDialogController>().UserName = chatCommand.ChatMessage.Username;
this.potatoes.Add(potato);
}
protected override void HandleInternal(ITwitchClient client, IChatCommand command)
{
Shoutout model = this.repository.Get(s => s.Command == command.ArgumentsAsList.FirstOrDefault());
if (model != null)
{
this.SendMessage(client, $@"▬▬☆✼★▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬★✼☆▬▬
{model.Message}
▬▬☆✼★━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━★✼☆▬▬");
}
}
private void HandleGerman(ITwitchClient client, IChatCommand command, CityWeather result)
{
if (result.City == null)
{
this.SendMessage(client, $"Tut mir leid {command.ChatMessage.UserName}, ich konnte keine Wetterdaten zu {command.ArgumentsAsString} finden.");
}
else
{
this.SendMessage(client, $"Wetter in {result.City}: {result.Weather.First().Description}. Es sind gerade {result.Temperatures.Temperature:0.#}°C ({result.Temperatures.FeelsLike:0.#}°C) mit {result.Temperatures.Humidity}% Luftfeuchtigkeit.");
}
}
private void HandleEnglish(ITwitchClient client, IChatCommand command, CityWeather result)
{
if (result.City == null)
{
this.SendMessage(client, $"Sorry {command.ChatMessage.UserName}, I couldn't find any weather data for {command.ArgumentsAsString}");
}
else
{
this.SendMessage(client, $"The weather in {result.City} is {result.Weather.First().Description}. It is {result.Temperatures.Temperature:0.#}°C ({result.Temperatures.FeelsLike:0.#}°C) with {result.Temperatures.Humidity}% humidity.");
}
}
public void OnCommandReceived(IChatCommand chatCommand)
{
if (chatCommand.Is("say") && !this.isDialogBoxOpen && this.UserName == chatCommand.ChatMessage.Username)
{
this.isDialogBoxOpen = true;
this.dialogBox.SetActive(true);
this.dialogBoxText.text = chatCommand.ArgumentsAsString;
StartCoroutine(this.CloseDialogBox());
}
}
public void OnModuleNWNXChat(NWPlayer sender)
{
if (!sender.IsPlayer || sender.IsDM)
{
return;
}
string message = _nwnxChat.GetMessage().Trim().ToLower();
// If it is double slash (//) treat it as a normal message (this is used by role-players to denote OOC speech)
if (message.Substring(0, 2) == "//")
{
return;
}
if (message.Substring(0, 1) != "/")
{
return;
}
var split = message.Split(' ').ToList();
// Commands with no arguments won't be split, so if we didn't split anything then add the command to the split list manually.
if (split.Count <= 0)
{
split.Add(message);
}
string command = split[0].Substring(1, split[0].Length - 1);
_nwnxChat.SkipMessage();
if (!App.IsKeyRegistered <IChatCommand>("ChatCommand." + command))
{
sender.SendMessage(_color.Red("Invalid chat command. Use '/help' to get a list of available commands."));
return;
}
IChatCommand chatCommand = App.ResolveByInterface <IChatCommand>("ChatCommand." + command);
CommandDetailsAttribute attribute = chatCommand.GetType().GetCustomAttribute <CommandDetailsAttribute>();
bool isDM = _auth.IsPCRegisteredAsDM(sender);
if (attribute != null &&
(attribute.Permissions.HasFlag(CommandPermissionType.Player) && sender.IsPlayer ||
attribute.Permissions.HasFlag(CommandPermissionType.DM) && isDM))
{
split.RemoveAt(0);
chatCommand.DoAction(sender, split.ToArray());
}
else
{
sender.SendMessage(_color.Red("Invalid chat command. Use '/help' to get a list of available commands."));
}
}
public void Add(IChatCommand c, params string[] cmds)
{
foreach (var cmd in cmds)
{
if (Commands.ContainsKey(cmd))
{
throw new ArgumentException($"collision for {cmd}, commands {Commands[cmd].GetType()} and {c.GetType()}");
}
Commands[cmd] = c;
}
}
private string getLocalizedCMDDesc(IChatCommand cmd, Locale loc)
{
if (loc.ContainsKey(cmd.DescriptionID))
{
return(loc[cmd.DescriptionID]);
}
else
{
return(cmd.Description);
}
}
private void EnqueueCommand(IChatCommand command)
{
lock (this.syncObject)
{
command.Execute(this.resolver);
}
foreach (var user in this.clients)
{
user.CommandsQueue = user.CommandsQueue.Enqueue(command);
}
}
protected override void HandleInternal(ITwitchClient client, IChatCommand command)
{
IEnumerable <TextCommand> textCommands = this.repository.GetAll();
foreach (TextCommand textCommand in textCommands)
{
if (this.replyLoader.TryGetReply(textCommand, command, out string reply))
{
SendMessage(client, reply);
return;
}
}
}
// Load all command types.
private void LoadCommands()
{
foreach (Type t in reflectionManager.GetAllChildren <IChatCommand>())
{
IChatCommand instance = (IChatCommand)Activator.CreateInstance(t, null);
if (_commands.ContainsKey(instance.Command))
{
Logger.Error("Command has duplicate name: {0}", instance.Command);
continue;
}
_commands[instance.Command] = instance;
}
}
