public static MessagePacket Create(Enums.ChatType chattype, System.Drawing.Color color, string sender, string to, string message)
{
StringPacker msg = new StringPacker(sender, to, "", message);
MessagePacket msgpacket = new MessagePacket(msg);
msgpacket.Color = color;
msgpacket.ChatType = chattype;
return(msgpacket);
}
public Chat(Entities.User u, Enums.ChatType type, string message, int targetId, string targetName)
: base((ushort)Enums.Packets.Chat)
{
Append(Core.Constants.Error_OK);
Append(u.SessionID);
Append(u.Displayname);
Append((byte)type);
Append(targetId);
Append(targetName);
Append(message);
}
public Chat(string name, Enums.ChatType type, string message, int targetId, string targetName)
: base((ushort)Enums.Packets.Chat)
{
Append(Core.Constants.Error_OK);
Append(0);
Append(name);
Append((byte)type);
Append(targetId);
Append(targetName);
Append(message);
}
public static byte[] MessagePacket(string Message, string From, string To, Enums.ChatType ChatType)
{
int Length = 32 + From.Length + To.Length + Message.Length + 1;
Writer PWR = new Writer(Length);
PWR.Fill((ushort)Length, 0);
PWR.Fill((ushort)1004, 2);
PWR.Fill((uint)0, 4);
PWR.Fill((uint)ChatType, 8);
PWR.Fill((byte)4, 24);
PWR.Fill((byte)From.Length, 25);
PWR.Fill(From, 26);
PWR.Fill((byte)To.Length, 26 + From.Length);
PWR.Fill(To, 27 + From.Length);
PWR.Fill((byte)Message.Length, 28 + From.Length + To.Length);
PWR.Fill(Message, 29 + From.Length + To.Length);
return(PWR.Bytes);
}
public ActionMessage CreatePrivate(string roomName, Enums.ChatType result, string userId)
{
var response = new ActionMessage();
var chat = new Chat()
{
ChatType = result,
Name = roomName,
};
chatRepository.Add(chat);
var chatroomId = chatRepository.GetByName(roomName).Id;
CreateChatUser(userId, chatroomId);
return(response);
}
public static MessagePacket Create(Enums.ChatType chattype, string sender, string to, string message)
{
return(Create(chattype, System.Drawing.Color.Yellow, sender, to, message));
}
protected override void Process(Entities.User u)
{
if (u.Authorized)
{
byte type = GetByte(0);
if (System.Enum.IsDefined(typeof(ChatType), type))
{
Enums.ChatType chatType = (ChatType)type;
uint nowTimeStamp = (uint)DateTime.Now.ToUniversalTime().Subtract(new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds;
string message = GetString(3);
string realMessage = message.Split(new string[] { ">>" + Convert.ToChar(0x1D).ToString() }, StringSplitOptions.None)[1].Replace(Convert.ToChar(0x1D), Convert.ToChar(0x20));
if (IsCommand(realMessage))
{
//removes /cris header
realMessage = realMessage.Remove(0, 6);
//get the command and the Arguments
string[] FullCommand = realMessage.Split(' ');
//TODO: PARSE FOR TARGET
Objects.Command Command = Managers.CommandManager.Instance.GetCommand(FullCommand[0]);
if (Command != null)
{
//get the arguments...
string[] Arguments = new string[FullCommand.Length - 1];
Array.Copy(FullCommand, 1, Arguments, 0, (FullCommand.Length - 1));
if (Arguments.Length < 32)
{
Command.SetArguments(Arguments);
Command.Process(u);
}
}
else
{
// string _notFound = Cristina.Core.Cristina.Localization.GetLocMessageFrom("UNKNOWN_COMMAND");
Cristina.Core.Cristina.Chat.SayToPlayer("El comando no existe", u);
}
}
else
{
string targetName = GetString(2);
int targetId = GetInt(1);
if (realMessage.Length <= 60)
{
realMessage = realMessage.Trim();
switch (chatType)
{
case ChatType.Lobby_ToChannel:
{
if (u.Room == null)
{
Databases.Game.AsyncInsert("chat_public_lobby", new System.Collections.Generic.Dictionary <string, object>()
{
{ "server", Config.SERVER_ID }, { "channel_id", (byte)u.Channel }, { "sender_id", u.ID }, { "target_all", 0 }, { "message", realMessage }, { "timestamp", nowTimeStamp }
});
Core.Networking.OutPacket p = new Packets.Chat(u, Enums.ChatType.Lobby_ToChannel, message, targetId, targetName);
Managers.ChannelManager.Instance.SendLobby(u.Channel, p.BuildEncrypted());
}
else
{
u.Disconnect(); // Sending lobby messages when in a room?
}
break;
}
case ChatType.Lobby_ToAll:
{
if (u.Room == null)
{
Databases.Game.AsyncInsert("chat_public_lobby", new System.Collections.Generic.Dictionary <string, object>()
{
{ "server", Config.SERVER_ID }, { "channel_id", (byte)u.Channel }, { "sender_id", u.ID }, { "target_all", 1 }, { "message", realMessage }, { "timestamp", nowTimeStamp }
});
Core.Networking.OutPacket p = new Packets.Chat(u, chatType, message, targetId, targetName);
Managers.ChannelManager.Instance.SendAllLobbies(p.BuildEncrypted());
}
else
{
u.Disconnect(); // Sending lobby messages when in a room?
}
break;
}
case ChatType.Room_ToAll:
{
if (u.Room != null)
{
if (u.Room.State == RoomState.Waiting && u.RoomSlot == u.Room.Master)
{
if (u.Room.Supermaster)
{
targetId = 998;
}
}
Databases.Game.AsyncInsert("chat_public_room", new System.Collections.Generic.Dictionary <string, object>()
{
{ "server", Config.SERVER_ID }, { "channel_id", (byte)u.Channel }, { "sender_id", u.ID }, { "room_id", u.Room.ID }, { "team_side", (byte)u.Room.Players[u.RoomSlot].Team }, { "target_all", 1 }, { "message", realMessage }, { "timestamp", nowTimeStamp }
});
Core.Networking.OutPacket p = new Packets.Chat(u, chatType, message, targetId, targetName);
u.Room.Send(p.BuildEncrypted());
}
else
{
u.Disconnect();
}
break;
}
case ChatType.Room_ToTeam:
{
if (u.Room != null)
{
if (u.Room.Mode != Mode.Free_For_All && u.Room.State == RoomState.Playing)
{
Databases.Game.AsyncInsert("chat_public_room", new System.Collections.Generic.Dictionary <string, object>()
{
{ "server", Config.SERVER_ID }, { "channel_id", (byte)u.Channel }, { "sender_id", u.ID }, { "room_id", u.Room.ID }, { "team_side", (byte)u.Room.Players[u.RoomSlot].Team }, { "target_all", 0 }, { "message", realMessage }, { "timestamp", nowTimeStamp }
});
Core.Networking.OutPacket p = new Packets.Chat(u, chatType, message, targetId, targetName);
byte[] buffer = p.BuildEncrypted();
u.Room.Players.Values.Where(n => n.Team == u.Room.Players[u.RoomSlot].Team).ToList().ForEach(n => n.Send(buffer));
}
else
{
u.Disconnect(); // NO team CHAT IN FFA or in the lobby.
}
}
break;
}
case ChatType.Clan:
{
if (u.ClanId != -1)
{
Databases.Game.AsyncInsert("chat_private_clan", new System.Collections.Generic.Dictionary <string, object>()
{
{ "server", Config.SERVER_ID }, { "clan_id", (byte)u.ClanId }, { "sender_id", u.ID }, { "message", realMessage }, { "timestamp", nowTimeStamp }
});
Core.Networking.OutPacket p = new Packets.Chat(u, chatType, message, targetId, targetName);
foreach (Entities.User User in Managers.UserManager.Instance.Sessions.Values)
{
User.Send(p.BuildEncrypted());
}
}
break;
}
case ChatType.Whisper:
{
Entities.User Target = Managers.UserManager.Instance.GetUser(targetName);
//fixes the lack of space between nick and "message sent" or "doesn´t exist" error code
targetName = targetName + Convert.ToChar(0x1D);
if (Target != null)
{
u.Send(new Packets.Chat(u, chatType, message, targetId, targetName)); //in this case targetId equals -1, that is "message sent"
Target.Send(new Packets.Chat(u, chatType, message, (int)Target.SessionID, Target.Displayname).BuildEncrypted());
}
else
{
u.Send(new Packets.Chat(95040, targetName).BuildEncrypted());
}
break;
}
default:
{
break;
}
}
}
else
{
u.Disconnect(); // Message is to long?
}
}
}
}
else
{
u.Disconnect();
}
}
public void Handle(byte[] Data, SocketClient Client)
{
Enums.ChatType ChatType = (Enums.ChatType)BitConverter.ToUInt32(Data, 8);
string From = Encoding.ASCII.GetString(Data, 26, Data[25]);
if (From != Client.Character.Name)
{
return;
}
string To = Encoding.ASCII.GetString(Data, 27 + From.Length, Data[26 + From.Length]);
string Message = Encoding.ASCII.GetString(Data, 29 + From.Length + To.Length, Data[28 + From.Length + To.Length]);
if (Message.StartsWith(Constants.CommandOperator))
{
Message = Message.Replace(Constants.CommandOperator, "");
string[] msgData = Message.Split(' ');
switch (msgData[0])
{
case "life": Client.Character.HitPoints = Client.Character.MaxHitPoints; break;
case "dc": Client.Disconnect(); break;
case "money":
case "silver":
{
if (msgData.Length < 2)
{
return;
}
uint Silver;
if (!uint.TryParse(msgData[1], out Silver))
{
return;
}
Client.Character.Silver = Silver;
break;
}
case "learnspell":
{
if (msgData.Length < 3)
{
return;
}
ushort SkillID;
if (!ushort.TryParse(msgData[1], out SkillID))
{
return;
}
byte Level;
if (!byte.TryParse(msgData[2], out Level))
{
return;
}
Client.Character.LearnSkill(SkillID, Level, 0);
break;
}
case "forgetspell":
{
if (msgData.Length < 2)
{
return;
}
ushort SkillID;
if (!ushort.TryParse(msgData[1], out SkillID))
{
return;
}
Client.Character.ForgetSkill(SkillID);
break;
}
case "item":
{
if (msgData.Length > 2)
{
uint ItemID;
if (!uint.TryParse(msgData[1], out ItemID))
{
if (msgData.Length == 8)
{
Enums.ItemQuality quality;
switch (msgData[2].ToLower())
{
case "super": quality = Enums.ItemQuality.Super; break;
case "elite": quality = Enums.ItemQuality.Elite; break;
case "unique": quality = Enums.ItemQuality.Unique; break;
case "refined": quality = Enums.ItemQuality.Refined; break;
case "normal": quality = Enums.ItemQuality.Normal; break;
default: return;
}
byte Plus;
if (!byte.TryParse(msgData[3], out Plus))
{
return;
}
byte Bless;
if (!byte.TryParse(msgData[4], out Bless))
{
return;
}
byte Enchant;
if (!byte.TryParse(msgData[5], out Enchant))
{
return;
}
byte Gem1;
if (!byte.TryParse(msgData[6], out Gem1))
{
return;
}
byte Gem2;
if (!byte.TryParse(msgData[7], out Gem2))
{
return;
}
foreach (Items.ItemType ItemInfo in Kernel.ItemTypes.Values)
{
if (ItemInfo.Name == msgData[1])
{
Items.Item Itm = new Items.Item(ItemInfo);
Itm.OwnerUID = Client.UniqueID;
Itm.Bless = Bless;
Itm.Enchant = Enchant;
Itm.QualityChange(quality);
Itm.Durability = ItemInfo.MaxDurability;
Itm.Mode = 1;
Itm.Plus = Plus;
if (ItemInfo.ID >= 730001 && ItemInfo.ID <= 730009)
{
Itm.Plus = (byte)(ItemInfo.ID - 730000);
}
Itm.Position = (byte)Enums.ItemPosition.Inventory;
Itm.Loaded = true;
Itm.Save();
Client.Character.Inventory.TryAdd(Itm);
return;
}
}
}
}
}
break;
}
default: break;
}
}
else
{
uint Color = BitConverter.ToUInt32(Data, 4);
switch (ChatType)
{
case Enums.ChatType.Talk:
{
Client.Character.Screen.Send(Packets.ToSend.MessagePacket(Message, From, To, Client.Character.Dead ? Enums.ChatType.Ghost : Enums.ChatType.Talk), false);
break;
}
default: break;
}
}
}
internal Message(String parOwner, String parText, Enums.ChatType parType)
{
Owner = parOwner;
Text = parText;
Type = parType;
}
