public static void sendPartyMessage(WorldClient client, Packet packet)
{
string mess;
byte len;
if (!packet.TryReadByte(out len) || !packet.TryReadString(out mess, len))
{
Log.WriteLine(LogLevel.Error, "PartyChat :: Can not parse party chat from {0}", client.Character.Character.Name);
return;
}
if(Program.Entity.Parties.Where(c => c.CharNo == client.Character.Character.ID).Count() == 1)
{
Party getPartyInfo = Program.Entity.Parties.First(c => c.CharNo == client.Character.Character.ID);
foreach (Party party in Program.Entity.Parties.Where(c => c.PartyNo == getPartyInfo.PartyNo))
{
Character character = Program.Entity.Characters.First(c => c.ID == party.CharNo);
WorldClient wclient = ClientManager.Instance.GetClientByCharname(character.Name);
using (var ppacket = new Packet(SH8Type.PartyChat))
{
ppacket.WriteString(client.Character.Character.Name, 16);
ppacket.WriteByte(len);
ppacket.WriteString(mess, len);
wclient.SendPacket(ppacket);
}
}
}
else
{
using (var ppacket = new Packet(SH8Type.PartyChatErr))
{
ppacket.WriteUShort(1985);
client.SendPacket(ppacket);
}
}
}
public static void WriteBasicCharInfo(WorldCharacter wchar, Packet packet)
{
packet.WriteInt(wchar.Character.ID);
packet.WriteString(wchar.Character.Name, 16);
packet.WriteUShort(wchar.Character.CharLevel);
packet.WriteByte(wchar.Character.Slot);
MapInfo mapinfo;
if (!DataProvider.Instance.Maps.TryGetValue(wchar.Character.Map, out mapinfo))
{
Log.WriteLine(LogLevel.Warn, "{0} has an invalid MapID ({1})", wchar.Character.Name, wchar.Character.Map);
wchar.Character.Map = 0;//we reset
packet.WriteString("Rou", 12);
}
else
{
packet.WriteString(mapinfo.ShortName, 12);
}
packet.WriteByte(0); // UNK
packet.WriteInt(0x00000000); // Random seed
WriteLook(wchar, packet);
WriteEquipment(wchar, packet);
WriteRefinement(wchar, packet);
packet.Fill(4, 0xff); // UNK
packet.WriteString("Rou", 12); //TODO: load from mapinfo.shn
packet.WriteInt(0); // X, doesn't matter
packet.WriteInt(0); // Y, neither
packet.WriteInt(0x63dd45ca);
packet.WriteByte(0);
packet.WriteInt(100); // Test later!
packet.WriteByte(0);
wchar.Detach();
}
public void SendMasterRequest()
{
using (var packet = new Packet(SH37Type.SendMasterRequest))
{
packet.WriteString(pRequest.InviterClient.Character.Character.Name, 16);
packet.WriteString(pRequest.InvitedClient.Character.Character.Name, 16);
this.pRequest.InvitedClient.SendPacket(packet);
}
}
public static void ChangeFromGuildAcademyToResponse(WorldClient client, Packet packet)
{
string GuildName;
string RequestName;
bool answer;
if (!packet.TryReadString(out GuildName, 16) || !packet.TryReadString(out RequestName, 16)|| (!packet.TryReadBool(out answer) || !client.Character.IsInGuildAcademy))
return;
if (answer)
{
GuildAcademyMember pMember = client.Character.GuildAcademy.Members.Find(m => m.Character.Character.Name == RequestName);
if (pMember == null)
return;
pMember.Character.IsInGuildAcademy = false;
pMember.Academy.RemoveMember(pMember);
pMember.Character.GuildAcademy.Guild.AddMember(pMember.Character, GuildRank.Member, Program.DatabaseManager.GetClient().GetConnection(), true, true);
pMember.Character.Guild = pMember.Character.GuildAcademy.Guild;
pMember.Character.IsInGuild = true;
using (var pack = new Packet(SH38Type.SendJoinGuildFromAcademy))
{
//this packet remove character from academy List and added to GuildList
pack.WriteString(RequestName, 16);
pack.WriteString(client.Character.Character.Name, 16);
pack.WriteByte(6);//rank
pack.WriteInt(0);//unk
pack.WriteUShort(0);//korp
pack.Fill(64, 0x00);//unk
pack.WriteByte(true ? (byte)0x95 : (byte)0x00);// (this.isOnline ? (byte)0x95 : (byte)0x00);
pack.Fill(3, 0x00);//unk
pack.WriteByte(pMember.Character.Character.Job);
pack.WriteByte(pMember.Character.Character.CharLevel);
pack.Fill(13, 0x00);//unk
client.Character.GuildAcademy.Guild.Broadcast(pack);
client.Character.GuildAcademy.Broadcast(pack);
}
}
using (var p2 = new Packet(SH4Type.CharacterGuildinfo))
{
client.Character.Guild.WriteGuildInfo(packet);
client.SendPacket(p2);
}
using (var pack = new Packet(SH29Type.GuildMemberJoined))
{
pack.WriteString(client.Character.Character.Name, 16);
client.Character.GuildAcademy.Guild.Broadcast(pack);
client.Character.GuildAcademy.Broadcast(pack);
}
using (var pack = new Packet(SH29Type.ChangeResponse))
{
pack.WriteUShort(3137);//unk
pack.WriteByte(3);
pack.Fill(2, 0x00);//unk
client.SendPacket(pack);
}
}
public static void FriendInvite(WorldClient pClient, Packet pPacket)
{
string sender, receiver;
if (!pPacket.TryReadString(out sender, 16) ||
!pPacket.TryReadString(out receiver, 16))
{
Log.WriteLine(LogLevel.Warn, "Error reading friend invite.");
return;
}
WorldCharacter inviter = pClient.Character;
WorldClient invitee = ClientManager.Instance.GetClientByCharname(receiver);
if (invitee == null)
{
//character not found
using (var pack = new Packet(SH21Type.FriendInviteResponse))
{
pack.WriteString(sender, 16);
pack.WriteString(receiver, 16);
pack.WriteUShort(0x0946); // Cannot find ${Target}
pClient.SendPacket(pack);
}
}
else if (receiver == sender)
{
using (var pack = new Packet(SH21Type.FriendInviteResponse))
{
pack.WriteString(sender, 16);
pack.WriteString(receiver, 16);
pack.WriteUShort(0x0942); // You cannot add yourself to your Buddy List.
pClient.SendPacket(pack);
}
}
else if (inviter.Friends.Find(f => f.Name == receiver) != null)
{
using (var pack = new Packet(SH21Type.FriendInviteResponse))
{
pack.WriteString(sender, 16);
pack.WriteString(receiver, 16);
pack.WriteUShort(0x0945); // {Target} is already registered in the friends list.
pClient.SendPacket(pack);
}
}
else
{
using (var pack = new Packet(SH21Type.FriendInviteRequest))
{
pack.WriteString(receiver, 16);
pack.WriteString(sender, 16);
invitee.SendPacket(pack);
}
}
}
public static void SendGameMessage(ZoneCharacter character, string Message, string script)
{
using (var packet = new Packet(SH27Type.GameMessage))
{
packet.WriteString(script, 31);
packet.WriteByte(24);
packet.WriteInt(Message.Length);
packet.WriteByte(0);
packet.WriteString(Message, Message.Length);
character.Client.SendPacket(packet);
}
}
public static void Wisper(WorldClient client, Packet packet)
{
string toname;
byte messagelenght;
if (packet.TryReadString(out toname, 16) && packet.TryReadByte(out messagelenght))
{
string message;
if (!packet.TryReadString(out message, messagelenght))
{
return;
}
WorldClient toChar = ClientManager.Instance.GetClientByCharname(toname);
if (toChar != null)
{
using (var frompacket = new Packet(SH8Type.WisperFrom))
{
frompacket.WriteString(client.Character.Character.Name, 16);
if (!toChar.Character.BlocketUser.Contains(client.Character.Character.Name))
{
frompacket.WriteByte(0);
}
else
{
frompacket.WriteByte(12);//blocket notdisplay message
}
frompacket.WriteByte(messagelenght);
frompacket.WriteString(message, messagelenght);
toChar.SendPacket(frompacket);
}
using (var pack = new Packet(SH8Type.WisperTo))
{
pack.WriteString(toname, 16);
pack.WriteByte(messagelenght);
pack.WriteString(message, messagelenght);
client.SendPacket(pack);
}
}
else
{
//target not found
using (var pp = new Packet(SH8Type.WisperTargetNotfound))
{
pp.WriteUShort(3945);//unk
pp.WriteString(toname, 16);
client.SendPacket(pp);
}
}
}
}
public static void LeaveParty(WorldClient client, Packet packet)
{
Party party;
party = Program.Entity.Parties.First(c => c.CharNo == client.Character.Character.ID);
foreach (Party PartyListFromDB in Program.Entity.Parties.Where(c => c.PartyNo == party.PartyNo).OrderBy(c => c.MasterNo))
{
Character character;
character = Program.Entity.Characters.First(c => c.ID == PartyListFromDB.CharNo);
WorldClient Partyclient = ClientManager.Instance.GetClientByCharname(character.Name);
using (var ppacket = new Packet(SH14Type.LeaveParty))
{
ppacket.WriteString(client.Character.Character.Name, 16);
ppacket.WriteUShort(1281);
Partyclient.SendPacket(ppacket);
}
}
if(Program.Entity.Parties.Where(c => c.PartyNo == party.PartyNo).Count() == 2){
Party OtherClientParty;
OtherClientParty = Program.Entity.Parties.First(c => c.CharNo != client.Character.Character.ID);
Program.Entity.DeleteObject(OtherClientParty);
}
Program.Entity.DeleteObject(party);
Program.Entity.SaveChanges();
}
public void BroadcastGuildName()
{
var packet = new Packet(SH29Type.GuildNameResult);
packet.WriteInt(Guild.ID);
packet.WriteString(Guild.Name, 16);
BroadcastManager.Instance.BroadcastInRange(Character, packet, false);
}
public void BroadcastGuildName()
{
var packet = new Packet(SH29Type.GuildNameResult);
packet.WriteInt(Academy.Guild.ID);
packet.WriteString(Academy.Guild.Name, 16);
Character.BroucastPacket(packet);
}
public static void SendGuildNameResult(WorldClient client, int pID, string pName)
{
using (var packet = new Packet(SH29Type.GuildNameResult))
{
packet.WriteInt(pID);
packet.WriteString(pName, 16);
client.SendPacket(packet);
}
}
public static void SendQuestion(ZoneCharacter character, Question question, ushort range)
{
using (var packet = new Packet(SH15Type.Question))
{
packet.WriteString(question.Text, 129);
packet.WriteUShort(character.MapObjectID); // Obj id
packet.WriteInt(character.Position.X);
packet.WriteInt(character.Position.Y);
packet.WriteUShort(range); // Distance how far your allowed to run when the question window is closed by Client
packet.WriteByte((byte)question.Answers.Count);
for (byte i = 0; i < question.Answers.Count; ++i)
{
packet.WriteByte(i);
packet.WriteString(question.Answers[i], 32);
}
character.Client.SendPacket(packet);
}
}
public static void SendAcademyResponse(WorldClient pClient,string GuildName, GuildAcademyResponse Response)
{
using (var packet = new Packet(SH38Type.AcademyResponse))
{
packet.WriteString(GuildName, 16);
packet.WriteUShort((ushort)Response);
pClient.SendPacket(packet);
}
}
public static void SendBackToWorldSelect(WorldClient client)
{
using(Packet packet = new Packet(SH3Type.BackToWorldSelect))
{
packet.WriteUShort(7768);
packet.WriteString(client.AccountKey);
client.SendPacket(packet);
}
}
public static void SendZoneServerIP(WorldClient client, ZoneConnection info)
{
using (var packet = new Packet(SH4Type.ServerIP))
{
packet.WriteString(info.IP, 16);
packet.WriteUShort(info.Port);
client.SendPacket(packet);
}
}
public static void getWhisperMessage(WorldClient client, Packet packet)
{
string toChar;
byte len;
string mess;
if (!packet.TryReadString(out toChar, 16) || !packet.TryReadByte(out len) || !packet.TryReadString(out mess, len))
{
Log.WriteLine(LogLevel.Error, "WhisperChat :: Can not parse Whisper request from {0}", client.Character.Character.Name);
return;
}
WorldClient wclient = ClientManager.Instance.GetClientByCharname(toChar);
if (wclient != null)
{
using (var ppacket = new Packet(SH8Type.WhisperTo))
{
ppacket.WriteString(toChar, 16);
ppacket.WriteByte(len);
ppacket.WriteString(mess, len);
client.SendPacket(ppacket);
}
using (var ppacket = new Packet(SH8Type.WhisperFrom))
{
ppacket.WriteString(client.Character.Character.Name, 16);
ppacket.WriteByte(0); // unk
ppacket.WriteByte(len);
ppacket.WriteString(mess, len);
wclient.SendPacket(ppacket);
}
}
else
{
using (var ppacket = new Packet(SH8Type.WhisperErrAnswer))
{
ppacket.WriteUShort(3945);
ppacket.WriteString(toChar, 16);
client.SendPacket(ppacket);
}
}
}
public static void SendChangeZone(ZoneCharacter character, ushort mapid, int x, int y, string ip, ushort port, ushort randomid)
{
using (var packet = new Packet(SH6Type.ChangeZone))
{
packet.WriteUShort(mapid);
packet.WriteInt(x);
packet.WriteInt(y);
packet.WriteString(Settings.Instance.IP, 16);
packet.WriteUShort(port);
packet.WriteUShort(randomid);
character.Client.SendPacket(packet);
}
}
public static void SendChangeZone(ZoneCharacter character, ushort mapid, int x, int y, string IP, ushort port, ushort randomid)
{
using (var packet = new Packet(SH6Type.ChangeZone))
{
packet.WriteUShort(mapid);
packet.WriteInt(x);
packet.WriteInt(y);
packet.WriteString(character.Client.Host == "127.0.0.1" ? "127.0.0.1" : IP, 16);
packet.WriteUShort(port);
packet.WriteUShort(randomid);
character.Client.SendPacket(packet);
}
}
public void SendRemoveFromGuildStore(GuildStoreAddFlags Flags, string Charname, long Value, long NewGuildMoney = 0, ushort ItemID = 0xFFFF)
{
using (var packet = new Packet(SH38Type.RemoveFromGuildStore))
{
packet.WriteByte(0);//unk
packet.WriteByte((byte)Flags);
packet.WriteString(Charname, 16);
packet.WriteUShort(ItemID);
packet.WriteByte(0);
packet.WriteLong(Value);
packet.WriteLong(NewGuildMoney);//new GuildMoney
Guild.Broadcast(packet);
}
}
public static void ChangeCharNameHandler(WorldClient client, Packet packet)
{
byte Character_slot;
string charname;
if (!packet.TryReadByte(out Character_slot) || !packet.TryReadString(out charname, 16))
return;
using (var pack = new Packet(SH5Type.SendCharacterChangeNewName))
{
pack.WriteByte(Character_slot);
pack.WriteString(charname,16);
pack.WriteUShort(208);//Responsecode?
}
//Todo ChangeinDatabase
}
public static void SendPartyInformation(ZoneClient client)
{
if (Program.Entity.Parties.Where(c => c.CharNo == client.Character.ID).Count() == 1)
{
Party PartyNo = Program.Entity.Parties.First(c => c.CharNo == client.Character.ID);
foreach (Party party in Program.Entity.Parties.Where(c => c.PartyNo == PartyNo.PartyNo))
{
Character Pcharacter = Program.Entity.Characters.First(c => c.ID == party.CharNo);
ZoneClient otherLiveInfo = ClientManager.Instance.GetClientByName(Pcharacter.Name);
if (otherLiveInfo != null)
{
if (otherLiveInfo.Character.MapID == client.Character.MapID)
{
using (var ppacket = new Packet(SH14Type.PartyInformationShort))
{
ppacket.WriteByte(1);
ppacket.WriteString(otherLiveInfo.Character.Name, 16);
ppacket.WriteUInt(otherLiveInfo.Character.HP);
ppacket.WriteUInt(otherLiveInfo.Character.SP);
ppacket.WriteUInt(otherLiveInfo.Character.LP);
client.SendPacket(ppacket);
}
using (var ppacket = new Packet(SH14Type.PartyInformation))
{
ppacket.WriteByte(1); //unk
ppacket.WriteString(otherLiveInfo.Character.Name, 16);
ppacket.WriteByte((byte)otherLiveInfo.Character.Job);
ppacket.WriteByte(otherLiveInfo.Character.Level);
ppacket.WriteUInt(otherLiveInfo.Character.HP);
ppacket.WriteUInt(otherLiveInfo.Character.SP);
ppacket.WriteUInt(otherLiveInfo.Character.LP);
ppacket.WriteByte(1); //unk
client.SendPacket(ppacket);
}
using (var ppacket = new Packet(SH14Type.PartyLoginCord))
{
ppacket.WriteByte(1); //unk
ppacket.WriteString(otherLiveInfo.Character.Name, 16);
ppacket.WriteInt(otherLiveInfo.Character.Position.X);
ppacket.WriteInt(otherLiveInfo.Character.Position.Y);
client.SendPacket(ppacket);
}
}
}
}
}
}
public static void MasterList(WorldClient client, Packet packet)
{
Dictionary<string, string> list = new Dictionary<string, string>
{
{"Char1", "hier ist Char1"},
{"Char2", "hier ist Char2"}
};
using (var ppacket = new Packet(SH14Type.GroupList))
{
ppacket.WriteHexAsBytes("00 00 14 01 01 00 01 00 00 00");
ppacket.WriteInt(list.Count);
foreach (KeyValuePair<string, string> stat in list)
{
// Note - teh f**k?
ppacket.WriteHexAsBytes("");
ppacket.WriteString("haha", 16);
ppacket.WriteString("1234567890123456789012345678901234567890123456", 46);
ppacket.WriteHexAsBytes("00 00 00 00 44 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 8C 8E CD 00 88 49 DF 4E B3 08 4C 00 78 26 43 00 01 00 00 00 5A 68 42 00 18 FE 64 02 40 55 DF 4E 08 27 4D 00 94 FF 64 02 24 00 00 00 BD 68 42 00 87 BE");
}
list.Clear();
client.SendPacket(ppacket);
}
}
public void WritePacket(Packet pPacket)
{
pPacket.WriteUShort(ItemID);
if (this.Type != HouseType.Resting)
{
pPacket.Fill(10, 0xFF); // Unknown
pPacket.WriteString(this.Name, 30);
}
else
{
pPacket.WriteHexAsBytes("BE 02 FA 01 F8 01");
pPacket.Fill(34, 0xFF); // No idea!?
}
pPacket.WriteByte(0xFF);
}
public static void AddBlock(WorldClient client, Packet packet)
{
string AddBlockname;
if (packet.TryReadString(out AddBlockname, 16))
{
client.Character.BlocketUser.Add(AddBlockname);
using (var pp = new Packet(SH42Type.AddToBlockList))
{
pp.WriteUShort(7168);//unk
pp.WriteString(AddBlockname, 16);
pp.WriteUShort(0);//unk
client.SendPacket(pp);
}
Program.DatabaseManager.GetClient().ExecuteQuery("INSERT INTO BlockUser (CharID,BlockCharname) VALUES ('" + client.Character.ID + "','" + AddBlockname + "')");
}
}
public static void RemoveFromBlockList(WorldClient client, Packet packet)
{
string removename;
if (packet.TryReadString(out removename, 16))
{
if (client.Character.BlocketUser.Contains(removename))
{
using (var pack = new Packet(SH42Type.RemoveFromBlockList))
{
pack.WriteUShort(7184);//unk
pack.WriteString(removename, 16);
client.SendPacket(pack);
}
Program.DatabaseManager.GetClient().ExecuteQuery("DELETE FROM BlockUser WHERE CharID = '" + client.Character.ID + "' AND BlockCharname= '" + removename + "'");
client.Character.BlocketUser.Remove(removename);
}
}
}
public void Write(Packet packet)
{
packet.WriteUShort(this.MapObjectID);
packet.WriteByte(2); //always 2 (type i bet shown / transparent?)
packet.WriteUShort(ID);
packet.WriteInt(this.Position.X);
packet.WriteInt(this.Position.Y);
packet.WriteByte(this.Rotation); //TODO: rotation for NPC (from txt official files?)
if (Gate != null)
{
packet.WriteByte(1);
packet.WriteString(Gate.MapClient, 12);
packet.Fill(41, 0);
}
else
{
packet.Fill(54, 0); //find out later
}
}
public void Write(Packet packet)
{
packet.WriteUShort(this.MapObjectID);
packet.WriteByte(2); //always 2 (type i bet shown / transparent?) -> test it
packet.WriteUShort(this.ID);
packet.WriteInt(this.Position.X);
packet.WriteInt(this.Position.Y);
packet.WriteByte(this.Rotation);
if (Gate != null)
{
packet.WriteByte(1);
packet.WriteString(Gate.MapClient, 12);
packet.Fill(43, 0);
}
else
{
packet.Fill(56, 0); //find out later
}
}
private void SendMasterRequestAccept(WorldClient pClient,string TargetName)
{
using(var packet = new Packet(SH37Type.SendMasterRequestAccept))
{
packet.WriteString(TargetName, 16);
pClient.SendPacket(packet);
}
}
private void SendApprenticeRemoveMaster(WorldClient pClient,string name)
{
using(var packet = new Packet(SH37Type.SendApprenticeRemoveMaster))
{
packet.WriteString(name, 16);
packet.WriteByte(0);//isonline?
pClient.SendPacket(packet);
}
}
private void SendApprenticeLevelUp(WorldClient pClient,string charname,byte level)
{
using (var packet = new Packet(SH37Type.SendApprenticeLevelUp))
{
packet.WriteString(charname, 16);
packet.WriteByte(level);
pClient.SendPacket(packet);
}
}
