public static void HandleChatMessage(Bot bot, ChatClientMultiMessage message)
{
if (message.content.StartsWith(".move"))
{
message.BlockNetworkSend();// do not send this message to the server
var splits = message.content.Split(' ');
if (splits.Length != 2)
{
bot.Character.SendMessage("syntax : .move [Right/Left/Top/Bottom/Any]");
return;
}
MapNeighbour neighbour;
try
{
neighbour = (MapNeighbour)Enum.Parse(typeof(MapNeighbour), splits[1]);
}
catch (Exception)
{
bot.Character.SendMessage("syntax : .move [Right/Left/Top/Bottom/Any]");
return;
}
if (bot.Character.ChangeMap(neighbour) == MapNeighbour.None)
{
bot.Character.SendMessage(string.Format("Cannot move to {0} !", neighbour));
}
}
}
private async void Party_PartyNewMember(IAccount account, bool message)
{
((Party)account.Character.Party).PartyNewMemberEvent -= Party_PartyNewMember;
var textMessage = new ChatClientMultiMessage()
{
Content = ".chef",
Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_GLOBAL
};
account.Network.SendToServer(textMessage);
textMessage = new ChatClientMultiMessage()
{
Content = ".pret",
Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_GLOBAL
};
account.Network.SendToServer(textMessage);
ushort[] CloseRangeIdols = { 32, 33, 34, 62, 63, 64 }; //Dynamos & Yoches
foreach (var Idol in CloseRangeIdols)
{
if (!await SendAndWait(account, new IdolSelectRequestMessage(true, true, Idol), 1000))
{
Logger.Default.Log($"Failure while equiping idols.", LogMessageType.Error);
return;
}
}
Logger.Default.Log($"Party Idols equipped with success.", LogMessageType.Party);
}
public void ChatClientMultiMessageFrame(GameClient client, ChatClientMultiMessage chatClientMultiMessage)
{
this._logger.Info($"Char {client.Character.Name} said {chatClientMultiMessage.content} in {chatClientMultiMessage.channel}");
//client.Send(new FriendsListMessage(new int[] { }));
if (chatClientMultiMessage.content.StartsWith("."))
{
// CommandManager.Instance.GetCommandeFromContent(chatClientMultiMessage.content, client);
}
else
{
switch (chatClientMultiMessage.channel) //((ChatChannelsMultiEnum)chatClientMultiMessage.channel)
{
case 0: //ChatChannelsMultiEnum.CHANNEL_GLOBAL:
var map = Container.Instance().Resolve <IMapManager>().GetMapById(client.Character.MapId).Result;
if (map == null)
{
client.Disconnect();
break;
}
foreach (var othersClients in Container.Instance().Resolve <IWorldManager>().GetNearestClientsFromCharacter(client.Character))
{
othersClients.Send(new ChatServerMessage(0, chatClientMultiMessage.content, new int[0], 0, "", client.Character.Id, client.Character.Name, client.Character.AccountId));
}
client.Send(new ChatServerMessage(0, chatClientMultiMessage.content, new int[0], 0, "", client.Character.Id, client.Character.Name, client.Character.AccountId));
break;
}
}
}
public static void HandleChatMessage(Bot bot, ChatClientMultiMessage message)
{
if (message.content == ".gather on")
{
message.BlockNetworkSend();// do not send this message to the server
if (!bot.Character.Jobs.Any(x => x.JobTemplate.id == GatherTest.FARMER_JOB))
{
bot.Character.SendMessage("You haven't the farmer job");
}
else
{
bot.AddFrame(new GatherTest(bot));
bot.Character.SendMessage("Gathering ...");
}
}
else if (message.content == ".gather off")
{
message.BlockNetworkSend();// do not send this message to the server
bot.RemoveFrame <GatherTest>();
bot.Character.SendMessage("Stop gathering ...");
}
}
public static void HandleChatClientMultiMessage(Client client, ChatClientMultiMessage message) //TODO
{
if (!message.content.StartsWith("."))
{
switch (message.channel)
{
case (sbyte)ChatChannelsMultiEnum.CHANNEL_TEAM:
/*if (client.Character.Team != null)
* {
* }*/
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_GUILD:
if (client.Character.Guild != null)
{
SendGuildServerMessage(client, message.channel, message.content, client.Character.Id, client.Character.Name, client.Character.Guild.Id);
}
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_ALIGN:
if (client.Character.AlignmentSide != AlignmentSideEnum.ALIGNMENT_NEUTRAL)
{
}
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_PARTY:
if (client.Character.Party != null)
{
//ForEach clients in party
}
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_SALES:
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_SEEK:
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_NOOB:
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_ADMIN:
if (client.Account.Role == GameHierarchyEnum.ADMIN)
{
}
break;
default:
SendChatServerMessage(client, message.channel, message.content, client.Character.Id, client.Character.Name);
break;
}
}
else
{
CommandEngine.Handle(client, message.content);
}
}
public BotChatMessageClient(ChatClientMultiMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
Content = message.content;
Channel = (ChatActivableChannelsEnum)message.channel;
}
public static void HandleChatClientMultiMessage(GameClient client, ChatClientMultiMessage message)
{
if (!message.content.StartsWith("."))
{
switch (message.channel)
{
case (sbyte)ChatChannelsMultiEnum.CHANNEL_TEAM:
/*if (client.Character.Team != null)
* {
* }*/
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_GUILD:
/*if (client.Character.Guild != null)
* {
* }*/
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_ALIGN:
if (client.Character.AlignmentSide != AlignmentSideEnum.ALIGNMENT_NEUTRAL)
{
SendAlignChatServerMessage(client, message.content, client.Character.Id, client.Character.Name);
}
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_PARTY:
client.Character.Party?.SendPartyChatServerMessage(message.content, client.Character.Id, client.Character.Name);
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_SALES:
SendSalesChatServerMessage(client, message.content, client.Character.Id, client.Character.Name);
break;
case (sbyte)ChatChannelsMultiEnum.CHANNEL_SEEK:
SendSeekChatServerMessage(client, message.content, client.Character.Id, client.Character.Name);
break;
/*case (sbyte)ChatChannelsMultiEnum.CHANNEL_NOOB:
* break;*/
case (sbyte)ChatChannelsMultiEnum.CHANNEL_ADMIN:
if (client.Account.Role > GameHierarchyEnum.PLAYER)
{
SendAdminChatServerMessage(client, message.content, client.Character.Id, client.Character.Name);
}
break;
default:
SendGlobalChatServerMessage(client, message.content, client.Character.Id, client.Character.Name);
break;
}
}
else
{
CommandEngine.Handle(client, message.content);
}
}
public static void HandleChatMessage(Bot bot, ChatClientMultiMessage message)
{
// if the client sends ".hello" in the chat
if (message.content == ".hello")
{
message.BlockNetworkSend();// do not send this message to the server
bot.Character.SendMessage(string.Format("Hello {0} you are on sub area {1}",
bot.Character.Name, bot.Character.Map.SubArea.Name));
}
}
public static void HandleChatMultiClient(ChatClientMultiMessage message, WorldClient client)
{
if (message.content.StartsWith(CommandsHandler.CommandsPrefix))
{
CommandsHandler.Handle(message.content, client);
}
else
{
Handle(client, message.content, (ChatActivableChannelsEnum)message.channel);
}
}
public void HandleChatClientMultiMessage(Bot bot, ChatClientMultiMessage message)
{
if (message.content == ".test")
{
bot.Character.OpenPopup("Yes Man !");
message.BlockNetworkSend();
}
else if (message.content == ".nop")
{
bot.RemoveFrame(this);
message.BlockNetworkSend();
}
}
public static void HandleChatMessage(Bot bot, ChatClientMultiMessage message)
{
if (m_bot == null)
{
m_bot = bot;
CreateTchatCommand("Help", "help", OnHelpCommand);
}
if (message.content[0] == m_charCommand)
{
message.BlockNetworkSend();
}
else
{
return;
}
string[] parts = message.content.Substring(1).Split(' ');
string commandName = parts[0].ToLowerInvariant();
List <string> parameters = new List <string>(parts.Length - 1);
for (int i = 1; i < parts.Length; i++)
{
if (parts[i].StartsWith("\""))
{
string paramInQuote = parts[i].Substring(1);
i++;
while (!parts[i].EndsWith("\""))
{
paramInQuote += " " + parts[i];
i++;
}
paramInQuote += " " + parts[i].Substring(0, parts[i].Length - 1);
parameters.Add(paramInQuote);
}
else
{
parameters.Add(parts[i]);
}
}
if (m_commands.Count(entry => entry.CommandName == commandName) == 1)
{
m_commands.Where(entry => entry.CommandName == commandName).First().Action(parameters.ToArray(), bot);
}
else
{
bot.Character.SendMessage(String.Format("The tchat command <b>{0}</b> doesn't exist.", commandName), System.Drawing.Color.Red);
}
}
public static void HandleChatClientMultiMessage(Bot bot, ChatClientMultiMessage message)
{
if (message.content.StartsWith(".compare pathfinder"))
{
message.BlockNetworkSend();
if (bot.HasFrame <PathfindersComparer>())
{
bot.RemoveFrame <PathfindersComparer>();
}
else
{
bot.AddFrame(new PathfindersComparer(bot));
}
}
}
private void Say(string sentence)
{
using (BigEndianWriter writer = new BigEndianWriter())
{
ChatClientMultiMessage msg = new ChatClientMultiMessage(sentence, (sbyte)0);
msg.Serialize(writer);
writer.Content = account.HumanCheck.hash_function(writer.Content);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack((int)msg.ProtocolID);
account.SocketManager.Send(pack.Writer.Content);
if (account.DebugMode.Checked)
{
account.Log(new DebugTextInformation("[SND] 861 (ChatClientMultiMessage)"), 0);
}
}
}
public void SendMessage(int channel, string content)
{
using (BigEndianWriter writer = new BigEndianWriter())
{
ChatClientMultiMessage msg = new ChatClientMultiMessage(content, (byte)channel);
msg.Serialize(writer);
writer.Content = account.HumanCheck.hash_function(writer.Content);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack((int)msg.MessageID);
account.SocketManager.Send(pack.Writer.Content);
if (account.DebugMode.Checked)
{
account.Log(new DebugTextInformation("[SND] 861 (ChatClientMultiMessage)"), 0);
}
account.FloodUC.Increase(false);
}
}
public static void HandleChatMessage(Bot bot, ChatClientMultiMessage message)
{
if (message.content == ".fight on")
{
message.BlockNetworkSend();// do not send this message to the server
bot.AddFrame(new AutoFight(bot));
bot.Character.SendMessage("Auto fight started");
}
else if (message.content == ".fight off")
{
message.BlockNetworkSend();// do not send this message to the server
bot.RemoveFrame <AutoFight>();
bot.Character.SendMessage("Auto fight stopped");
}
}
public static void HandleChatMessage(Bot bot, ChatClientMultiMessage message)
{
if (message.content.StartsWith(".send"))
{
message.BlockNetworkSend();
var detector = bot.GetFrame <WindowDetector>();
if (detector == null)
{
bot.Character.SendMessage("Frame WindowDetector not found");
return;
}
var splits = message.content.Split(' ');
if (splits.Length != 3)
{
bot.Character.SendMessage("syntax : .send [System.Windows.Forms.Keys] [delay]");
return;
}
Keys key;
try
{
key = (Keys)Enum.Parse(typeof(Keys), splits[1]);
}
catch (Exception)
{
bot.Character.SendMessage("syntax : .send [System.Windows.Forms.Keys] [delay]");
return;
}
int delay;
if (!int.TryParse(splits[2], out delay))
{
bot.Character.SendMessage("syntax : .send [System.Windows.Forms.Keys] [delay]");
return;
}
bot.CallDelayed(delay, () => detector.SendKey(key));
}
}
public void ChatClientMultiMessageFrame(WorldClient client, ChatClientMultiMessage chatClientMultiMessage)
{
if (chatClientMultiMessage.content.StartsWith("."))
{
CommandManager.Instance.GetCommandeFromContent(chatClientMultiMessage.content, client);
}
else
{
switch ((ChatChannelsMultiEnum)chatClientMultiMessage.channel)
{
case ChatChannelsMultiEnum.CHANNEL_GLOBAL:
foreach (var othersClients in WorldManager.Instance.GetNearestClientsFromCharacter(client.ActiveCharacter))
{
othersClients.SendPacket(new ChatServerMessage((uint)ChatChannelsMultiEnum.CHANNEL_GLOBAL, chatClientMultiMessage.content, 0, client.ActiveCharacter.Name, client.ActiveCharacter.Id, client.ActiveCharacter.Name, "", (uint)client.Account.Id));
}
client.SendPacket(new ChatServerMessage((uint)ChatChannelsMultiEnum.CHANNEL_GLOBAL, chatClientMultiMessage.content, 0, client.ActiveCharacter.Name, client.ActiveCharacter.Id, client.ActiveCharacter.Name, "", (uint)client.Account.Id));
break;
case ChatChannelsMultiEnum.CHANNEL_GUILD:
if (client.ActiveCharacter.Guild != null)
{
foreach (var othersClient in WorldManager.Instance.worldClients.FindAll(x => x.ActiveCharacter != null && x.ActiveCharacter.Id != client.ActiveCharacter.Id && x.ActiveCharacter.Guild.Id == client.ActiveCharacter.Guild.Id))
{
othersClient.SendPacket(new ChatServerMessage((uint)ChatChannelsMultiEnum.CHANNEL_GUILD, chatClientMultiMessage.content, 0, client.ActiveCharacter.Name, client.ActiveCharacter.Id, client.ActiveCharacter.Name, "", (uint)client.Account.Id));
}
client.SendPacket(new ChatServerMessage((uint)ChatChannelsMultiEnum.CHANNEL_GUILD, chatClientMultiMessage.content, 0, client.ActiveCharacter.Name, client.ActiveCharacter.Id, client.ActiveCharacter.Name, "", (uint)client.Account.Id));
}
else
{
client.SendPacket(new ChatErrorMessage((uint)ChatErrorEnum.CHAT_ERROR_NO_GUILD));
}
break;
}
}
}
public static void HandleChatClientMultiMessage(WorldClient client, ChatClientMultiMessage message)
{
BsonDocument document = new BsonDocument
{
{
"SenderId",
client.Character.Id
},
{
"Message",
message.content
},
{
"Date",
System.DateTime.Now.ToString(System.Globalization.CultureInfo.InvariantCulture)
}
};
Singleton <MongoLogger> .Instance.Insert("MultiMessage", document);
Singleton <ChatManager> .Instance.HandleChat(client, (ChatActivableChannelsEnum)message.channel, message.content);
}
public static void HandleChatMessage(Bot bot, ChatClientMultiMessage message)
{
if (message.content == ".help")
{
message.BlockNetworkSend();// do not send this message to the server
bot.Character.SendInformation(".dump spells");
bot.Character.SendInformation(".dump all");
bot.Character.SendInformation(".FF ? => Show all plugins running");
bot.Character.SendInformation(".FF on or .FF auto => Starts experimental AI fight in automatic mode");
bot.Character.SendInformation(".FF fol => Put the experimental AI fight in follower mode");
bot.Character.SendInformation(".FF gat => Put the experimental AI fight in gathering mode (not implemented yet)");
bot.Character.SendInformation(".FF off or .FF man => Disable experimental AI fight (manual mode)");
bot.Character.SendInformation(".FF stats => gives some stats");
bot.Character.SendInformation(".FF all => Starts experimental AI fight on all Bots");
bot.Character.SendInformation(".FF /all => Stops experimental AI fight on all Bots");
bot.Character.SendInformation("message <Level> => Filters the messages received from the bot to the Dofus client. <Level> is a bit field (4 bits, so values range from 0 to 7)");
}
else if (message.content == ".dump all")
{
message.BlockNetworkSend();// do not send this message to the server
XmlDumper.DumpAll();
}
else if (message.content == ".dump spells")
{
message.BlockNetworkSend();// do not send this message to the server
XmlDumper.SpellsDumper("_Spells.xml");
}
if (message.content.StartsWith(".FF"))
{
message.BlockNetworkSend();// do not send this message to the server
if (message.content == ".FF ?")
{
int BotNo = 0;
int FrameNo = 0;
foreach (Bot subBot in BotManager.Instance.Bots)
{
BotNo++;
foreach (IFrame frame in subBot.Frames)
{
FrameNo++;
bot.Character.SendInformation("Bot {0} ({3}) Frame {1} : {2}", BotNo, FrameNo, frame.GetType().Name, subBot.Character);
}
}
}
else
if (message.content == ".FF all")
{
bot.Character.SendInformation("Experimental AI fight started for all played characters (set to follower mode for non-leaders of parties)");
foreach (Bot subBot in BotManager.Instance.Bots)
{
if (subBot.AddFrame(new FFight(subBot)))
{
subBot.Character.SendInformation("Experimental AI fight started");
bot.Character.SendInformation("FF started for {0}", bot.Character);
}
else
{
subBot.Character.SendInformation("Can't start FF");
bot.Character.SendInformation("Can't start FF for {0}", bot.Character);
}
}
}
else if (message.content == ".FF /all")
{
bot.Character.SendInformation("Experimental AI fight stopped for all played characters (set to manual mode)");
foreach (Bot subBot in BotManager.Instance.Bots)
{
if (subBot.RemoveFrame <FFight>())
{
subBot.Character.SendInformation("Experimental AI fight stopped");
bot.Character.SendInformation("FF stopped for {0}", bot.Character);
}
else
{
subBot.Character.SendInformation("Failed to stop Experimental AI fight. Probably not running ?");
bot.Character.SendInformation("Can't stop FF for {0}", bot.Character);
}
}
}
else if (message.content.StartsWith(".FF fol", StringComparison.InvariantCultureIgnoreCase))
{
SetFrame(bot, Mode.Follower);
}
else if (message.content.StartsWith(".FF gat", StringComparison.InvariantCultureIgnoreCase))
{
SetFrame(bot, Mode.Ressources);
}
else if (message.content.StartsWith(".FF auto", StringComparison.InvariantCultureIgnoreCase) || message.content.StartsWith(".FF on", StringComparison.InvariantCultureIgnoreCase))
{
SetFrame(bot, Mode.AutomaticFight);
}
else if (message.content.StartsWith(".FF man", StringComparison.InvariantCultureIgnoreCase) || message.content.StartsWith(".FF off", StringComparison.InvariantCultureIgnoreCase))
{
SetFrame(bot, Mode.Manual);
}
else if (message.content == ".FF stats")
{
if (!bot.HasFrame <FFight>())
{
bot.Character.SendInformation("Experimental AI fight is NOT running");
}
else
{
FFight fightBot = bot.GetFrame <FFight>();
bot.Character.SendInformation("Experimental AI fight IS running in mode {0}", fightBot.Mode);
fightBot.Dump();
}
}
}
PlayedCharacter PC = bot.Character;
if (message.content == "?")
{
message.BlockNetworkSend();// do not send this message to the server
PC.SendInformation(String.Format("Position : NF{0} - F{1}", PC.Cell, PC.Fighter != null ? PC.Fighter.Cell.ToString() : "N/A"));
/*PC.ResetCellsHighlight();
* if (PC.Fighter != null)
* {
* PC.HighlightCells(PC.Fight.BlueTeam.FightersAlive.Select(fighter => fighter.Cell), Color.Blue);
* PC.HighlightCells(PC.Fight.RedTeam.FightersAlive.Select(fighter => fighter.Cell), Color.Red);
* PC.HighlightCell(PC.Fighter.Cell, Color.Pink);
* }
* else
* PC.HighlightCell(PC.Cell, Color.Pink);*/
}
if (message.content.StartsWith("message"))
{
message.BlockNetworkSend();// do not send this message to the server
string sdbgLevel = message.content.Replace("message", "").Trim();
PlayedCharacter.MessageLevel dbgLevel = PC.InformationLevel;
if (PlayedCharacter.MessageLevel.TryParse(sdbgLevel, out dbgLevel))
{
PC.SendMessage(String.Format("MessageLevel was {0}, it is now {1}", PC.InformationLevel, dbgLevel));
PC.InformationLevel = dbgLevel;
}
else
{
PC.SendMessage(String.Format("MessageLevel is {0}", PC.InformationLevel));
}
}
}
public static void OnClientMultiMessage(INetworkClient client, ChatClientMultiMessage message)
{
client.GetEntity().Notify(new ClientChatMessageEventArgs((ChatChannelType)message.Channel, message.Content));
}
public static void HandleChatMessage(Bot bot, ChatClientMultiMessage message)
{
if (message.content.StartsWith(".algo submap"))
{
bot.Character.ResetCellsHighlight();
var sw = Stopwatch.StartNew();
var submaps = SubMapsManager.Instance.GetMapSubMapsBinder(bot.Character.Map.Id);
sw.Stop();
bot.Character.SendMessage(string.Format("{0}ms", sw.ElapsedMilliseconds));
foreach (var subMap in submaps)
{
var random = new Random();
int hue = random.Next(0, 361);
bot.Character.SendMessage(string.Format("[{0} mapid:{1} submap:{2}]", subMap.GlobalId, subMap.MapId, subMap.SubMapId));
double step = 1d / subMap.Neighbours.Count;
for (int i = 0; i < subMap.Neighbours.Count; i++)
{
var neighbour = subMap.Neighbours[i];
var color = HSVColorConverter.ColorFromHSV(hue, step * (i + 1), 1);
bot.Character.SendMessage(string.Format("[{0}] to [{1}] ({2})",
subMap.GlobalId, neighbour.GlobalId,
neighbour.Transition is MovementTransition ? (neighbour.Transition as MovementTransition).MapNeighbour : MapNeighbour.None));
if (neighbour.Transition is MovementTransition)
{
bot.Character.HighlightCells((neighbour.Transition as MovementTransition).Cells, color);
}
}
}
message.BlockNetworkSend();
}
if (message.content.StartsWith(".algo los"))
{
var canBeSee = new List <Cell>();
var cannotBeSee = new List <Cell>();
Cell currentCell;
if (bot.Character.IsFighting())
{
currentCell = bot.Character.Fighter.Cell;
}
else
{
currentCell = bot.Character.Cell;
}
foreach (var cell in bot.Character.Map.Cells.Where(x => x.Walkable))
{
if (bot.Character.Context.CanBeSeen(currentCell, cell, !bot.Character.IsFighting()))
{
canBeSee.Add(cell);
}
else
{
cannotBeSee.Add(cell);
}
}
bot.Character.ResetCellsHighlight();
bot.Character.HighlightCells(canBeSee, Color.Green);
bot.Character.HighlightCells(cannotBeSee, Color.Red);
message.BlockNetworkSend();
}
}
public void SendMessage(string message, ChannelTchatEnum channel = ChannelTchatEnum.CHANNEL_GLOBAL)
{
ChatClientMultiMessage CCMM = new ChatClientMultiMessage(message, (sbyte)channel);
bot.Network.Send(CCMM);
}
private void HandleSendChatMessage()
{
if (_account.Character.Status == CharacterStatus.Disconnected)
{
return;
}
if (string.IsNullOrWhiteSpace(ChatTextBox.Text))
{
Logger.Default.Log("Vous ne pouvez pas envoyer un texte vide.", LogMessageType.Public);
}
else
{
_chatHistory.Add(ChatTextBox.Text);
Logger.Default.Log(ChatTextBox.Text, LogMessageType.Command);
if (ChatTextBox.Text.Length > 2 && ChatTextBox.Text[0] == '.')
{
var txt = ChatTextBox.Text.Substring(1);
try
{
CommandManager.ParseAndCall(_account, txt);
}
catch (Exception e)
{
Logger.Default.Log(e.Message);
Logger.Default.Log("Commande Incorrecte ou qui a échouée.", LogMessageType.Public);
}
ChatTextBox.BeginInvoke(new Action(() => ChatTextBox.Text = ""));
return;
}
if (ChatTextBox.Text.Length < 2)
{
var ccmm = new ChatClientMultiMessage
{
Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_GLOBAL,
Content = ChatTextBox.Text
};
_account.Network.SendToServer(ccmm);
}
else
{
var txt = ChatTextBox.Text.Substring(0, 2);
var chattxt = ChatTextBox.Text.Replace(txt, "");
if (txt == "/w")
{
string[] receiver = chattxt.Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
var messagePacket = new ChatClientPrivateMessage(receiver[0])
{
Content = receiver[1]
};
_account.Network.SendToServer(messagePacket);
}
else
{
var ccmm = new ChatClientMultiMessage
{
Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_GLOBAL,
Content = chattxt
};
switch (txt)
{
case "/g":
if (string.IsNullOrWhiteSpace(chattxt))
{
ccmm.Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_GUILD;
}
break;
case "/s":
if (string.IsNullOrWhiteSpace(chattxt))
{
ccmm.Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_GLOBAL;
}
break;
case "/t":
if (string.IsNullOrWhiteSpace(chattxt))
{
ccmm.Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_TEAM;
}
break;
case "/a":
if (string.IsNullOrWhiteSpace(chattxt))
{
ccmm.Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_ALLIANCE;
}
break;
case "/p":
if (string.IsNullOrWhiteSpace(chattxt))
{
ccmm.Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_PARTY;
}
break;
case "/k":
if (string.IsNullOrWhiteSpace(chattxt))
{
ccmm.Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_ARENA;
}
break;
case "/b":
if (string.IsNullOrWhiteSpace(chattxt))
{
ccmm.Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_SALES;
}
break;
case "/r":
if (string.IsNullOrWhiteSpace(chattxt))
{
ccmm.Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_SEEK;
}
break;
default:
ccmm.Channel = (sbyte)ChatChannelsMultiEnum.CHANNEL_GLOBAL;
ccmm.Content = txt + chattxt;
break;
}
_account.Network.SendToServer(ccmm);
ChatTextBox.BeginInvoke(new Action(() => ChatTextBox.Text = ""));
}
}
}
}
public static void HandleChatClientMultiMessage(Bot bot, ChatClientMultiMessage message)
{
bot.SendLocal(new BotChatMessageClient(message));
}
public static void HandleChatMultiClient(ChatClientMultiMessage message, WorldClient client)
{
Handle(client, message.content, (ChatActivableChannelsEnum)message.channel);
}
public static void HandleChatClientMultiMessage(WorldClient client, ChatClientMultiMessage message)
{
ChatManager.Instance.HandleChat(client, (ChatActivableChannelsEnum)message.channel, message.content);
}
private void ChatClientMultiMessageHandler(DofusClient client, ChatClientMultiMessage message)
{
//
}
