public void Reply(IReceiveMessage message, IMessageTarget sender, ReplyForm replyForm, object result)
{
IMessageTarget target = ReplyTarget(message);
ISendMessage sendMessage = ReplyMessage(message.Connection.MessageSender, target, replyForm, result);
if(replyForm != ReplyForm.More)
{
String[] messages = SplitMessage(sendMessage).ToArray();
if(messages.Length > _data.ReplyMores)
{
_moreMessages.Remove(sender);
_moreMessages.Add(sender, new Queue<String>(messages.Skip(_data.ReplyMores)));
_lastMore = sender;
}
message.Connection.SendAndForget(messages
.Take(_data.ReplyMores)
.Select(s => SendMessage(sendMessage, s, sender, replyForm))
);
}
else
{
message.Connection.SendAndForget(SendMessage(sendMessage, sendMessage.Contents, sender,
_bot.DefaultReplyForm));
}
}
public Boolean Register(IMessageTarget target)
{
String id = target.Id;
if (String.IsNullOrWhiteSpace(id))
{
return(false);
}
lock (_regedit)
{
if (_regedit.ContainsKey(id))
{
throw new InvalidOperationException($"The id {id} has been Existed");
}
_regedit.Add(id, target);
}
AddinProxy proxy = target as AddinProxy;
if (proxy != null)
{
proxy.MessageService = this;
proxy.Owner.DomainUnload += OnDomainUnload;
}
target.MessageDispatcher?.Start();
#if DEBUG
Console.WriteLine($"Register target.{target.Id}");
#endif
return(true);
}
public void Unregister(String id)
{
if (String.IsNullOrWhiteSpace(id))
{
return;
}
IMessageTarget target = null;
lock (_regedit)
{
if (!_regedit.ContainsKey(id))
{
return;
}
target = _regedit[id];
_regedit.Remove(id);
}
target.MessageDispatcher?.Stop();
AddinProxy proxy = target as AddinProxy;
if (proxy != null)
{
proxy.MessageService = null;
}
#if DEBUG
Console.WriteLine($"Unregister target.{target.Id}");
#endif
}
// IMessageTarget
public object SendMessage(LogoContext context, string message, ICollection arguments)
{
message = message.ToLower();
IMessageTarget target = (IMessageTarget)messages[message];
if (target == null)
{
foreach (IMessageStore store in List)
{
IMessageTarget store_target = store as IMessageTarget;
if (store_target != null && store.SupportsMessage(message))
{
target = store_target;
messages[message] = target;
break;
}
}
}
if (target == null)
{
throw new MessageNotSupportedException(message);
}
return(target.SendMessage(context, message, arguments));
}
public UserItemView(IMessageTarget user)
{
User = user;
Content = user.Name;
Icon = LazuriteUI.Icons.Icon.User;
Margin = new System.Windows.Thickness(0, 1, 0, 0);
}
private IReceiveMessage ParseDirectedMessage(Regex regex, ReceiveType type, IMessageTarget sender, String line)
{
Match results = regex.Match(line);
if (results.Success && results.Groups[1].Success)
{
String receiverName = results.Groups[1].Value;
IMessageTarget receiver = ParseReceiver(receiverName);
String message = String.Empty;
if (results.Groups[2].Success)
{
message = results.Groups[2].Value;
}
IMessageTarget realSender = sender;
if (sender.Type == MessageTargetType.User && receiver.Type == MessageTargetType.Channel)
{
IChannel channel = receiver as IChannel;
realSender = channel.GetUser(sender.Name);
}
return(Client.CreateReceiveMessage(Connection, message, DateTime.Now, realSender, receiver, type,
ReplyType.Unknown));
}
return(null);
}
public ISendMessage Mode(IMessageTarget target, String[] newModes, String[] newModeParameters)
{
if(newModes == null)
{
throw new ArgumentNullException("newModes");
}
if(newModeParameters == null)
{
throw new ArgumentNullException("newModeParameters");
}
if(newModes.Length != newModeParameters.Length)
{
throw new ArgumentException("newModes and newModeParameters must have the same size.");
}
StringBuilder newMode = new StringBuilder(newModes.Length);
StringBuilder newModeParameter = new StringBuilder();
// as per RFC 3.2.3, maximum is 3 modes changes at once
int maxModeChanges = 3;
if(newModes.Length > maxModeChanges)
{
throw new ArgumentOutOfRangeException(
"newModes.Length",
newModes.Length,
String.Format("Mode change list is too large (> {0}).", maxModeChanges)
);
}
for(int i = 0; i <= newModes.Length; i += maxModeChanges)
{
for(int j = 0; j < maxModeChanges; j++)
{
if(i + j >= newModes.Length)
{
break;
}
newMode.Append(newModes[i + j]);
}
for(int j = 0; j < maxModeChanges; j++)
{
if(i + j >= newModeParameters.Length)
{
break;
}
newModeParameter.Append(newModeParameters[i + j]);
newModeParameter.Append(" ");
}
}
if(newModeParameter.Length > 0)
{
// remove trailing space
newModeParameter.Length--;
newMode.Append(" ");
newMode.Append(newModeParameter.ToString());
}
return Mode(target, newMode.ToString());
}
public IReceiveMessage Receive(String raw)
{
if (raw == null)
{
throw new ArgumentNullException("raw");
}
if (String.IsNullOrWhiteSpace(raw))
{
throw new ArgumentException("Not an IRC line", "raw");
}
// Remove first :
String line = null;
if (raw[0] == ':')
{
line = raw.Substring(1);
}
else
{
line = raw;
}
// Try to parse messages without prefixes.
IReceiveMessage message = ParseNoPrefixMessage(line);
if (message != null)
{
return(message);
}
// Tokenize
String[] tokens = line.Split(new [] { ' ' }, 3);
String prefix = tokens[0];
String command = tokens[1];
String parameters = String.Empty;
if (tokens.Length == 3)
{
parameters = tokens[2];
}
// Parse sender
IMessageTarget sender = ParseSender(prefix);
// Parse message type
Tuple <ReceiveType, ReplyType> type = ParseMessageType(command);
// Parse message
if (type.Item1 != ReceiveType.Unknown)
{
return(ParseInformationMessage(sender, type.Item1, type.Item2, parameters));
}
else
{
return(ParseMessage(sender, line.Substring(prefix.Length + 1)));
}
}
/// <summary>
/// 初始化类型 Tumbler.Addin.Core.MessageDispathcer 实例。
/// </summary>
/// <param name="target">实现了 IMessageTarget 接口的类型实例。</param>
public MessageDispatcher(IMessageTarget target)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
_target = target;
_queue = new Queue <Message>(MaxCount);
_syncEvent = new ManualResetEventSlim(false);
}
public String More(IMessageTarget sender)
{
if(!_moreMessages.ContainsKey(sender))
throw new InvalidOperationException("No more messages in the buffer.");
Queue<String> moreMessages = _moreMessages[sender];
if(moreMessages.Count == 0)
throw new InvalidOperationException("No more messages in the buffer.");
return moreMessages.Dequeue();
}
protected NetworkEvent CreateEvent(byte code, object data, IMessageTarget target)
{
return(new NetworkEvent
{
SenderId = LocalClientRef.ClientId,
Code = code,
Data = data,
Target = target
});
}
public ReceiveMessage(IClientConnection connection, String contents, DateTime date, IMessageTarget sender,
IMessageTarget receiver, ReceiveType type, ReplyType replyType)
{
Connection = connection;
Contents = contents;
Date = date;
Sender = sender;
Receiver = receiver;
Type = type;
ReplyType = replyType;
}
public ReceiveMessage(IClientConnection connection, String contents, DateTime date, IMessageTarget sender,
IMessageTarget receiver, ReceiveType type, ReplyType replyType)
{
Connection = connection;
Contents = contents;
Date = date;
Sender = sender;
Receiver = receiver;
Type = type;
ReplyType = replyType;
}
public int RegisterTarget(IMessageTarget target, int groupId)
{
// Add the new target
var context = new TargetContext();
context.Target = target;
context.GroupId = groupId;
this.Targets.Add(context);
return(this.NumTargets - 1);
}
public override async Task SendMessage(IMessageTarget target, Message message)
{
if (message.Count == 0)
{
return;
}
long id;
switch (target)
{
case GroupTarget g:
id = g.id;
break;
case UserTarget u:
id = u.id;
break;
default:
return;
}
foreach (var sub in message)
{
switch (sub)
{
case TextSub textSub:
await PostJson("sendMessage", new JsonData {
["chat_id"] = id,
["text"] = textSub.text,
["parse_mode"] = "Markdown"
});
break;
case LocalImageSub localImageSub:
var photoContent = new MultipartFormDataContent();
photoContent.Add(new StringContent(id.ToString()), "chat_id");
photoContent.Add(new ByteArrayContent(
await File.ReadAllBytesAsync(Path.Join("./Resources/images", localImageSub.resourcePath))
), "photo", Path.GetFileName(localImageSub.resourcePath));
await PostMPF("sendPhoto", photoContent);
/*await PostJson("sendPhoto", new JsonData {
* ["chat_id"] = id,
* ["photo"] = new Uri(new Uri(new Uri(_botServiceUrl), "images"), localImageSub.resourcePath).ToString()
* });*/
break;
}
}
}
private IReceiveMessage ParseInviteMessage(IMessageTarget sender, String line)
{
Match results = InviteRegex.Match(line);
if (results.Success && results.Groups[1].Success && results.Groups[2].Success)
{
String userName = results.Groups[1].Value;
String channelName = results.Groups[2].Value;
IChannel channel = Connection.GetChannel(channelName);
return(Client.CreateReceiveMessage(Connection, userName, DateTime.Now, sender, channel,
ReceiveType.Invite, ReplyType.Unknown));
}
return(null);
}
protected int[] ResolveClientIds(IMessageTarget target)
{
if (target is IClientIdResolvable)
{
var resolvable = (IClientIdResolvable)target;
OneClientIdList[0] = resolvable.ClientId;
return(OneClientIdList);
}
if (target is IClientIdListResolvable)
{
var resolvable = (IClientIdListResolvable)target;
return(resolvable.GetClientIds());
}
return(EmptyClientIdList);
}
public override async Task SendMessage(IMessageTarget target, Message message)
{
if (message.Count == 0)
{
return;
}
JsonData msgChain = new JsonData();
foreach (var sub in message)
{
switch (sub)
{
case LocalImageSub localImageSub:
msgChain.Add(new JsonData {
["type"] = "Image",
["path"] = localImageSub.resourcePath
});
break;
case TextSub textSub:
msgChain.Add(new JsonData {
["type"] = "Plain",
["text"] = textSub.text
});
break;
case AtSub atSub:
msgChain.Add(new JsonData {
["type"] = "At",
["target"] = atSub.target
});
break;
}
}
switch (target)
{
case GroupTarget groupTarget:
await PostJson("/sendGroupMessage", new JsonData {
["sessionKey"] = sessionKey,
["target"] = groupTarget.id,
["messageChain"] = msgChain
});
break;
}
}
private void SendRpc(string name, IMessageTarget target, bool reliable, object[] parameters)
{
if (!_rpcMethodLookup.ContainsKey(name))
{
throw new InvalidOperationException($"No RPC method with the name {name} is registered on the component." +
$"Check if you misspelled it or forgot to add the {nameof(NetworkRpcAttribute)} to your method.");
}
var call = new RpcCall
{
EntityId = _context.Entity.Id,
ComponentId = _context.Id,
RpcCode = _rpcMethodLookup[name],
Params = parameters
};
_context.Entity.Manager.SendEvent(DefaultEvents.Rpc, call, target, reliable);
}
private IReceiveMessage ParseUndirectedMessage(Regex regex, ReceiveType type, IMessageTarget sender, String line,
IMessageTarget receiver)
{
Match results = regex.Match(line);
if (results.Success)
{
String message = String.Empty;
if (results.Groups[1].Success)
{
message = results.Groups[1].Value;
}
return(Client.CreateReceiveMessage(Connection, message, DateTime.Now, sender, receiver, type,
ReplyType.Unknown));
}
return(null);
}
private IMessageTarget ParseReceiver(String name)
{
IMessageTarget receiver = null;
switch (name[0])
{
case '#':
case '!':
case '&':
case '+':
receiver = Connection.GetChannel(name);
break;
default:
receiver = Connection.GetUser(name);
break;
}
return(receiver);
}
public static Boolean IsFromHost(this IMessageTarget target, Message message)
{
if (message.Source == MessageService.AddinHostId)
{
return(true);
}
String hostActualId = null;
if (AppDomain.CurrentDomain.IsDefaultAppDomain())
{
MessageService ms = AppDomain.CurrentDomain.GetData("ms") as MessageService;
hostActualId = ms?.GetHostActualId();
}
else
{
AddinProxy proxy = AppDomain.CurrentDomain.GetData("proxy") as AddinProxy;
hostActualId = proxy?.GetHostActualId();
}
return(hostActualId == message.Source);
}
public override void SendEvent(byte code, object data, IMessageTarget target, bool reliable = true)
{
if (_photonClient.CurrentRoom == null)
{
throw new InvalidOperationException("Cannot send events before joining a room.");
}
var evt = CreateEvent(code, data, target);
ReceiverGroup?receivers = null;
int[] targetClients = null;
if (target == null || target == MessageTarget.Others)
{
receivers = ReceiverGroup.Others;
}
else if (target == MessageTarget.AllPlayers)
{
receivers = ReceiverGroup.All;
}
else if (target == MessageTarget.Server)
{
receivers = ReceiverGroup.MasterClient;
}
else
{
targetClients = ResolveClientIds(target);
}
_raiseEventOptions.TargetActors = targetClients;
_raiseEventOptions.Receivers = receivers ?? ReceiverGroup.Others;
var serialized = Serializer.Serialize(evt, out int length);
_photonArrayWrapper.Array = serialized;
_photonArrayWrapper.Length = length;
// Send the event over the network
_photonClient.OpRaiseEvent(PhotonEventCode, evt.Data != null ? _photonArrayWrapper : null,
_raiseEventOptions, reliable ? SendOptions.SendReliable : SendOptions.SendUnreliable);
}
private IReceiveMessage ParseKickMessage(IMessageTarget sender, String line)
{
Match results = KickRegex.Match(line);
if (results.Success && results.Groups[1].Success && results.Groups[2].Success)
{
String channelName = results.Groups[1].Value;
String userName = results.Groups[2].Value;
String message = String.Empty;
if (results.Groups[3].Success)
{
message = results.Groups[3].Value;
}
IChannel channel = Connection.GetChannel(channelName);
IChannelUser channelUser = channel.GetUser(userName);
return(Client.CreateReceiveMessage(Connection, message, DateTime.Now, sender, channelUser,
ReceiveType.Kick, ReplyType.Unknown));
}
return(null);
}
private IReceiveMessage ParseModeMessage(IMessageTarget sender, String line)
{
Match results = ModeRegex.Match(line);
if (results.Success && results.Groups[1].Success)
{
String receiverName = results.Groups[1].Value;
IMessageTarget receiver = ParseReceiver(receiverName);
String message = String.Empty;
if (results.Groups[2].Success)
{
message = results.Groups[2].Value;
}
ReceiveType type = receiver.Type == MessageTargetType.Channel ? ReceiveType.ChannelModeChange :
ReceiveType.UserModeChange;
return(Client.CreateReceiveMessage(Connection, message, DateTime.Now, sender, receiver, type,
ReplyType.Unknown));
}
return(null);
}
public override void SendEvent(byte code, object data, IMessageTarget target, bool reliable = true)
{
var evt = CreateEvent(code, data, target);
// TODO: handle targets properly
int[] targetClients = ResolveClientIds(target);
if (target == MessageTarget.AllPlayers || targetClients != null && targetClients.Contains(_isServer ? 1 : 2))
{
EventSubject.OnNext(evt);
}
_manager.GetPeersNonAlloc(_peers);
if (target == MessageTarget.AllPlayers || target == MessageTarget.Others ||
targetClients != null && targetClients.Contains(_isServer ? 2 : 1))
{
foreach (var peer in _peers)
{
peer.Send(Serializer.Serialize(evt, out int length), 0, length,
reliable ? SendOptions.Unreliable : SendOptions.ReliableOrdered);
}
}
}
/// <summary>
/// Sends an action to this target.
/// </summary>
///
/// <param name="channel">The channel to act on.</param>
/// <param name="action"> The action.</param>
public static void SendAction(this IMessageTarget target, String action)
{
IClientConnection connection = target.Connection;
connection.SendAndForget(connection.MessageSender.Action(target, action));
}
private IReceiveMessage ParseDirectedMessage(Regex regex, ReceiveType type, IMessageTarget sender, String line)
{
Match results = regex.Match(line);
if(results.Success && results.Groups[1].Success)
{
String receiverName = results.Groups[1].Value;
IMessageTarget receiver = ParseReceiver(receiverName);
String message = String.Empty;
if(results.Groups[2].Success)
message = results.Groups[2].Value;
IMessageTarget realSender = sender;
if(sender.Type == MessageTargetType.User && receiver.Type == MessageTargetType.Channel)
{
IChannel channel = receiver as IChannel;
realSender = channel.GetUser(sender.Name);
}
return Client.CreateReceiveMessage(Connection, message, DateTime.Now, realSender, receiver, type,
ReplyType.Unknown);
}
return null;
}
private IReceiveMessage ParseInformationMessage(IMessageTarget sender, ReceiveType type, ReplyType replyType,
String parameters)
{
return Client.CreateReceiveMessage(Connection, parameters, DateTime.Now, sender, Connection.Me, type,
replyType);
}
public ISendMessage Notice(IMessageTarget receiver, String message)
{
return Client.CreateSendMessage(Connection, String.Concat("NOTICE ", receiver.Name, " :"), message,
String.Empty, SendType.Notice, receiver);
}
private IReceiveMessage ParseInviteMessage(IMessageTarget sender, String line)
{
Match results = InviteRegex.Match(line);
if(results.Success && results.Groups[1].Success && results.Groups[2].Success)
{
String userName = results.Groups[1].Value;
String channelName = results.Groups[2].Value;
IChannel channel = Connection.GetChannel(channelName);
return Client.CreateReceiveMessage(Connection, userName, DateTime.Now, sender, channel,
ReceiveType.Invite, ReplyType.Unknown);
}
return null;
}
private IReceiveMessage ParseMessage(IMessageTarget sender, String line)
{
IReceiveMessage message = null;
message = ParseDirectedMessage(ActionRegex, ReceiveType.Action, sender, line);
if(message != null) return message;
message = ParseDirectedMessage(MessageRegex, ReceiveType.Message, sender, line);
if(message != null) return message;
message = ParseDirectedMessage(NoticeRegex, ReceiveType.Notice, sender, line);
if(message != null) return message;
message = ParseDirectedMessage(JoinRegex, ReceiveType.Join, sender, line);
if(message != null) return message;
message = ParseDirectedMessage(PartRegex, ReceiveType.Part, sender, line);
if(message != null) return message;
message = ParseKickMessage(sender, line);
if(message != null) return message;
message = ParseDirectedMessage(TopicRegex, ReceiveType.TopicChange, sender, line);
if(message != null) return message;
message = ParseUndirectedMessage(NickRegex, ReceiveType.NickChange, sender, line,
Connection.Me.Network.Value);
if(message != null) return message;
message = ParseUndirectedMessage(QuitRegex, ReceiveType.Quit, sender, line, Connection.Me.Network.Value);
if(message != null) return message;
message = ParseModeMessage(sender, line);
if(message != null) return message;
message = ParseInviteMessage(sender, line);
if(message != null) return message;
return Client.CreateReceiveMessage(Connection, line, DateTime.Now, sender, Connection.Me.Network.Value,
ReceiveType.Unknown, ReplyType.Unknown);
}
private IReceiveMessage ParseModeMessage(IMessageTarget sender, String line)
{
Match results = ModeRegex.Match(line);
if(results.Success && results.Groups[1].Success)
{
String receiverName = results.Groups[1].Value;
IMessageTarget receiver = ParseReceiver(receiverName);
String message = String.Empty;
if(results.Groups[2].Success)
message = results.Groups[2].Value;
ReceiveType type = receiver.Type == MessageTargetType.Channel ? ReceiveType.ChannelModeChange :
ReceiveType.UserModeChange;
return Client.CreateReceiveMessage(Connection, message, DateTime.Now, sender, receiver, type,
ReplyType.Unknown);
}
return null;
}
private IReceiveMessage ParseUndirectedMessage(Regex regex, ReceiveType type, IMessageTarget sender, String line,
IMessageTarget receiver)
{
Match results = regex.Match(line);
if(results.Success)
{
String message = String.Empty;
if(results.Groups[1].Success)
message = results.Groups[1].Value;
return Client.CreateReceiveMessage(Connection, message, DateTime.Now, sender, receiver, type,
ReplyType.Unknown);
}
return null;
}
private ISendMessage ReplyMessage(IMessageSender messageSender, IMessageTarget target, ReplyForm replyForm,
object result)
{
switch(replyForm)
{
case ReplyForm.Action: return messageSender.Action(target, result.ToString());
case ReplyForm.Notice: return messageSender.Notice(target, result.ToString());
default: return messageSender.Message(target, result.ToString());
}
}
public String More(IMessageTarget sender)
{
return _replyHandler.More(sender);
}
private ISendMessage SendMessage(ISendMessage message, String contents, IMessageTarget sender,
ReplyForm replyForm)
{
if(replyForm == ReplyForm.Reply)
contents = sender.Name + ": " + contents;
return message.Connection.Client.CreateSendMessage(message, contents);
}
public ISendMessage Notice(IMessageTarget receiver, String message)
{
return Client.CreateSendMessage(Connection, String.Concat("NOTICE ", receiver.Name, " :"), message,
String.Empty, SendType.Notice, receiver);
}
public IReceiveMessage CreateReceiveMessage(IClientConnection connection, String contents, DateTime date,
IMessageTarget sender, IMessageTarget receiver, ReceiveType type, ReplyType replyType)
{
return new ReceiveMessage(connection, contents, date, sender, receiver, type, replyType);
}
private IReceiveMessage ParseKickMessage(IMessageTarget sender, String line)
{
Match results = KickRegex.Match(line);
if(results.Success && results.Groups[1].Success && results.Groups[2].Success)
{
String channelName = results.Groups[1].Value;
String userName = results.Groups[2].Value;
String message = String.Empty;
if(results.Groups[3].Success)
message = results.Groups[3].Value;
IChannel channel = Connection.GetChannel(channelName);
IChannelUser channelUser = channel.GetUser(userName);
return Client.CreateReceiveMessage(Connection, message, DateTime.Now, sender, channelUser,
ReceiveType.Kick, ReplyType.Unknown);
}
return null;
}
public ISendMessage Action(IMessageTarget receiver, String action)
{
return Client.CreateSendMessage(Connection, String.Concat("PRIVMSG ", receiver.Name, " :"),
String.Concat('\x001', "ACTION ", action, '\x001'), String.Empty, SendType.Privmsg, receiver);
}
public ISendMessage Message(IMessageTarget receiver, String message)
{
return Client.CreateSendMessage(Connection, String.Concat("PRIVMSG ", receiver.Name, " :"), message,
String.Empty, SendType.Privmsg, receiver);
}
public abstract Task SendMessage(IMessageTarget target, Message message);
public ISendMessage Mode(IMessageTarget target)
{
return Client.CreateSendMessage(Connection, "MODE ", target.Name, String.Empty, SendType.Mode, target);
}
public IReceiveMessage CreateReceiveMessage(IClientConnection connection, String contents, DateTime date,
IMessageTarget sender, IMessageTarget receiver, ReceiveType type, ReplyType replyType)
{
return(new ReceiveMessage(connection, contents, date, sender, receiver, type, replyType));
}
public ISendMessage Mode(IMessageTarget target, String newmode, String newModeParameter)
{
return Client.CreateSendMessage(Connection, "MODE ", String.Concat(target.Name, " ", newmode, " ",
newModeParameter), String.Empty, SendType.Mode, target);
}
public bool ContainsReceiver(IMessageTarget receiver)
{
return _receivers.Contains(receiver);
}
public ISendMessage Mode(IMessageTarget target, String[] newModes, String[] newModeParameters)
{
if(newModes == null)
{
throw new ArgumentNullException("newModes");
}
if(newModeParameters == null)
{
throw new ArgumentNullException("newModeParameters");
}
if(newModes.Length != newModeParameters.Length)
{
throw new ArgumentException("newModes and newModeParameters must have the same size.");
}
StringBuilder newMode = new StringBuilder(newModes.Length);
StringBuilder newModeParameter = new StringBuilder();
// as per RFC 3.2.3, maximum is 3 modes changes at once
int maxModeChanges = 3;
if(newModes.Length > maxModeChanges)
{
throw new ArgumentOutOfRangeException(
"newModes.Length",
newModes.Length,
String.Format("Mode change list is too large (> {0}).", maxModeChanges)
);
}
for(int i = 0; i <= newModes.Length; i += maxModeChanges)
{
for(int j = 0; j < maxModeChanges; j++)
{
if(i + j >= newModes.Length)
{
break;
}
newMode.Append(newModes[i + j]);
}
for(int j = 0; j < maxModeChanges; j++)
{
if(i + j >= newModeParameters.Length)
{
break;
}
newModeParameter.Append(newModeParameters[i + j]);
newModeParameter.Append(" ");
}
}
if(newModeParameter.Length > 0)
{
// remove trailing space
newModeParameter.Length--;
newMode.Append(" ");
newMode.Append(newModeParameter.ToString());
}
return Mode(target, newMode.ToString());
}
public bool ContainsReceiver(IMessageTarget receiver)
{
return(_receivers.Contains(receiver));
}
public ISendMessage Action(IMessageTarget receiver, String action)
{
return Client.CreateSendMessage(Connection, String.Concat("PRIVMSG ", receiver.Name, " :"),
String.Concat('\x001', "ACTION ", action, '\x001'), String.Empty, SendType.Privmsg, receiver);
}
/// <summary>
/// Sends a notice to this target.
/// </summary>
///
/// <param name="channel">The channel to act on.</param>
/// <param name="notice"> The notice.</param>
public static void SendNotice(this IMessageTarget target, String notice)
{
IClientConnection connection = target.Connection;
connection.SendAndForget(connection.MessageSender.Notice(target, notice));
}
public void Reply(IReceiveMessage message, IMessageTarget sender, ReplyForm replyForm, Exception e)
{
LogUserError(message, e);
if(!_data.ReplyError)
return;
if(_data.ReplyErrorDetailed)
Reply(message, sender, replyForm, "Error -- " + e.Message);
else
Reply(message, sender, replyForm, "An error occurred.");
}