public void HandleAuthLogonChallenge(RealmClass session, PacketReader data)
{
Log.Message(LogType.NORMAL, "AuthLogonChallenge");
data.Skip(10);
ushort ClientBuild = data.ReadUInt16();
data.Skip(8);
account.Language = data.ReadStringFromBytes(4);
data.Skip(4);
account.IP = data.ReadIPAddress();
account.Name = data.ReadAccountName();
SQLResult result = DB.Realms.Select("SELECT id, name, password, expansion, gmlevel, securityFlags FROM accounts WHERE name = '{0}'", account.Name);
PacketWriter logonChallenge = new PacketWriter();
logonChallenge.WriteUInt8((byte)ClientLink.CMD_AUTH_LOGON_CHALLENGE);
logonChallenge.WriteUInt8(0);
if (result.Count != 0)
{
account.Id = result.Read<Int32>(0, "id");
account.Expansion = result.Read<Byte>(0, "expansion");
account.SecurityFlags = result.Read<Byte>(0, "securityFlags");
DB.Realms.Execute("UPDATE accounts SET ip = '{0}', language = '{1}' WHERE id = {2}", account.IP, account.Language, account.Id);
byte[] username = Encoding.ASCII.GetBytes(result.Read<String>(0, "name").ToUpper());
byte[] password = Encoding.ASCII.GetBytes(result.Read<String>(0, "password").ToUpper());
// WoW 5.1.0.16173 (5.1.0 PTR)
if (ClientBuild == 16173)
{
session.SecureRemotePassword.CalculateX(username, password);
byte[] buf = new byte[0x10];
SRP6.RAND_bytes(buf, 0x10);
logonChallenge.WriteUInt8((byte)AuthResults.WOW_SUCCESS);
logonChallenge.WriteBytes(session.SecureRemotePassword.B);
logonChallenge.WriteUInt8(1);
logonChallenge.WriteUInt8(session.SecureRemotePassword.g[0]);
logonChallenge.WriteUInt8(0x20);
logonChallenge.WriteBytes(session.SecureRemotePassword.N);
logonChallenge.WriteBytes(session.SecureRemotePassword.salt);
logonChallenge.WriteBytes(buf);
// Security flags
logonChallenge.WriteUInt8(account.SecurityFlags);
// Enable authenticator
if ((account.SecurityFlags & 4) != 0)
logonChallenge.WriteUInt8(1);
}
}
else
logonChallenge.WriteUInt8((byte)AuthResults.WOW_FAIL_UNKNOWN_ACCOUNT);
session.Send(logonChallenge);
}
public static void HandleUpdateObject(ref PacketReader packet, ref WorldClass session)
{
Character character = session.Character;
PacketWriter updateObject = new PacketWriter(LegacyMessage.UpdateObject);
updateObject.WriteUInt16((ushort)character.Map);
updateObject.WriteUInt32(1); // Grml sandbox style...
updateObject.WriteUInt8(1);
updateObject.WriteGuid(character.Guid);
updateObject.WriteUInt8(4);
UpdateFlag updateFlags = UpdateFlag.Alive | UpdateFlag.Rotation | UpdateFlag.Self | UpdateFlag.Unknown4;
WorldMgr.WriteUpdateObjectMovement(ref updateObject, ref character, updateFlags);
character.WriteUpdateFields(ref updateObject);
session.Send(updateObject);
}
public static PacketWriter HandleObjectDestroy(ref WorldClass session, ulong guid)
{
PacketWriter objectDestroy = new PacketWriter(LegacyMessage.ObjectDestroy);
objectDestroy.WriteUInt64(guid);
objectDestroy.WriteUInt8(0);
return objectDestroy;
}
public static void HandleObjectDestroy(ref WorldClass session)
{
PacketWriter objectDestroy = new PacketWriter(LegacyMessage.ObjectDestroy);
objectDestroy.WriteUInt64(session.Character.Guid);
objectDestroy.WriteUInt8(0);
session.Send(objectDestroy);
}
public static void HandleUpdateObjectCreate(ref WorldClass session)
{
WorldObject character = session.Character;
PacketWriter updateObject = new PacketWriter(LegacyMessage.UpdateObject);
updateObject.WriteUInt16((ushort)character.Map);
updateObject.WriteUInt32(1);
updateObject.WriteUInt8((byte)UpdateType.CreateObject);
updateObject.WriteGuid(character.Guid);
updateObject.WriteUInt8((byte)ObjectType.Player);
UpdateFlag updateFlags = UpdateFlag.Alive | UpdateFlag.Rotation | UpdateFlag.Self;
WorldMgr.WriteUpdateObjectMovement(ref updateObject, ref character, updateFlags);
character.WriteUpdateFields(ref updateObject);
character.WriteDynamicUpdateFields(ref updateObject);
session.Send(ref updateObject);
}
public static void HandleRealmCache(ref PacketReader packet, ref WorldClass session)
{
Character pChar = session.Character;
uint realmId = packet.ReadUInt32();
SQLResult result = DB.Realms.Select("SELECT name FROM realms WHERE id = '{0}'", WorldConfig.RealmId);
string realmName = result.Read<string>(0, "Name");
PacketWriter nameCache = new PacketWriter(LegacyMessage.RealmCache);
nameCache.WriteUInt32(realmId);
nameCache.WriteUInt8(0); // < 0 => End of packet
nameCache.WriteUInt8(1); // Unknown
nameCache.WriteCString(realmName);
nameCache.WriteCString(realmName);
session.Send(nameCache);
}
public static void HandleNameCache(ref PacketReader packet, ref WorldClass session)
{
Character pChar = session.Character;
ulong guid = packet.ReadUInt64();
uint realmId = packet.ReadUInt32();
PacketWriter nameCache = new PacketWriter(LegacyMessage.NameCache);
nameCache.WriteGuid(guid);
nameCache.WriteUInt8(0);
nameCache.WriteCString(pChar.Name);
nameCache.WriteUInt32(realmId);
nameCache.WriteUInt8(pChar.Race);
nameCache.WriteUInt8(pChar.Gender);
nameCache.WriteUInt8(pChar.Class);
nameCache.WriteUInt8(0);
session.Send(nameCache);
}
public static void HandleAuthChallenge(ref PacketReader packet, ref WorldClass session)
{
PacketWriter authChallenge = new PacketWriter(ServerMessage.AuthChallenge, true);
for (int i = 0; i < 8; i++)
authChallenge.WriteUInt32(0);
authChallenge.WriteUInt32((uint)new Random(DateTime.Now.Second).Next(1, 0xFFFFFFF));
authChallenge.WriteUInt8(1);
session.Send(ref authChallenge);
}
public static void HandleCreatureStats(ref PacketReader packet, ref WorldClass session)
{
int id = packet.ReadInt32();
ulong guid = packet.ReadUInt64();
Creature creature = DataMgr.FindCreature(id);
if (creature != null)
{
CreatureStats stats = creature.Stats;
PacketWriter creatureStats = new PacketWriter(LegacyMessage.CreatureStats);
creatureStats.WriteInt32(stats.Id);
creatureStats.WriteCString(stats.Name);
for (int i = 0; i < 7; i++)
creatureStats.WriteCString("");
creatureStats.WriteCString(stats.SubName);
creatureStats.WriteCString("");
creatureStats.WriteCString(stats.IconName);
foreach (var v in stats.Flag)
creatureStats.WriteInt32(v);
creatureStats.WriteInt32(stats.Type);
creatureStats.WriteInt32(stats.Family);
creatureStats.WriteInt32(stats.Rank);
foreach (var v in stats.QuestKillNpcId)
creatureStats.WriteInt32(v);
foreach (var v in stats.DisplayInfoId)
creatureStats.WriteInt32(v);
creatureStats.WriteFloat(stats.HealthModifier);
creatureStats.WriteFloat(stats.PowerModifier);
creatureStats.WriteUInt8(stats.RacialLeader);
foreach (var v in stats.QuestItemId)
creatureStats.WriteInt32(v);
creatureStats.WriteInt32(stats.MovementInfoId);
creatureStats.WriteInt32(stats.ExpansionRequired);
session.Send(ref creatureStats);
}
else
Log.Message(LogType.DEBUG, "Creature (Id: {0}) not found.", id);
}
public static void SendMessageByType(ref WorldClass session, MessageType type, int language, string chatMessage)
{
PacketWriter messageChat = new PacketWriter(LegacyMessage.MessageChat);
ulong guid = session.Character.Guid;
messageChat.WriteUInt8((byte)type);
messageChat.WriteInt32(language);
messageChat.WriteUInt64(guid);
messageChat.WriteUInt32(0);
messageChat.WriteUInt64(guid);
messageChat.WriteUInt32((uint)chatMessage.Length + 1);
messageChat.WriteCString(chatMessage);
messageChat.WriteUInt16(0);
session.Send(ref messageChat);
}
public static void HandleLogoutRequest(ref PacketReader packet, WorldClass session)
{
PacketWriter logoutResponse = new PacketWriter(ServerMessage.LogoutResponse);
BitPack BitPack = new BitPack(logoutResponse);
logoutResponse.WriteUInt8(0);
BitPack.Write(0);
BitPack.Flush();
session.Send(ref logoutResponse);
Task.Delay(20000).ContinueWith(_ => HandleLogoutComplete(session), (cts = new CancellationTokenSource()).Token);
session.Character.setStandState(1);
MoveHandler.HandleMoveRoot(session);
}
public static void HandleCharDelete(ref PacketReader packet, WorldClass session)
{
byte[] guidMask = { 7, 0, 4, 1, 6, 5, 3, 2 };
byte[] guidBytes = { 6, 7, 5, 0, 4, 2, 3, 1 };
var GuidUnpacker = new BitUnpack(packet);
var guid = GuidUnpacker.GetPackedValue(guidMask, guidBytes);
PacketWriter deleteChar = new PacketWriter(ServerMessage.DeleteChar);
deleteChar.WriteUInt8(0x48);
session.Send(ref deleteChar);
DB.Characters.Execute("DELETE FROM characters WHERE guid = ?", guid);
DB.Characters.Execute("DELETE FROM character_spells WHERE guid = ?", guid);
DB.Characters.Execute("DELETE FROM character_skills WHERE guid = ?", guid);
}
public static void HandleLogoutComplete(ref PacketReader packet, ref WorldClass session)
{
var pChar = session.Character;
ObjectMgr.SavePositionToDB(pChar);
PacketWriter logoutComplete = new PacketWriter(LegacyMessage.LogoutComplete);
session.Send(ref logoutComplete);
// Destroy object after logout
PacketWriter objectDestroy = new PacketWriter(LegacyMessage.ObjectDestroy);
objectDestroy.WriteUInt64(pChar.Guid);
objectDestroy.WriteUInt8(0);
WorldMgr.SendToAllInMap(pChar.Guid, objectDestroy);
WorldMgr.DeleteSession(pChar.Guid);
}
public static void SendMessageByType(ref WorldClass session, MessageType type, int language, string chatMessage, bool Broadcast = false)
{
PacketWriter messageChat = new PacketWriter(LegacyMessage.MessageChat);
ulong guid = session.Character.Guid;
messageChat.WriteUInt8((byte)type);
messageChat.WriteInt32(language);
messageChat.WriteUInt64(guid);
messageChat.WriteUInt32(0);
messageChat.WriteUInt64(guid);
messageChat.WriteUInt32((uint)chatMessage.Length + 1);
messageChat.WriteCString(chatMessage);
messageChat.WriteUInt16(0);
if (Broadcast)
{
Globals.WorldMgr.SendToInRangeCharacter(session.Character, messageChat);
session.Send(ref messageChat);
}
else
session.Send(ref messageChat);
}
public static void HandleCharDelete(ref PacketReader packet, ref WorldClass session)
{
bool[] guidMask = new bool[8];
byte[] guidBytes = new byte[8];
BitUnpack BitUnpack = new BitUnpack(packet);
guidMask[2] = BitUnpack.GetBit();
guidMask[1] = BitUnpack.GetBit();
guidMask[5] = BitUnpack.GetBit();
guidMask[7] = BitUnpack.GetBit();
guidMask[6] = BitUnpack.GetBit();
var unknown = BitUnpack.GetBit();
guidMask[3] = BitUnpack.GetBit();
guidMask[0] = BitUnpack.GetBit();
guidMask[4] = BitUnpack.GetBit();
if (guidMask[1]) guidBytes[1] = (byte)(packet.Read<byte>() ^ 1);
if (guidMask[3]) guidBytes[3] = (byte)(packet.Read<byte>() ^ 1);
if (guidMask[4]) guidBytes[4] = (byte)(packet.Read<byte>() ^ 1);
if (guidMask[0]) guidBytes[0] = (byte)(packet.Read<byte>() ^ 1);
if (guidMask[7]) guidBytes[7] = (byte)(packet.Read<byte>() ^ 1);
if (guidMask[2]) guidBytes[2] = (byte)(packet.Read<byte>() ^ 1);
if (guidMask[5]) guidBytes[5] = (byte)(packet.Read<byte>() ^ 1);
if (guidMask[6]) guidBytes[6] = (byte)(packet.Read<byte>() ^ 1);
var guid = BitConverter.ToUInt64(guidBytes, 0);
PacketWriter deleteChar = new PacketWriter(ServerMessage.DeleteChar);
deleteChar.WriteUInt8(0x47);
session.Send(ref deleteChar);
DB.Characters.Execute("DELETE FROM characters WHERE guid = ?", guid);
DB.Characters.Execute("DELETE FROM character_spells WHERE guid = ?", guid);
DB.Characters.Execute("DELETE FROM character_skills WHERE guid = ?", guid);
}
public static void HandleChatMessageSay(ref PacketReader packet, ref WorldClass session)
{
BitUnpack BitUnpack = new BitUnpack(packet);
int language = packet.ReadInt32();
uint messageLength = BitUnpack.GetBits<uint>(9);
string chatMessage = packet.ReadString(messageLength);
PacketWriter messageChat = new PacketWriter(LegacyMessage.MessageChat);
ulong guid = WorldMgr.Session.Character.Guid;
messageChat.WriteUInt8(1);
messageChat.WriteInt32(language);
messageChat.WriteUInt64(guid);
messageChat.WriteUInt32(0);
messageChat.WriteUInt64(guid);
messageChat.WriteUInt32(messageLength + 1);
messageChat.WriteCString(chatMessage);
messageChat.WriteUInt16(0);
session.Send(messageChat);
}
public static void HandleMoveTeleport(ref WorldClass session, Vector4 vector)
{
bool IsTransport = false;
bool Unknown = false;
PacketWriter moveTeleport = new PacketWriter(ServerMessage.MoveTeleport);
BitPack BitPack = new BitPack(moveTeleport, session.Character.Guid);
BitPack.WriteGuidMask(7);
BitPack.Write(Unknown);
BitPack.WriteGuidMask(2, 0);
if (Unknown)
{
BitPack.Write(0);
BitPack.Write(0);
}
BitPack.Write(IsTransport);
if (IsTransport)
BitPack.WriteTransportGuidMask(4, 3, 5, 7, 0, 2, 6, 1);
BitPack.WriteGuidMask(5, 1, 3, 6, 4);
BitPack.Flush();
BitPack.WriteGuidBytes(0);
if (IsTransport)
BitPack.WriteTransportGuidBytes(7, 6, 0, 2, 3, 1, 5, 4);
BitPack.WriteGuidBytes(6, 1);
moveTeleport.WriteUInt32(0);
BitPack.WriteGuidBytes(7, 5);
moveTeleport.WriteFloat(vector.X);
BitPack.WriteGuidBytes(4, 3, 2);
moveTeleport.WriteFloat(vector.Y);
moveTeleport.WriteFloat(vector.O);
moveTeleport.WriteFloat(vector.Z);
if (Unknown)
moveTeleport.WriteUInt8(0);
session.Send(ref moveTeleport);
}
public static void HandleAuthResponse(ref PacketReader packet, ref WorldClass session)
{
BitUnpack BitUnpack = new BitUnpack(packet);
packet.Skip(54);
int addonSize = packet.Read<int>();
packet.Skip(addonSize);
uint nameLength = BitUnpack.GetBits<uint>(12);
string accountName = packet.ReadString(nameLength);
SQLResult result = DB.Realms.Select("SELECT * FROM accounts WHERE name = ?", accountName);
if (result.Count == 0)
session.clientSocket.Close();
else
session.Account = new Account()
{
Id = result.Read<int>(0, "id"),
Name = result.Read<String>(0, "name"),
Password = result.Read<String>(0, "password"),
SessionKey = result.Read<String>(0, "sessionkey"),
Expansion = result.Read<byte>(0, "expansion"),
GMLevel = result.Read<byte>(0, "gmlevel"),
IP = result.Read<String>(0, "ip"),
Language = result.Read<String>(0, "language")
};
string K = session.Account.SessionKey;
byte[] kBytes = new byte[K.Length / 2];
for (int i = 0; i < K.Length; i += 2)
kBytes[i / 2] = Convert.ToByte(K.Substring(i, 2), 16);
session.Crypt.Initialize(kBytes);
uint realmId = WorldConfig.RealmId;
SQLResult realmClassResult = DB.Realms.Select("SELECT class, expansion FROM realm_classes WHERE realmId = ?", realmId);
SQLResult realmRaceResult = DB.Realms.Select("SELECT race, expansion FROM realm_races WHERE realmId = ?", realmId);
bool HasAccountData = true;
bool IsInQueue = false;
PacketWriter authResponse = new PacketWriter(ServerMessage.AuthResponse);
BitPack BitPack = new BitPack(authResponse);
BitPack.Write(IsInQueue);
if (IsInQueue)
BitPack.Write(1); // Unknown
BitPack.Write(HasAccountData);
if (HasAccountData)
{
BitPack.Write(0); // Unknown, 5.0.4
BitPack.Write(0); // Unknown, 5.3.0
BitPack.Write(realmRaceResult.Count, 23); // Activation count for races
BitPack.Write(0); // Unknown, 5.1.0
BitPack.Write(0, 21); // Activate character template windows/button
//if (HasCharacterTemplate)
//Write bits for char templates...
BitPack.Write(realmClassResult.Count, 23); // Activation count for classes
BitPack.Write(0, 22); // Unknown, 5.3.0
BitPack.Write(0); // Unknown2, 5.3.0
}
BitPack.Flush();
if (HasAccountData)
{
authResponse.WriteUInt8(0);
for (int c = 0; c < realmClassResult.Count; c++)
{
authResponse.WriteUInt8(realmClassResult.Read<byte>(c, "expansion"));
authResponse.WriteUInt8(realmClassResult.Read<byte>(c, "class"));
}
//if (Unknown2)
// authResponse.WriteUInt16(0);
//if (HasCharacterTemplate)
//Write data for char templates...
//if (Unknown)
// authResponse.WriteUInt16(0);
for (int r = 0; r < realmRaceResult.Count; r++)
{
authResponse.WriteUInt8(realmRaceResult.Read<byte>(r, "expansion"));
authResponse.WriteUInt8(realmRaceResult.Read<byte>(r, "race"));
}
authResponse.WriteUInt32(0);
authResponse.WriteUInt32(0);
authResponse.WriteUInt32(0);
authResponse.WriteUInt8(session.Account.Expansion);
// Unknown Counter
// Write UInt32...
authResponse.WriteUInt8(session.Account.Expansion);
}
authResponse.WriteUInt8((byte)AuthCodes.AUTH_OK);
if (IsInQueue)
authResponse.WriteUInt32(0);
session.Send(ref authResponse);
MiscHandler.HandleCacheVersion(ref session);
TutorialHandler.HandleTutorialFlags(ref session);
}
public static void HandleCreateCharacter(ref PacketReader packet, WorldClass session)
{
BitUnpack BitUnpack = new BitUnpack(packet);
var hairStyle = packet.ReadByte();
var gender = packet.ReadByte();
var skin = packet.ReadByte();
var hairColor = packet.ReadByte();
var facialHair = packet.ReadByte();
var pClass = packet.ReadByte();
var race = packet.ReadByte();
var face = packet.ReadByte();
packet.ReadByte(); // Always 0
var HasUnknown = BitUnpack.GetBit();
var nameLength = BitUnpack.GetBits<uint>(6);
var name = Character.NormalizeName(packet.ReadString(nameLength));
if (HasUnknown)
packet.ReadUInt32();
var result = DB.Characters.Select("SELECT * from characters WHERE name = ?", name);
var createChar = new PacketWriter(ServerMessage.CreateChar);
if (result.Count != 0)
{
// Name already in use
createChar.WriteUInt8(0x32);
session.Send(ref createChar);
return;
}
result = DB.Characters.Select("SELECT map, zone, posX, posY, posZ, posO FROM character_creation_data WHERE race = ? AND class = ?", race, pClass);
if (result.Count == 0)
{
createChar.WriteUInt8(0x31);
session.Send(ref createChar);
return;
}
var map = result.Read<uint>(0, "map");
var zone = result.Read<uint>(0, "zone");
var posX = result.Read<float>(0, "posX");
var posY = result.Read<float>(0, "posY");
var posZ = result.Read<float>(0, "posZ");
var posO = result.Read<float>(0, "posO");
// Allow declined names for now
var characterFlags = CharacterFlag.Decline;
DB.Characters.Execute("INSERT INTO characters (name, accountid, realmId, race, class, gender, skin, zone, map, x, y, z, o, face, hairstyle, haircolor, facialhair, characterFlags) VALUES (" +
"?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
name, session.Account.Id, WorldConfig.RealmId, race, pClass, gender, skin, zone, map, posX, posY, posZ, posO, face, hairStyle, hairColor, facialHair, characterFlags);
// Success
createChar.WriteUInt8(0x2F);
session.Send(ref createChar);
}
public static void HandleUpdateObjectCreate(ref WorldClass session)
{
WorldObject character = session.Character;
PacketWriter updateObject = new PacketWriter(LegacyMessage.UpdateObject);
updateObject.WriteUInt16((ushort)character.Map);
updateObject.WriteUInt32(1);
updateObject.WriteUInt8((byte)UpdateType.CreateObject);
updateObject.WriteGuid(character.Guid);
updateObject.WriteUInt8((byte)ObjectType.Player);
UpdateFlag updateFlags = UpdateFlag.Alive | UpdateFlag.Rotation | UpdateFlag.Self;
WorldMgr.WriteUpdateObjectMovement(ref updateObject, ref character, updateFlags);
character.WriteUpdateFields(ref updateObject);
character.WriteDynamicUpdateFields(ref updateObject);
session.Send(ref updateObject);
var tempSessions = new Dictionary<ulong, WorldClass>(WorldMgr.Sessions);
tempSessions.Remove(character.Guid);
if (tempSessions != null)
{
foreach (var s in tempSessions)
{
if (s.Value.Character.CheckUpdateDistance(character))
{
updateObject = new PacketWriter(LegacyMessage.UpdateObject);
updateObject.WriteUInt16((ushort)character.Map);
updateObject.WriteUInt32(1);
updateObject.WriteUInt8((byte)UpdateType.CreateObject);
updateObject.WriteGuid(character.Guid);
updateObject.WriteUInt8((byte)ObjectType.Player);
updateFlags = UpdateFlag.Alive | UpdateFlag.Rotation;
WorldMgr.WriteUpdateObjectMovement(ref updateObject, ref character, updateFlags);
character.WriteUpdateFields(ref updateObject);
character.WriteDynamicUpdateFields(ref updateObject);
s.Value.Send(ref updateObject);
}
}
foreach (var s in tempSessions)
{
WorldObject pChar = s.Value.Character;
if (character.CheckUpdateDistance(pChar))
{
character.ToCharacter().InRangeObjects.Add(pChar.Guid, pChar);
updateObject = new PacketWriter(LegacyMessage.UpdateObject);
updateObject.WriteUInt16((ushort)pChar.Map);
updateObject.WriteUInt32(1);
updateObject.WriteUInt8((byte)UpdateType.CreateObject);
updateObject.WriteGuid(pChar.Guid);
updateObject.WriteUInt8((byte)ObjectType.Player);
updateFlags = UpdateFlag.Alive | UpdateFlag.Rotation;
WorldMgr.WriteUpdateObjectMovement(ref updateObject, ref pChar, updateFlags);
pChar.WriteUpdateFields(ref updateObject);
pChar.WriteDynamicUpdateFields(ref updateObject);
session.Send(ref updateObject);
}
}
}
}
public static void HandleEnumCharactersResult(ref PacketReader packet, WorldClass session)
{
// Set existing character from last world session to null
session.Character = null;
DB.Realms.Execute("UPDATE accounts SET online = 1 WHERE id = ?", session.Account.Id);
SQLResult result = DB.Characters.Select("SELECT * FROM characters WHERE accountid = ?", session.Account.Id);
PacketWriter enumCharacters = new PacketWriter(ServerMessage.EnumCharactersResult);
BitPack BitPack = new BitPack(enumCharacters);
BitPack.Write(0, 21);
BitPack.Write(result.Count, 16);
for (int c = 0; c < result.Count; c++)
{
var name = result.Read<string>(c, "Name");
var loginCinematic = result.Read<bool>(c, "LoginCinematic");
BitPack.Guid = result.Read<ulong>(c, "Guid");
BitPack.GuildGuid = result.Read<ulong>(c, "GuildGuid");
BitPack.WriteGuidMask(0);
BitPack.WriteGuildGuidMask(4);
BitPack.WriteGuidMask(7);
BitPack.WriteGuildGuidMask(3, 7);
BitPack.WriteGuidMask(5, 4, 6);
BitPack.WriteGuildGuidMask(1);
BitPack.WriteGuidMask(3, 2);
BitPack.WriteGuildGuidMask(0, 2);
BitPack.WriteGuidMask(1);
BitPack.WriteGuildGuidMask(5);
BitPack.Write(loginCinematic);
BitPack.WriteGuildGuidMask(6);
BitPack.Write((uint)UTF8Encoding.UTF8.GetBytes(name).Length, 6);
}
BitPack.Write(1);
BitPack.Flush();
for (int c = 0; c < result.Count; c++)
{
string name = result.Read<string>(c, "Name");
BitPack.Guid = result.Read<ulong>(c, "Guid");
BitPack.GuildGuid = result.Read<ulong>(c, "GuildGuid");
enumCharacters.WriteUInt32(result.Read<uint>(c, "PetLevel"));
enumCharacters.WriteUInt8(result.Read<byte>(c, "Level"));
BitPack.WriteGuildGuidBytes(2, 3);
//TODO: implement items
for (int j = 0; j < 23; j++)
{
enumCharacters.WriteUInt32(0);
enumCharacters.WriteUInt32(0);
enumCharacters.WriteUInt8(0);
}
BitPack.WriteGuildGuidBytes(6);
enumCharacters.WriteUInt8(0);
enumCharacters.WriteUInt8(result.Read<byte>(c, "HairStyle"));
enumCharacters.WriteUInt32(result.Read<uint>(c, "CustomizeFlags"));
enumCharacters.WriteUInt8(result.Read<byte>(c, "Class"));
BitPack.WriteGuildGuidBytes(7);
BitPack.WriteGuidBytes(0);
enumCharacters.WriteUInt32(result.Read<uint>(c, "PetFamily"));
BitPack.WriteGuildGuidBytes(1);
BitPack.WriteGuidBytes(3, 7, 2);
BitPack.WriteGuildGuidBytes(5);
enumCharacters.WriteUInt8(result.Read<byte>(c, "Gender"));
enumCharacters.WriteUInt32(result.Read<uint>(c, "PetDisplayId"));
enumCharacters.WriteUInt32(result.Read<uint>(c, "Zone"));
BitPack.WriteGuidBytes(6);
enumCharacters.WriteUInt8(result.Read<byte>(c, "HairColor"));
enumCharacters.WriteUInt8(result.Read<byte>(c, "FacialHair"));
enumCharacters.WriteString(name);
enumCharacters.WriteUInt8(result.Read<byte>(c, "Race"));
BitPack.WriteGuildGuidBytes(4);
enumCharacters.WriteUInt8(result.Read<byte>(c, "Skin"));
enumCharacters.WriteUInt32(result.Read<uint>(c, "Map"));
enumCharacters.WriteUInt32(result.Read<uint>(c, "CharacterFlags"));
enumCharacters.WriteFloat(result.Read<float>(c, "Y"));
BitPack.WriteGuildGuidBytes(0);
BitPack.WriteGuidBytes(4, 1);
enumCharacters.WriteFloat(result.Read<float>(c, "Z"));
BitPack.WriteGuidBytes(5);
enumCharacters.WriteUInt8(result.Read<byte>(c, "Face"));
enumCharacters.WriteFloat(result.Read<float>(c, "X"));
}
session.Send(ref enumCharacters);
}
public static void HandleUpdateActionButtons(ref WorldClass session)
{
var pChar = session.Character;
PacketWriter updateActionButtons = new PacketWriter(ServerMessage.UpdateActionButtons);
BitPack BitPack = new BitPack(updateActionButtons);
const int buttonCount = 132;
var buttons = new byte[buttonCount][];
byte[] buttonMask = { 0, 1, 3, 4, 6, 7, 2, 5 };
byte[] buttonBytes = { 5, 2, 0, 1, 3, 6, 4, 7 };
var actions = ActionMgr.GetActionButtons(pChar, pChar.ActiveSpecGroup);
for (int i = 0; i < buttonCount; i++)
if (actions.Any(action => action.SlotId == i))
buttons[i] = BitConverter.GetBytes((ulong)actions.Where(action => action.SlotId == i).Select(action => action.Action).First());
else
buttons[i] = new byte[8];
for (int i = 0; i < 16; i++)
{
for (int j = 0; j < buttonCount; j++)
{
if (i < 8)
BitPack.Write(buttons[j][buttonMask[i]]);
else if (i < 16)
{
BitPack.Flush();
if (buttons[j][buttonBytes[i - 8]] != 0)
updateActionButtons.WriteUInt8((byte)(buttons[j][buttonBytes[i - 8]] ^ 1));
}
}
}
// 0 - Initial packet on Login (no verification) / 1 - Verify spells on switch (Spec change) / 2 - Clear Action Buttons (Spec change)
updateActionButtons.WriteInt8(0);
session.Send(ref updateActionButtons);
}
public void HandleRealmList(PacketReader data)
{
Log.Message(LogType.NORMAL, "RealmList");
using (var realmData = new PacketWriter())
{
Realms.ToList().ForEach(r =>
{
using (var result = DB.Characters.Select("SELECT COUNT(*) as Count FROM characters WHERE AccountId = ? AND RealmId = ?", account.Id, r.Value.Id))
{
var charCount = result.Read<byte>(0, "Count");
realmData.WriteUInt8(1);
realmData.WriteUInt8(0);
realmData.WriteUInt8(0);
realmData.WriteCString(r.Key);
realmData.WriteCString(r.Value.IP + ":" + r.Value.Port);
realmData.WriteFloat(0);
realmData.WriteUInt8(charCount);
realmData.WriteUInt8(1);
realmData.WriteUInt8(0x2C);
}
});
using (var realmList = new PacketWriter())
{
realmList.WriteUInt8((byte)ClientLink.CMD_REALM_LIST);
realmList.WriteUInt16((ushort)(realmData.BaseStream.Length + 8));
realmList.WriteUInt32(0);
realmList.WriteUInt16((ushort)Realms.Count);
realmList.WriteBytes(realmData.ReadDataToSend());
realmList.WriteUInt8(0);
realmList.WriteUInt8(0x10);
Send(realmList);
}
}
}
public static void HandleQueryPlayerName(ref PacketReader packet, ref WorldClass session)
{
BitUnpack BitUnpack = new BitUnpack(packet);
byte[] guidMask = { 2, 1, 5, 7, 4, 3, 6, 0 };
byte[] guidBytes = { 3, 2, 6, 1, 0, 4, 5, 7 };
uint realmId = packet.Read<uint>();
ulong guid = BitUnpack.GetPackedValue(guidMask, guidBytes);
var pSession = WorldMgr.GetSession(guid);
if (pSession != null)
{
var pChar = pSession.Character;
if (pChar != null)
{
PacketWriter queryPlayerNameResponse = new PacketWriter(ServerMessage.QueryPlayerNameResponse);
BitPack BitPack = new BitPack(queryPlayerNameResponse, guid);
BitPack.WriteGuidMask(7, 3, 0, 2, 1, 6);
BitPack.Write(pChar.Name.Length, 6);
BitPack.WriteGuidMask(4);
BitPack.Write(0);
BitPack.WriteGuidMask(5);
BitPack.Write(0);
BitPack.Flush();
BitPack.WriteGuidBytes(2, 7);
queryPlayerNameResponse.WriteUInt8(0);
BitPack.WriteGuidBytes(5, 6, 4, 1);
queryPlayerNameResponse.WriteUInt8(pChar.Gender);
queryPlayerNameResponse.WriteUInt8(pChar.Race);
queryPlayerNameResponse.WriteUInt32(realmId);
queryPlayerNameResponse.WriteUInt8(pChar.Class);
BitPack.WriteGuidBytes(3, 0);
queryPlayerNameResponse.WriteString(pChar.Name);
session.Send(ref queryPlayerNameResponse);
}
}
}
public static void HandleUpdateObjectValues(ref WorldClass session)
{
WorldObject character = session.Character;
PacketWriter updateObject = new PacketWriter(ServerMessage.ObjectUpdate);
updateObject.WriteUInt16((ushort)character.Map);
updateObject.WriteUInt32(1);
updateObject.WriteUInt8((byte)UpdateType.Values);
updateObject.WriteGuid(character.Guid);
character.WriteUpdateFields(ref updateObject);
character.WriteDynamicUpdateFields(ref updateObject);
session.Send(ref updateObject);
}
public void HandleAuthLogonChallenge(PacketReader data)
{
Log.Message(LogType.NORMAL, "AuthLogonChallenge");
data.Skip(10);
ushort ClientBuild = data.Read<ushort>();
data.Skip(8);
account.Language = data.ReadStringFromBytes(4);
data.Skip(4);
account.IP = data.ReadIPAddress();
account.Name = data.ReadAccountName();
SQLResult result = DB.Realms.Select("SELECT id, name, password, expansion, gmlevel, securityFlags, online FROM accounts WHERE name = ?", account.Name);
using (var logonChallenge = new PacketWriter())
{
logonChallenge.WriteUInt8((byte)ClientLink.CMD_AUTH_LOGON_CHALLENGE);
logonChallenge.WriteUInt8(0);
if (result.Count != 0)
{
if (result.Read<bool>(0, "online"))
{
logonChallenge.WriteUInt8((byte)AuthResults.WOW_FAIL_ALREADY_ONLINE);
Send(logonChallenge);
return;
}
account.Id = result.Read<Int32>(0, "id");
account.Expansion = result.Read<Byte>(0, "expansion");
account.SecurityFlags = result.Read<Byte>(0, "securityFlags");
DB.Realms.Execute("UPDATE accounts SET ip = ?, language = ? WHERE id = ?", account.IP, account.Language, account.Id);
var username = result.Read<String>(0, "name").ToUpperInvariant();
var password = result.Read<String>(0, "password").ToUpperInvariant();
// WoW 5.2.0.16826
if (ClientBuild == 16826)
{
SecureRemotePassword.CalculateX(username, password);
var randBytes = new byte[0x10];
var random = RNGCryptoServiceProvider.Create();
random.GetBytes(randBytes);
logonChallenge.WriteUInt8((byte)AuthResults.WOW_SUCCESS);
logonChallenge.WriteBytes(SecureRemotePassword.B);
logonChallenge.WriteUInt8(1);
logonChallenge.WriteUInt8(SecureRemotePassword.g.ToByteArray()[0]);
logonChallenge.WriteUInt8(0x20);
logonChallenge.WriteBytes(SecureRemotePassword.N);
logonChallenge.WriteBytes(SecureRemotePassword.Salt);
logonChallenge.WriteBytes(randBytes);
// Security flags
logonChallenge.WriteUInt8(account.SecurityFlags);
// Enable authenticator
if ((account.SecurityFlags & 4) != 0)
logonChallenge.WriteUInt8(1);
}
}
else
logonChallenge.WriteUInt8((byte)AuthResults.WOW_FAIL_UNKNOWN_ACCOUNT);
Send(logonChallenge);
}
}
public static void HandleQueryGameObject(ref PacketReader packet, ref WorldClass session)
{
byte[] guidMask = { 4, 6, 7, 5, 3, 2, 1, 0 };
byte[] guidBytes = { 0, 2, 3, 5, 6, 1, 4, 7 };
BitUnpack BitUnpack = new BitUnpack(packet);
var hasData = false;
var id = packet.Read<int>();
var guid = BitUnpack.GetPackedValue(guidMask, guidBytes);
PacketWriter queryGameObjectResponse = new PacketWriter(ServerMessage.QueryGameObjectResponse);
BitPack BitPack = new BitPack(queryGameObjectResponse);
GameObject gObject = DataMgr.FindGameObject(id);
if (hasData = (gObject != null))
{
GameObjectStats stats = gObject.Stats;
BitPack.Write(hasData);
BitPack.Flush();
queryGameObjectResponse.WriteInt32(stats.Id);
queryGameObjectResponse.WriteInt32(0);
queryGameObjectResponse.WriteInt32(stats.Type);
queryGameObjectResponse.WriteInt32(stats.DisplayInfoId);
queryGameObjectResponse.WriteCString(stats.Name);
for (int i = 0; i < 3; i++)
queryGameObjectResponse.WriteCString("");
queryGameObjectResponse.WriteCString(stats.IconName);
queryGameObjectResponse.WriteCString(stats.CastBarCaption);
queryGameObjectResponse.WriteCString("");
foreach (var v in stats.Data)
queryGameObjectResponse.WriteInt32(v);
queryGameObjectResponse.WriteFloat(stats.Size);
queryGameObjectResponse.WriteUInt8((byte)stats.QuestItemId.Count);
foreach (var v in stats.QuestItemId)
queryGameObjectResponse.WriteInt32(v);
queryGameObjectResponse.WriteInt32(stats.ExpansionRequired);
var size = (uint)queryGameObjectResponse.BaseStream.Length - 13;
queryGameObjectResponse.WriteUInt32Pos(size, 9);
session.Send(ref queryGameObjectResponse);
}
else
{
BitPack.Write(hasData);
Log.Message(LogType.DEBUG, "Gameobject (Id: {0}) not found.", id);
}
}
public static void HandleUpdateTalentData(ref WorldClass session)
{
var pChar = session.Character;
const byte glyphCount = 6;
PacketWriter updateTalentData = new PacketWriter(ServerMessage.UpdateTalentData);
BitPack BitPack = new BitPack(updateTalentData);
BitPack.Write(pChar.SpecGroupCount, 19);
for (int i = 0; i < pChar.SpecGroupCount; i++)
{
var talents = SpecializationMgr.GetTalentsBySpecGroup(pChar, (byte)i);
BitPack.Write(talents.Count, 23);
}
BitPack.Flush();
for (int i = 0; i < pChar.SpecGroupCount; i++)
{
var talents = SpecializationMgr.GetTalentsBySpecGroup(pChar, (byte)i);
var specId = (i == 0) ? pChar.PrimarySpec : pChar.SecondarySpec;
for (int j = 0; j < glyphCount; j++)
updateTalentData.WriteInt16(0); // Glyph Id
for (int j = 0; j < talents.Count; j++)
updateTalentData.WriteUInt16(talents[j].Id); // Talent Id
updateTalentData.WriteUInt32(specId); // Spec Id
}
updateTalentData.WriteUInt8(pChar.ActiveSpecGroup); // Active Spec (0 or 1)
session.Send(ref updateTalentData);
}
public static void HandleQueryRealmName(ref PacketReader packet, ref WorldClass session)
{
Character pChar = session.Character;
uint realmId = packet.Read<uint>();
SQLResult result = DB.Realms.Select("SELECT name FROM realms WHERE id = ?", WorldConfig.RealmId);
string realmName = result.Read<string>(0, "Name");
PacketWriter realmQueryResponse = new PacketWriter(ServerMessage.RealmQueryResponse);
BitPack BitPack = new BitPack(realmQueryResponse);
realmQueryResponse.WriteUInt8(0);
realmQueryResponse.WriteUInt32(realmId); // <= 0 => End of packet
BitPack.Write(realmName.Length, 8);
BitPack.Write(realmName.Length, 8);
BitPack.Write(1);
BitPack.Flush();
realmQueryResponse.WriteString(realmName);
realmQueryResponse.WriteString(realmName);
session.Send(ref realmQueryResponse);
}
public static void SendMessage(ref WorldClass session, ChatMessageValues chatMessage, WorldClass pSession = null)
{
byte[] GuidMask = { 4, 1, 3, 6, 2, 5, 0, 7 };
byte[] GuidMask3 = { 6, 1, 3, 5, 4, 2, 7, 0 };
byte[] GuidBytes = { 7, 4, 0, 6, 3, 2, 5, 1 };
byte[] GuidBytes3 = { 7, 4, 1, 3, 0, 6, 5, 2 };
var pChar = session.Character;
var guid = pChar.Guid;
if (pSession != null)
guid = pSession.Character.Guid;
PacketWriter chat = new PacketWriter(ServerMessage.Chat);
BitPack BitPack = new BitPack(chat, guid);
BitPack.Write(!chatMessage.HasLanguage);
BitPack.Write(1);
BitPack.Write(1);
BitPack.Write(0, 8);
BitPack.Write(1);
BitPack.Write(0);
BitPack.Write(1);
BitPack.Write(1);
BitPack.Write(1);
BitPack.Write(0, 8);
BitPack.Write(0);
BitPack.WriteGuidMask(GuidMask3);
BitPack.Write(1);
BitPack.Write(0);
BitPack.Write(1);
BitPack.Write(!chatMessage.HasRealmId);
BitPack.Write(0);
BitPack.WriteStringLength(chatMessage.Message, 12);
BitPack.Write(0);
BitPack.WriteGuidMask(GuidMask);
BitPack.Write(0);
BitPack.Write(8, 9);
BitPack.Flush();
BitPack.WriteGuidBytes(GuidBytes3);
if (chatMessage.HasLanguage)
chat.WriteUInt8(chatMessage.Language);
BitPack.WriteGuidBytes(GuidBytes);
chat.WriteString(chatMessage.Message, false);
chat.WriteUInt8((byte)chatMessage.ChatType);
chat.WriteInt32(0);
if (chatMessage.HasRealmId)
chat.WriteInt32(chatMessage.RealmId);
switch (chatMessage.ChatType)
{
case MessageType.ChatMessageSay:
WorldMgr.SendByDist(pChar, chat, 625);
break;
case MessageType.ChatMessageYell:
WorldMgr.SendByDist(pChar, chat, 90000);
break;
default:
session.Send(ref chat);
break;
}
}
