public static void SendChatAdminServerMessage(IPacketReceiver client, ChatActivableChannelsEnum channel, string message, int timestamp, string fingerprint, int senderId, string senderName, int accountId)
{
if (!string.IsNullOrEmpty(message))
{
client.Send(new ChatAdminServerMessage((sbyte)channel, message, timestamp, fingerprint, senderId, senderName, accountId));
}
}
public static string ToFriendlyString(this ChatActivableChannelsEnum channel)
{
switch (channel)
{
case ChatActivableChannelsEnum.CHANNEL_ADMIN:
return(LanguageManager.Translate("217"));
case ChatActivableChannelsEnum.CHANNEL_ALLIANCE:
return(LanguageManager.Translate("218"));
case ChatActivableChannelsEnum.CHANNEL_ARENA:
return(LanguageManager.Translate("219"));
case ChatActivableChannelsEnum.CHANNEL_GUILD:
return(LanguageManager.Translate("220"));
case ChatActivableChannelsEnum.CHANNEL_NOOB:
return(LanguageManager.Translate("221"));
case ChatActivableChannelsEnum.CHANNEL_PARTY:
return(LanguageManager.Translate("222"));
case ChatActivableChannelsEnum.CHANNEL_SALES:
return(LanguageManager.Translate("223"));
case ChatActivableChannelsEnum.CHANNEL_SEEK:
return(LanguageManager.Translate("224"));
case ChatActivableChannelsEnum.CHANNEL_TEAM:
return(LanguageManager.Translate("225"));
default: // Including GLOBAL
return("");
}
}
public void HandleChat(WorldClient client, ChatActivableChannelsEnum channel, string message)
{
if (this.CanUseChannel(client.Character, channel) && this.ChatHandlers.ContainsKey(channel))
{
if (message.StartsWith(ChatManager.CommandPrefix) && (message.Length < ChatManager.CommandPrefix.Length * 2 || message.Substring(ChatManager.CommandPrefix.Length, ChatManager.CommandPrefix.Length) != ChatManager.CommandPrefix))
{
message = message.Remove(0, ChatManager.CommandPrefix.Length);
ServerBase <WorldServer> .Instance.CommandManager.HandleCommand(new TriggerChat(new StringStream(ChatManager.UnescapeChatCommand(message)), client.Character));
}
else
{
if (client.Character.IsMuted())
{
client.Character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_ERROR, 124, new object[]
{
(int)client.Character.GetMuteRemainingTime().TotalSeconds
});
}
else
{
if (client.Character.ChatHistory.RegisterAndCheckFlood(new ChatEntry(message, channel, System.DateTime.Now)))
{
this.ChatHandlers[channel](client, message);
}
}
}
}
}
public string GetChannelName(ChatActivableChannelsEnum channel)
{
if (!m_channelsNames.ContainsKey(channel))
return "?";
return m_channelsNames[channel];
}
public bool CanUseChannel(Character character, ChatActivableChannelsEnum channel)
{
bool result;
switch (channel)
{
case ChatActivableChannelsEnum.CHANNEL_GLOBAL:
result = (!character.Map.IsMuted || character.UserGroup.Role >= ChatManager.AdministratorChatMinAccess);
break;
case ChatActivableChannelsEnum.CHANNEL_TEAM:
result = character.IsFighting();
break;
case ChatActivableChannelsEnum.CHANNEL_GUILD:
result = (character.Guild != null);
break;
case ChatActivableChannelsEnum.CHANNEL_PARTY:
result = character.IsInParty();
break;
case ChatActivableChannelsEnum.CHANNEL_SALES:
result = !character.IsMuted();
break;
case ChatActivableChannelsEnum.CHANNEL_SEEK:
result = !character.IsMuted();
break;
case ChatActivableChannelsEnum.CHANNEL_NOOB:
result = true;
break;
case ChatActivableChannelsEnum.CHANNEL_ADMIN:
result = (character.UserGroup.Role >= ChatManager.AdministratorChatMinAccess);
break;
case ChatActivableChannelsEnum.PSEUDO_CHANNEL_PRIVATE:
result = !character.IsMuted();
break;
case ChatActivableChannelsEnum.PSEUDO_CHANNEL_INFO:
result = false;
break;
case ChatActivableChannelsEnum.PSEUDO_CHANNEL_FIGHT_LOG:
result = false;
break;
case ChatActivableChannelsEnum.CHANNEL_ADS:
result = !character.IsMuted();
break;
default:
result = false;
break;
}
return(result);
}
public bool CanUseChannel(Character character, ChatActivableChannelsEnum channel)
{
switch (channel)
{
case ChatActivableChannelsEnum.CHANNEL_GLOBAL:
{
if (character.Map.IsMuted && character.UserGroup.Role <= AdministratorChatMinAccess)
{
character.SendServerMessage("La map est actuellement réduite au silence !");
return(false);
}
return(true);
}
case ChatActivableChannelsEnum.CHANNEL_TEAM:
return(character.IsFighting());
case ChatActivableChannelsEnum.CHANNEL_ARENA:
return(character.IsInParty(PartyTypeEnum.PARTY_TYPE_ARENA));
case ChatActivableChannelsEnum.CHANNEL_GUILD:
return(character.Guild != null);
case ChatActivableChannelsEnum.CHANNEL_ALLIANCE:
return(false);
case ChatActivableChannelsEnum.CHANNEL_PARTY:
return(character.IsInParty(PartyTypeEnum.PARTY_TYPE_CLASSICAL));
case ChatActivableChannelsEnum.CHANNEL_SALES:
return(!character.IsMuted());
case ChatActivableChannelsEnum.CHANNEL_SEEK:
return(!character.IsMuted());
case ChatActivableChannelsEnum.CHANNEL_NOOB:
return(true);
case ChatActivableChannelsEnum.CHANNEL_ADMIN:
return(character.UserGroup.Role >= AdministratorChatMinAccess);
case ChatActivableChannelsEnum.CHANNEL_ADS:
return(!character.IsMuted());
case ChatActivableChannelsEnum.PSEUDO_CHANNEL_PRIVATE:
return(!character.IsMuted());
case ChatActivableChannelsEnum.PSEUDO_CHANNEL_INFO:
return(false);
case ChatActivableChannelsEnum.PSEUDO_CHANNEL_FIGHT_LOG:
return(false);
default:
return(false);
}
}
public string GetChannelName(ChatActivableChannelsEnum channel)
{
if (!m_channelsNames.ContainsKey(channel))
{
return("?");
}
return(m_channelsNames[channel]);
}
public static ChatServerCopyMessage GetChatServerCopyMessage(ChatActivableChannelsEnum channel, string message, WorldClient client, WorldClient target)
{
return(new ChatServerCopyMessage((sbyte)ChatActivableChannelsEnum.PSEUDO_CHANNEL_PRIVATE,
message,
(int)DateExtensions.DateTimeToUnixTimestamp(DateTime.Now),
client.Character.Record.Name,
(uint)target.Character.Record.Id,
target.Character.Record.Name));
}
private Color GetChannelColor(ChatActivableChannelsEnum channel)
{
if (!m_colorsRules.ContainsKey(channel))
{
return(Colors.Black);
}
return(m_colorsRules[channel]);
}
public async Task SendMessage(string message, ChatActivableChannelsEnum channel = ChatActivableChannelsEnum.CHANNEL_GLOBAL)
{
if (string.IsNullOrEmpty(message))
{
return;
}
await _account.Network.SendMessageAsync(new ChatClientMultiMessage(message, (uint)channel));
}
public void HandleChat(WorldClient client, ChatActivableChannelsEnum channel, string message, IEnumerable <ObjectItem> objectItems = null)
{
if (!ChatHandlers.ContainsKey(channel))
{
return;
}
if (message.StartsWith(CommandPrefix) &&
(message.Length < CommandPrefix.Length * 2 || message.Substring(CommandPrefix.Length, CommandPrefix.Length) != CommandPrefix)) // ignore processing command whenever there is the preffix twice
{
message = message.Remove(0, CommandPrefix.Length); // remove our prefix
WorldServer.Instance.CommandManager.HandleCommand(new TriggerChat(new StringStream(UnescapeChatCommand(message)),
client.Character));
}
else
{
if (!CanUseChannel(client.Character, channel))
{
return;
}
var badword = CanSendMessage(message);
if (badword != string.Empty)
{
client.Character.SendServerMessage($"Message non envoyé. Le terme <b>{badword}</b> est interdit sur le serveur !");
return;
}
if (client.Character.IsMuted())
{
client.Character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_ERROR, 124, (int)client.Character.GetMuteRemainingTime().TotalSeconds);
}
else
{
if (client.Character.ChatHistory.RegisterAndCheckFlood(new ChatEntry(message, channel, DateTime.Now)))
{
ChatHandlers[channel](client, message, objectItems);
}
}
}
var document = new BsonDocument
{
{ "SenderId", client.Character.Id },
{ "SenderName", client.Character.Name },
{ "SenderAccountId", client.Account.Id },
{ "ReceiverId", 0 },
{ "ReceiverName", "" },
{ "ReceiverAccountId", 0 },
{ "Message", message },
{ "Channel", (int)channel },
{ "Date", DateTime.Now.ToString(CultureInfo.InvariantCulture) }
};
MongoLogger.Instance.Insert("Chats", document);
}
public static ChatServerMessage GetChatServerMessage(ChatActivableChannelsEnum channel, string message, WorldClient client)
{
return(new ChatServerMessage((sbyte)channel,
message,
(int)DateExtensions.DateTimeToUnixTimestamp(DateTime.Now),
string.Empty,
client.Character.Id,
client.Character.Name,
client.Account.Id));
}
static void Handle(WorldClient client, string message, ChatActivableChannelsEnum channel)
{
var handler = ChatHandlers.FirstOrDefault(x => x.Key == channel);
if (handler.Value != null)
{
handler.Value(client, message);
}
else
{
client.Character.Reply("Ce chat n'est pas géré");
}
}
// Constructor
public FloodSentence(string content, ChatActivableChannelsEnum channel, bool onPlayerJoined, bool onPlayerLeft)
{
Content = content;
Channel = channel;
if (Channel == ChatActivableChannelsEnum.PSEUDO_CHANNEL_PRIVATE)
{
OnPlayerJoined = onPlayerJoined;
OnPlayerLeft = onPlayerLeft;
}
else
{
OnPlayerJoined = false;
OnPlayerLeft = false;
}
}
static void Handle(WorldClient client, string message, ChatActivableChannelsEnum channel)
{
if (message.StartsWith(CommandsHandler.CommandsPrefix))
{
CommandsHandler.Handle(message, client);
return;
}
var handler = ChatHandlers.FirstOrDefault(x => x.Key == channel);
if (handler.Value != null)
{
handler.Value(client, message);
}
else
{
client.Character.Reply("Ce chat n'est pas géré");
}
}
private List <FloodSentence> GetSentences(ChatActivableChannelsEnum channel) => Configuration.Sentences.Where(s => s.Channel == channel).ToList();
public void Say(string message, ChatActivableChannelsEnum channel)
{
Bot.SendToServer(new ChatClientMultiMessage(message, (sbyte)channel));
}
public ChatChannelAttribute(ChatActivableChannelsEnum channel)
{
this.Channel = channel;
}
public static void SendChatAdminServerMessage(IPacketReceiver client, Character sender, ChatActivableChannelsEnum channel, string message)
{
ChatHandler.SendChatAdminServerMessage(client, sender, channel, message, System.DateTime.Now.GetUnixTimeStamp(), "");
}
private string GetChannelName(ChatActivableChannelsEnum channel)
{
return(m_channelNameConverter.GetChannelName(channel));
}
public static void SendChatServerMessage(IPacketReceiver client, Character sender, ChatActivableChannelsEnum channel, string message, int timestamp, string fingerprint)
{
if (string.IsNullOrEmpty(message))
{
return;
}
if (sender.UserGroup.Role <= RoleEnum.Moderator)
{
message = message.HtmlEntities();
}
client.Send(new ChatServerMessage(
(sbyte)channel,
message,
timestamp,
fingerprint,
sender.Id,
sender.Name,
sender.Account.Id));
}
public static bool IsGlobalChannel(ChatActivableChannelsEnum channel)
{
return(channel == ChatActivableChannelsEnum.CHANNEL_SALES || channel == ChatActivableChannelsEnum.CHANNEL_SEEK);
}
/// <summary>
/// Send a message to a specific channel
/// </summary>
/// <param name="content">Content of chat Message</param>
/// <param name="channel">Channel of the message</param>
public void SendMessage(string content, ChatActivableChannelsEnum channel)
{
if (content == null) throw new ArgumentNullException("content");
SendMessage(new ChatClientMultiMessage(content, (sbyte) channel));
}
/// <summary>
/// Send a Message to the Client
/// </summary>
/// <param name="content">Content of chat Message</param>
/// <param name="senderName">Name of the Sender</param>
/// <param name="channel">Channel of the chat Message</param>
public void SendMessageToClient(string content, string senderName, ChatActivableChannelsEnum channel)
{
if (content == null) throw new ArgumentNullException("content");
if (senderName == null) throw new ArgumentNullException("senderName");
m_bot.SendToClient(new ChatServerMessage((sbyte) channel, content, (int) DateTime.Now.DateTimeToUnixTimestamp(), "", 0, senderName, 0));
}
public static void SendChatServerCopyWithObjectMessage(IPacketReceiver client, Character sender, Character receiver, ChatActivableChannelsEnum channel, string message,
int timestamp, string fingerprint, IEnumerable <ObjectItem> objectItems)
{
if (!sender.UserGroup.IsGameMaster)
{
message = message.HtmlEntities();
}
client.Send(new ChatServerCopyWithObjectMessage(
(sbyte)channel,
message,
timestamp,
fingerprint,
receiver.Id,
receiver.Name,
objectItems));
}
public static void SendChatServerCopyWithObjectMessage(IPacketReceiver client, Character sender, Character receiver, ChatActivableChannelsEnum channel,
string message, IEnumerable <ObjectItem> objectItems)
{
SendChatServerCopyWithObjectMessage(client, sender, receiver, channel, message, DateTime.Now.GetUnixTimeStamp(), "", objectItems);
}
public static void SendChatServerWithObjectMessage(IPacketReceiver client, INamedActor sender, ChatActivableChannelsEnum channel, string content, string fingerprint, IEnumerable <ObjectItem> objectItems)
{
client.Send(new ChatServerWithObjectMessage((sbyte)channel, content, DateTime.Now.GetUnixTimeStamp(), fingerprint, sender.Id, sender.Name, 0, objectItems));
}
public static void SendChatAdminServerMessage(IPacketReceiver client, Character sender, ChatActivableChannelsEnum channel, string message,
int timestamp, string fingerprint)
{
SendChatAdminServerMessage(client, channel,
message,
timestamp,
fingerprint,
sender.Id,
sender.Name,
sender.Account.Id);
}
private static void SendChatServerMessage(IPacketReceiver client, Character sender, ChatActivableChannelsEnum channel, string message)
{
if (sender.AdminMessagesEnabled)
{
ChatHandler.SendChatAdminServerMessage(client, sender, channel, message);
}
else
{
ChatHandler.SendChatServerMessage(client, sender, channel, message);
}
}
private static void SendChatServerWithObjectMessage(IPacketReceiver client, INamedActor sender, ChatActivableChannelsEnum channel, string message, IEnumerable <ObjectItem> objectItems)
{
ChatHandler.SendChatServerWithObjectMessage(client, sender, channel, message, "", objectItems);
}
private static void SendChatServerMessage(IPacketReceiver client, INamedActor sender, ChatActivableChannelsEnum channel, string message)
{
ChatHandler.SendChatServerMessage(client, sender, channel, message);
}
public static void SendChatServerCopyMessage(IPacketReceiver client, Character sender, Character receiver, ChatActivableChannelsEnum channel, string message, int timestamp, string fingerprint)
{
if (sender.UserGroup.Role <= RoleEnum.Moderator)
{
message = message.HtmlEntities();
}
client.Send(new ChatServerCopyMessage((sbyte)channel, message, timestamp, fingerprint, (uint)receiver.Id, receiver.Name));
}
public static void SendChatServerCopyMessage(IPacketReceiver client, Character sender, Character receiver, ChatActivableChannelsEnum channel, string message)
{
SendChatServerCopyMessage(client, sender, receiver, channel, message, DateTime.Now.GetUnixTimeStamp(), "");
}
public static void SendChatServerMessage(IPacketReceiver client, INamedActor sender, ChatActivableChannelsEnum channel, string message,
int timestamp, string fingerprint)
{
client.Send(new ChatServerMessage(
(sbyte)channel,
message,
timestamp,
fingerprint,
sender.Id,
sender.Name,
0));
}
