Exemplo n.º 1
0
        public static void HandleLFGuildAddRecruit(Packet packet)
        {
            var guid = new byte[8];

            packet.ReadUInt32E<GuildFinderOptionsRoles>("Class Roles");
            packet.ReadUInt32E<GuildFinderOptionsInterest>("Guild Interests");
            packet.ReadUInt32E<GuildFinderOptionsAvailability>("Availability");

            guid[3] = packet.ReadBit();
            guid[0] = packet.ReadBit();
            guid[6] = packet.ReadBit();
            guid[1] = packet.ReadBit();
            var comment = packet.ReadBits(11);
            guid[5] = packet.ReadBit();
            guid[4] = packet.ReadBit();
            guid[7] = packet.ReadBit();
            var player = packet.ReadBits(7);
            guid[2] = packet.ReadBit();

            packet.ReadXORByte(guid, 4);
            packet.ReadXORByte(guid, 5);
            packet.ReadWoWString("Comment", comment);
            packet.ReadWoWString("Player name", player);
            packet.ReadXORByte(guid, 7);
            packet.ReadXORByte(guid, 2);
            packet.ReadXORByte(guid, 0);
            packet.ReadXORByte(guid, 6);
            packet.ReadXORByte(guid, 1);
            packet.ReadXORByte(guid, 3);

            packet.WriteGuid("Guild GUID", guid);
        }
Exemplo n.º 2
0
 public static void HandleGuildFinderBrowse(Packet packet)
 {
     packet.ReadUInt32E<GuildFinderOptionsRoles>("Class Roles");
     packet.ReadUInt32E<GuildFinderOptionsAvailability>("Availability");
     packet.ReadUInt32E<GuildFinderOptionsInterest>("Guild Interests");
     packet.ReadUInt32("Player Level");
 }
Exemplo n.º 3
0
 public static void HandleGuildFinderSetGuildPost422(Packet packet)
 {
     packet.ReadBit("Join");
     packet.ReadUInt32E<GuildFinderOptionsAvailability>("Availability");
     packet.ReadUInt32E<GuildFinderOptionsRoles>("Class Roles");
     packet.ReadUInt32E<GuildFinderOptionsInterest>("Guild Interests");
     packet.ReadUInt32E<GuildFinderOptionsLevel>("Level");
     packet.ReadCString("Comment");
 }
Exemplo n.º 4
0
 public static void HandleMailCommandResult(Packet packet)
 {
     packet.ReadUInt32("MailID");
     packet.ReadUInt32E<MailActionType>("Command");
     packet.ReadUInt32E<MailErrorType>("ErrorCode");
     packet.ReadUInt32("BagResult");
     packet.ReadUInt32("AttachID");
     packet.ReadUInt32("QtyInInventory");
 }
Exemplo n.º 5
0
 public static void HandleGuildFinderSetGuildPost434(Packet packet)
 {
     packet.ReadUInt32E<GuildFinderOptionsLevel>("Level");
     packet.ReadUInt32E<GuildFinderOptionsAvailability>("Availability");
     packet.ReadUInt32E<GuildFinderOptionsInterest>("Guild Interests");
     packet.ReadUInt32E<GuildFinderOptionsRoles>("Class Roles");
     var length = packet.ReadBits(11);
     packet.ReadBit("Listed");
     packet.ReadWoWString("Comment", length);
 }
Exemplo n.º 6
0
        public static void HandleAuctionCommandResult(Packet packet)
        {
            packet.ReadUInt32("AuctionItemID");
            packet.ReadUInt32E<AuctionHouseAction>("Command");
            packet.ReadUInt32E<AuctionHouseError>("ErrorCode");
            packet.ReadUInt32("BagResult");
            packet.ReadPackedGuid128("Guid");

            // One of the following is MinIncrement and the other is Money, order still unknown
            packet.ReadUInt64("MinIncrement");
            packet.ReadUInt64("Money");
        }
Exemplo n.º 7
0
        public static void HandleDBReply(Packet packet)
        {
            var type = packet.ReadUInt32E<DB2Hash>("TableHash");
            var entry = packet.ReadInt32("RecordID");
            var timeStamp = packet.ReadUInt32();
            packet.AddValue("Timestamp", Utilities.GetDateTimeFromUnixTime(timeStamp));
            var allow = packet.ReadBit("Allow");

            var size = packet.ReadInt32("Size");
            var data = packet.ReadBytes(size);
            var db2File = new Packet(data, packet.Opcode, packet.Time, packet.Direction, packet.Number, packet.Writer,
                packet.FileName);

            if (entry < 0 || !allow)
            {
                packet.WriteLine("Row {0} has been removed.", -entry);
                HotfixStoreMgr.RemoveRecord(type, entry);
                Storage.AddHotfixData(entry, type, true, timeStamp);
            }
            else
            {
                packet.AddSniffData(StoreNameType.None, entry, type.ToString());
                HotfixStoreMgr.AddRecord(type, entry, db2File);
                Storage.AddHotfixData(entry, type, false, timeStamp);
                db2File.ClosePacket(false);
            }
        }
Exemplo n.º 8
0
        public static void HandleGuildFinderPostUpdated(Packet packet)
        {
            var b = packet.ReadBit("Unk Bit"); // Can set settings ?

            if (b != 0)
            {
                var length = packet.ReadBits(11);
                packet.ReadBit("Listed");
                // Flush bits
                packet.ReadUInt32E<GuildFinderOptionsLevel>("Level");
                packet.ReadWoWString("Comment", length);
                packet.ReadInt32("Unk Int32");
                packet.ReadUInt32E<GuildFinderOptionsAvailability>("Availability");
                packet.ReadUInt32E<GuildFinderOptionsRoles>("Class Roles");
                packet.ReadUInt32E<GuildFinderOptionsInterest>("Guild Interests");
            }
        }
Exemplo n.º 9
0
        public static void HandleHotfixNotify(Packet packet)
        {
            var tableHash = packet.ReadUInt32E<DB2Hash>("TableHash");
            var recordID = packet.ReadInt32("RecordID");
            var timeStamp = packet.ReadUInt32();
            packet.AddValue("Timestamp", Utilities.GetDateTimeFromUnixTime(timeStamp));

            Storage.AddHotfixData(recordID, tableHash, false, timeStamp);
        }
Exemplo n.º 10
0
 public static void HandleInitializeFactions(Packet packet)
 {
     var count = packet.ReadInt32("Count");
     for (var i = 0; i < count; i++)
     {
         packet.ReadByteE<FactionFlag>("Faction Flags", i);
         packet.ReadUInt32E<ReputationRank>("Faction Standing", i);
     }
 }
Exemplo n.º 11
0
        public static void HandleAuctionCommandResult(Packet packet)
        {
            var unk32 = !packet.ReadBit("!unk32"); // 32
            var unk16 = !packet.ReadBit("!unk16"); // 16
            var unk24 = !packet.ReadBit("!unk24"); // 24
            var guid = packet.StartBitStream(1, 4, 0, 6, 3, 5, 2, 7);
            packet.ParseBitStream(guid, 3, 0, 7, 1, 4, 6, 5, 2);
            if (unk16)
                packet.ReadInt64("unk16"); // 16
            var error = packet.ReadUInt32E<AuctionHouseError>("Error"); // 44
            var action = packet.ReadUInt32E<AuctionHouseAction>("Action"); // 48

            packet.ReadUInt32("Auction ID"); // 52
            if (unk32)
                packet.ReadInt64("unk32"); // 32
            packet.ReadInt32("unk40"); // 40  =40 if bag

            packet.WriteGuid("Guid", guid);
        }
Exemplo n.º 12
0
        public static void HandleGameObjectQueryResponse(Packet packet)
        {
            var entry = packet.ReadEntry("Entry");
            if (entry.Value) // entry is masked
                return;

            GameObjectTemplate gameObject = new GameObjectTemplate
            {
                Entry = (uint)entry.Key
            };

            int unk1 = packet.ReadInt32("Unk1 UInt32");
            if (unk1 == 0)
            {
                packet.ReadByte("Unk1 Byte");
                return;
            }

            gameObject.Type = packet.ReadInt32E<GameObjectType>("Type");
            gameObject.DisplayID = packet.ReadUInt32("Display ID");

            var name = new string[4];
            for (int i = 0; i < 4; i++)
                name[i] = packet.ReadCString("Name", i);
            gameObject.Name = name[0];

            gameObject.IconName = packet.ReadCString("Icon Name");
            gameObject.CastCaption = packet.ReadCString("Cast Caption");
            gameObject.UnkString = packet.ReadCString("Unk String");

            gameObject.Data = new int?[32];
            for (int i = 0; i < gameObject.Data.Length; i++)
                gameObject.Data[i] = packet.ReadInt32("Data", i);

            gameObject.Size = packet.ReadSingle("Size");

            gameObject.QuestItems = new uint?[packet.ReadByte("QuestItems Length")];

            for (int i = 0; i < gameObject.QuestItems.Length; i++)
                gameObject.QuestItems[i] = (uint)packet.ReadInt32<ItemId>("Quest Item", i);

            packet.ReadUInt32E<ClientType>("Expansion");

            packet.ReadByte("Unk1 Byte");

            Storage.GameObjectTemplates.Add(gameObject, packet.TimeSpan);

            ObjectName objectName = new ObjectName
            {
                ObjectType = ObjectType.GameObject,
                ID = entry.Key,
                Name = gameObject.Name
            };
            Storage.ObjectNames.Add(objectName, packet.TimeSpan);
        }
Exemplo n.º 13
0
        public static void HandleInitializeFactions(Packet packet)
        {
            for (var i = 0; i < 0x100; i++)
            {
                packet.ReadByteE<FactionFlag>("FactionFlags", i);
                packet.ReadUInt32E<ReputationRank>("FactionStandings", i);
            }

            for (var i = 0; i < 0x100; i++)
                packet.ReadBit("FactionHasBonus", i);
        }
Exemplo n.º 14
0
        public static void HandleHotfixNotifyBlob(Packet packet)
        {
            var count = packet.ReadUInt32("HotfixCount");

            for (var i = 0; i < count; ++i)
            {
                var tableHash = packet.ReadUInt32E<DB2Hash>("TableHash", i);
                var recordID = packet.ReadInt32("RecordID", i);
                var timestamp = packet.ReadUInt32("Timestamp", i);
                Storage.AddHotfixData(recordID, tableHash, false, timestamp);
            }
        }
Exemplo n.º 15
0
        public static void HandleInitializeFactions(Packet packet)
        {
            for (var i = 0; i < 256; i++)
            {
                packet.ReadUInt32E<ReputationRank>("Faction Standing", i);
                packet.ReadByteE<FactionFlag>("Faction Flags", i);
            }

            for (var i = 0; i < 256; i++)
            {
                var bit1296 = packet.ReadBit("Count");
            }
        }
Exemplo n.º 16
0
        public static void HandleAuctionCommandResult(Packet packet)
        {
            packet.ReadUInt32("Auction ID");
            var action = packet.ReadUInt32E<AuctionHouseAction>("Action");
            var error = packet.ReadUInt32E<AuctionHouseError>("Error");

            if (error == AuctionHouseError.Inventory)
                packet.ReadUInt32E<InventoryResult>("Equip Error");

            switch (error)
            {
                case AuctionHouseError.Ok:
                    if (action == AuctionHouseAction.Bid)
                        packet.ReadValue("Diff", _auctionSize);
                    break;
                case AuctionHouseError.HigherBid:
                    packet.ReadGuid("Bidder");
                    packet.ReadValue("Bid", _auctionSize);
                    packet.ReadValue("Diff", _auctionSize);
                    break;
            }
        }
Exemplo n.º 17
0
        public static void HandleGossipPoi(Packet packet)
        {
            PointsOfInterest gossipPOI = new PointsOfInterest();
            gossipPOI.ID = ++LastGossipPOIEntry;

            gossipPOI.Flags = (uint)packet.ReadInt32E<UnknownFlags>("Flags");
            var pos = packet.ReadVector2("Coordinates");
            gossipPOI.Icon = packet.ReadUInt32E<GossipPOIIcon>("Icon");
            gossipPOI.Importance = packet.ReadUInt32("Importance");
            gossipPOI.Name = packet.ReadCString("Icon Name");

            gossipPOI.PositionX = pos.X;
            gossipPOI.PositionY = pos.Y;

            Storage.GossipPOIs.Add(gossipPOI, packet.TimeSpan);
        }
Exemplo n.º 18
0
        public static void HandleGossipPoi(Packet packet)
        {
            ++LastGossipPOIEntry;

            var gossipPOI = new GossipPOI {Flags = packet.ReadBits("Flags", 14)};

            var bit84 = packet.ReadBits(6);
            var pos = packet.ReadVector2("Coordinates");
            gossipPOI.Icon = packet.ReadUInt32E<GossipPOIIcon>("Icon");
            gossipPOI.Importance = packet.ReadUInt32("Importance");
            gossipPOI.Name = packet.ReadWoWString("Name", bit84);

            gossipPOI.PositionX = pos.X;
            gossipPOI.PositionY = pos.Y;

            Storage.GossipPOIs.Add(LastGossipPOIEntry, gossipPOI, packet.TimeSpan);
        }
Exemplo n.º 19
0
        public static void HandleGossipPoi(Packet packet)
        {
            PointsOfInterest gossipPOI = new PointsOfInterest();
            gossipPOI.ID = ++LastGossipPOIEntry;

            gossipPOI.Flags = packet.ReadBits("Flags", 14);
            uint bit84 = packet.ReadBits(6);

            Vector2 pos = packet.ReadVector2("Coordinates");
            gossipPOI.PositionX = pos.X;
            gossipPOI.PositionY = pos.Y;

            gossipPOI.Icon = packet.ReadUInt32E<GossipPOIIcon>("Icon");
            gossipPOI.Importance = packet.ReadUInt32("Importance");
            gossipPOI.Name = packet.ReadWoWString("Name", bit84);

            Storage.GossipPOIs.Add(gossipPOI, packet.TimeSpan);
        }
Exemplo n.º 20
0
        public static void HandleGossipPoi(Packet packet)
        {
            LastGossipPOIEntry++;

            var gossipPOI = new GossipPOI
            {
                Flags = (uint) packet.ReadInt32E<UnknownFlags>("Flags")
            };

            var pos = packet.ReadVector2("Coordinates");
            gossipPOI.Icon = packet.ReadUInt32E<GossipPOIIcon>("Icon");
            gossipPOI.Importance = packet.ReadUInt32("Data");
            gossipPOI.Name = packet.ReadCString("Icon Name");

            gossipPOI.PositionX = pos.X;
            gossipPOI.PositionY = pos.Y;

            Storage.GossipPOIs.Add(LastGossipPOIEntry, gossipPOI, packet.TimeSpan);
        }
Exemplo n.º 21
0
 public static void HandleTradeStatus(Packet packet)
 {
     var status = packet.ReadUInt32E<TradeStatus>("Status");
     switch (status)
     {
         case TradeStatus.BeginTrade:
             packet.ReadGuid("GUID");
             break;
         case TradeStatus.OpenWindow:
             packet.ReadUInt32("Trade Id");
             break;
         case TradeStatus.CloseWindow:
             packet.ReadUInt32("Unk UInt32 1");
             packet.ReadByte("Unk Byte");
             packet.ReadUInt32("Unk UInt32 2");
             break;
         case TradeStatus.OnlyConjured:
         case TradeStatus.NotEligible:
             packet.ReadByte("Unk Byte");
             break;
     }
 }
Exemplo n.º 22
0
        public static void HandleSpellStart(Packet packet)
        {
            var guid1 = new byte[8];
            var guid2 = new byte[8];
            var guid3 = new byte[8];
            var guid4 = new byte[8];
            var guid5 = new byte[8];
            byte[][] guid6;
            byte[][] guid7;
            var guid8 = new byte[8];
            var guid9 = new byte[8];
            var powerGUID = new byte[8];
            byte[][] guid11;

            packet.ReadBit(); // fake bit

            guid1[4] = packet.ReadBit();

            var bit198 = !packet.ReadBit();
            var bit170 = !packet.ReadBit();
            var bit168 = !packet.ReadBit();

            packet.ReadBit(); // fake bit

            guid2[7] = packet.ReadBit();

            packet.StartBitStream(guid3, 2, 5, 6, 1, 0, 3, 7, 4);

            guid1[1] = packet.ReadBit();

            var bit151 = !packet.ReadBit();

            packet.StartBitStream(guid4, 7, 0, 1, 3, 4, 2, 5, 6);

            guid2[2] = packet.ReadBit();

            var hasTargetFlags = !packet.ReadBit();
            var bit180 = !packet.ReadBit();

            guid1[5] = packet.ReadBit();

            var bit1AC = !packet.ReadBit();
            var bits140 = (int)packet.ReadBits(21);
            var bit16C = !packet.ReadBit();
            var bits2C = (int)packet.ReadBits("bits2C", 13);
            var bit17C = packet.ReadBit();
            var bit98 = packet.ReadBit();

            guid2[3] = packet.ReadBit();

            var counter2 = packet.ReadBits(20);

            guid2[1] = packet.ReadBit();
            guid1[0] = packet.ReadBit();

            packet.StartBitStream(guid2, 6, 5);

            var bit194 = !packet.ReadBit();
            var counter1 = packet.ReadBits(24);

            guid1[3] = packet.ReadBit();

            var bit1A8 = !packet.ReadBit();
            var bitC0 = !packet.ReadBit();

            if (hasTargetFlags)
                packet.ReadBitsE<TargetFlag>("Target Flags", 20);

            guid1[2] = packet.ReadBit();

            if (bit98)
                packet.StartBitStream(guid5, 2, 4, 6, 3, 7, 5, 1, 0);

            guid6 = new byte[counter1][];
            for (var i = 0; i < counter1; ++i)
            {
                guid6[i] = new byte[8];
                packet.StartBitStream(guid6[i], 6, 7, 0, 2, 5, 4, 1, 3);
            }

            var bitB8 = packet.ReadBit();

            packet.ReadBit(); // fake bit

            guid7 = new byte[counter2][];
            for (var i = 0; i < counter2; ++i)
            {
                guid7[i] = new byte[8];
                packet.StartBitStream(guid7[i], 0, 4, 3, 1, 6, 7, 2, 5);
            }

            packet.StartBitStream(guid8, 4, 6, 7, 0, 1, 2, 3, 5);

            var bit164 = !packet.ReadBit();
            if (bitB8)
                packet.StartBitStream(guid9, 4, 1, 7, 3, 0, 5, 6, 2);

            var hasPowerData = packet.ReadBit();
            var counter3 = packet.ReadBits(24);

            var PowerTypeCount = 0u;
            if (hasPowerData)
            {
                packet.StartBitStream(powerGUID, 7, 4, 0, 6);
                PowerTypeCount = packet.ReadBits(21);
                packet.StartBitStream(powerGUID, 5, 2, 3, 1);
            }

            guid11 = new byte[counter3][];
            for (var i = 0; i < counter3; ++i)
            {
                guid11[i] = new byte[8];
                packet.StartBitStream(guid11[i], 4, 0, 2, 7, 6, 1, 3, 5);
            }

            packet.StartBitStream(guid2, 0, 4);

            guid1[6] = packet.ReadBit();

            var bits154 = packet.ReadBits(3);
            var bit150 = !packet.ReadBit();
            guid1[7] = packet.ReadBit();
            var counter4 = packet.ReadBits(25);

            var bitsC0 = 0u;
            if (bitC0)
                bitsC0 = packet.ReadBits(7);

            for (var i = 0; i < counter4; ++i)
            {
                if (packet.ReadBits("bits22[0]", 4, i) == 11)
                    packet.ReadBits("bits22[1]", 4, i);
            }

            packet.ReadXORByte(guid1, 7);

            if (hasPowerData)
            {
                packet.ReadXORByte(powerGUID, 3);
                packet.ReadXORByte(powerGUID, 5);
                packet.ReadXORByte(powerGUID, 1);
                packet.ReadXORByte(powerGUID, 4);

                for (var i = 0; i < PowerTypeCount; ++i)
                {
                    packet.ReadUInt32E<PowerType>("Power Type", i);
                    packet.ReadInt32("Power Value", i);
                }

                packet.ReadXORByte(powerGUID, 6);
                packet.ReadXORByte(powerGUID, 2);
                packet.ReadInt32("Current Health");
                packet.ReadInt32("Attack power");
                packet.ReadInt32("Spell power");
                packet.ReadXORByte(powerGUID, 7);
                packet.ReadXORByte(powerGUID, 0);

                packet.WriteGuid("Power GUID", powerGUID);
            }

            packet.ParseBitStream(guid8, 5, 3, 2, 7, 4, 0, 6, 1);

            for (var i = 0; i < counter1; ++i)
            {
                packet.ParseBitStream(guid6[i], 7, 1, 0, 4, 2, 5, 6, 3);
                packet.WriteGuid("Guid6", guid6[i], i);
            }

            if (bit98)
            {
                packet.ReadXORByte(guid5, 2);
                packet.ReadXORByte(guid5, 6);
                packet.ReadXORByte(guid5, 0);
                packet.ReadXORByte(guid5, 3);
                packet.ReadXORByte(guid5, 4);

                packet.ReadSingle("Float8C");
                packet.ReadSingle("Float88");
                packet.ReadSingle("Float90");

                packet.ReadXORByte(guid5, 7);
                packet.ReadXORByte(guid5, 5);
                packet.ReadXORByte(guid5, 1);

                packet.WriteGuid("Guid10", guid5);
            }

            packet.ParseBitStream(guid4, 0, 6, 5, 7, 3, 2, 4, 1);
            packet.ReadXORByte(guid2, 3);

            for (var i = 0; i < counter3; ++i)
            {
                packet.ParseBitStream(guid11[i], 6, 0, 7, 1, 2, 5, 3, 4);

                packet.WriteGuid("Guid12", guid11[i], i);
            }

            if (bit168)
                packet.ReadSingle("Float168");

            packet.ParseBitStream(guid3, 3, 1, 5, 0, 7, 6, 4, 2);

            packet.ReadXORByte(guid1, 3);

            if (bit1AC)
                packet.ReadByte("Byte1AC");

            packet.ReadXORByte(guid2, 4);

            if (bit198)
                packet.ReadInt32("Int198");

            if (bit151)
                packet.ReadByte("Byte151");

            packet.ReadXORByte(guid2, 0);
            packet.ReadXORByte(guid1, 4);

            if (bitB8)
            {
                packet.ReadSingle("FloatB0");

                packet.ReadXORByte(guid9, 4);

                packet.ReadSingle("FloatAC");
                packet.ReadSingle("FloatA8");

                packet.ReadXORByte(guid9, 7);
                packet.ReadXORByte(guid9, 3);
                packet.ReadXORByte(guid9, 2);
                packet.ReadXORByte(guid9, 1);
                packet.ReadXORByte(guid9, 6);
                packet.ReadXORByte(guid9, 0);
                packet.ReadXORByte(guid9, 5);

                packet.WriteGuid("Guid9", guid9);
            }

            packet.ReadXORByte(guid2, 2);
            packet.ReadXORByte(guid1, 6);

            if (bit150)
                packet.ReadByte("Byte150");

            packet.ReadXORByte(guid1, 1);

            packet.ReadInt32("Int30");

            for (var i = 0; i < counter2; ++i)
            {
                packet.ReadXORByte(guid7[i], 2);

                packet.ReadSingle("Float188", i);

                packet.ReadXORByte(guid7[i], 6);

                packet.ReadSingle("Float188", i);
                packet.ReadSingle("Float188", i);

                packet.ReadXORByte(guid7[i], 4);
                packet.ReadXORByte(guid7[i], 1);
                packet.ReadXORByte(guid7[i], 3);
                packet.ReadXORByte(guid7[i], 0);
                packet.ReadXORByte(guid7[i], 7);
                packet.ReadXORByte(guid7[i], 5);

                packet.WriteGuid("Guid7", guid7[i], i);
            }

            if (bit17C)
            {
                packet.ReadInt32("Int178");
                packet.ReadInt32("Int174");
            }

            packet.ReadInt32<SpellId>("Spell ID");

            if (bit16C)
                packet.ReadInt32("Int16C");

            packet.ReadXORByte(guid2, 6);

            if (bit1A8)
                packet.ReadInt32("Int1A8");

            for (var i = 0; i < bits140; ++i)
            {
                packet.ReadByteE<PowerType>("Power type", i);
                packet.ReadInt32("Value", i);
            }

            for (var i = 0; i < bits154; ++i)
                packet.ReadByte("Byte158", i);

            packet.ReadWoWString("StringC0", bitsC0);

            packet.ReadXORByte(guid2, 1);

            if (bit170)
                packet.ReadByte("Byte170");

            if (bit164)
                packet.ReadInt32("Int164");

            if (bit180)
                packet.ReadByte("Byte180");

            packet.ReadInt32("Int28");
            packet.ReadXORByte(guid1, 5);

            if (bit194)
                packet.ReadInt32("Int194");

            packet.ReadXORByte(guid1, 0);
            packet.ReadXORByte(guid2, 7);
            packet.ReadXORByte(guid2, 5);
            packet.ReadXORByte(guid1, 2);

            packet.ReadByte("Byte20");

            packet.WriteGuid("Guid1", guid1);
            packet.WriteGuid("Guid3", guid3);
            packet.WriteGuid("Guid4", guid4);
            packet.WriteGuid("Guid5", guid2);
        }
Exemplo n.º 23
0
        public static void HandleSpellGo(Packet packet)
        {
            var guid1 = new byte[8];
            var guid2 = new byte[8];
            var guid3 = new byte[8];
            var guid4 = new byte[8];
            var guid5 = new byte[8];
            byte[][] guid6;
            byte[][] guid7;
            var guid8 = new byte[8];
            var powerGUID = new byte[8];
            byte[][] guid10;
            var guid11 = new byte[8];

            var bitE8 = packet.ReadBit();
            packet.StartBitStream(guid1, 6, 7);

            packet.ReadBit(); // fake bit

            packet.StartBitStream(guid2, 2, 6, 0, 3, 4, 1, 7, 5);

            guid3[4] = packet.ReadBit();
            guid1[1] = packet.ReadBit();
            guid3[2] = packet.ReadBit();
            var counter1 = (int)packet.ReadBits(24);
            guid1[0] = packet.ReadBit();
            var counter2 = (int)packet.ReadBits(24);
            guid3[5] = packet.ReadBit();

            if (bitE8)
                packet.StartBitStream(guid4, 4, 7, 5, 3, 6, 2, 1, 0);

            packet.ReadBit(); // fake bit

            packet.StartBitStream(guid5, 5, 3, 4, 6, 7, 1, 2, 0);

            var bitF0 = !packet.ReadBit();
            var bit19C = !packet.ReadBit();
            var bit180 = !packet.ReadBit();
            var bit1D8 = !packet.ReadBit();

            guid3[7] = packet.ReadBit();

            guid6 = new byte[counter2][];
            for (var i = 0; i < counter2; ++i)
            {
                guid6[i] = new byte[8];
                packet.StartBitStream(guid6[i], 5, 3, 1, 4, 6, 0, 2, 7);
            }

            guid7 = new byte[counter1][];
            for (var i = 0; i < counter1; ++i)
            {
                guid7[i] = new byte[8];
                packet.StartBitStream(guid7[i], 0, 2, 7, 4, 6, 3, 5, 1);
            }

            var hasTargetMask = !packet.ReadBit();
            var bit1C8 = !packet.ReadBit();

            var counter3 = packet.ReadBits(21);

            var hasPowerData = packet.ReadBit();
            var bitC8 = packet.ReadBit();
            var bit1A0 = !packet.ReadBit();

            if (bitC8)
                packet.StartBitStream(guid8, 4, 7, 6, 3, 2, 0, 5, 1);

            var bit181 = !packet.ReadBit();
            var bit1DC = !packet.ReadBit();

            guid1[4] = packet.ReadBit();

            var powerCount = 0u;
            if (hasPowerData)
            {
                powerGUID[4] = packet.ReadBit();
                powerCount = packet.ReadBits(21);
                packet.StartBitStream(powerGUID, 2, 3, 7, 6, 5, 0, 1);
            }

            var bit198 = !packet.ReadBit();
            var bit194 = !packet.ReadBit();

            if (hasTargetMask)
                packet.ReadBitsE<TargetFlag>("Target Flags", 20);

            var bits5C = packet.ReadBits(13);
            guid1[3] = packet.ReadBit();
            var bits184 = packet.ReadBits(3);

            packet.ReadBit(); // fake bit

            guid1[2] = packet.ReadBit();
            var bit1B0 = !packet.ReadBit();
            guid3[3] = packet.ReadBit();
            var counter4 = (int)packet.ReadBits(20);

            guid10 = new byte[counter4][];
            for (var i = 0; i < counter4; ++i)
            {
                guid10[i] = new byte[8];
                packet.StartBitStream(guid10[i], 5, 1, 4, 7, 3, 6, 0, 2);
            }

            packet.StartBitStream(guid11, 4, 1, 5, 2, 7, 6, 0, 3);

            guid3[1] = packet.ReadBit();
            guid1[5] = packet.ReadBit();
            guid3[6] = packet.ReadBit();

            var counter5 = packet.ReadBits(25);

            guid3[0] = packet.ReadBit();

            var bitsF0 = 0u;
            if (bitF0)
                bitsF0 = packet.ReadBits(7);

            var bit1C4 = !packet.ReadBit();
            var bit1AC = packet.ReadBit();

            for (var i = 0; i < counter5; ++i)
            {
                var bits136 = packet.ReadBits(4);

                if (bits136 == 11)
                    packet.ReadBits("bits140", 4, i);
            }

            packet.ParseBitStream(guid11, 5, 3, 4, 2, 0, 1, 7, 6);

            packet.ReadXORByte(guid1, 2);

            packet.ReadInt32("Int60");

            for (var i = 0; i < counter1; ++i)
            {
                packet.ParseBitStream(guid7[i], 3, 6, 7, 5, 0, 4, 2, 1);
                packet.WriteGuid("Guid7", guid7[i], i);
            }

            packet.ReadXORByte(guid1, 6);

            for (var i = 0; i < counter2; ++i)
            {
                packet.ParseBitStream(guid6[i], 6, 0, 3, 7, 2, 1, 5, 4);
                packet.WriteGuid("Guid7", guid7[i], i);
            }

            packet.ReadXORByte(guid3, 0);

            if (bitC8)
            {
                packet.ReadXORByte(guid8, 6);
                packet.ReadXORByte(guid8, 7);
                packet.ReadXORByte(guid8, 3);
                packet.ReadXORByte(guid8, 0);

                packet.ReadSingle("FloatBC");

                packet.ReadXORByte(guid8, 1);

                packet.ReadSingle("FloatC0");

                packet.ReadXORByte(guid8, 4);
                packet.ReadXORByte(guid8, 2);

                packet.ReadSingle("FloatB8");

                packet.ReadXORByte(guid8, 5);

                packet.WriteGuid("guidG", guid8);
            }

            if (bit19C)
                packet.ReadInt32("Int19C");

            if (bitE8)
            {
                var pos = new Vector3();

                packet.ReadXORByte(guid4, 5);
                packet.ReadXORByte(guid4, 1);
                packet.ReadXORByte(guid4, 6);
                packet.ReadXORByte(guid4, 0);
                packet.ReadXORByte(guid4, 3);
                packet.ReadXORByte(guid4, 4);

                pos.X = packet.ReadSingle("FloatD8");

                packet.ReadXORByte(guid4, 2);

                pos.Y = packet.ReadSingle("FloatDC");
                pos.Z = packet.ReadSingle("FloatE0");

                packet.ReadXORByte(guid4, 7);

                packet.WriteGuid("Guid4", guid4);
                packet.AddValue("Position", pos);
            }

            if (bit1B0)
                packet.ReadByte("Byte1B0");

            packet.ReadXORByte(guid1, 5);
            packet.ReadXORByte(guid1, 7);

            packet.ParseBitStream(guid5, 1, 7, 3, 0, 6, 2, 4, 5);

            if (bit1AC)
            {
                packet.ReadInt32("Int1A8");
                packet.ReadInt32("Int1A4");
            }

            packet.ReadXORByte(guid1, 4);

            for (var i = 0; i < counter4; ++i)
            {
                packet.ReadXORByte(guid10[i], 4);
                packet.ReadXORByte(guid10[i], 5);

                packet.ReadSingle("Float1B8", i);

                packet.ReadXORByte(guid10[i], 0);
                packet.ReadXORByte(guid10[i], 1);
                packet.ReadXORByte(guid10[i], 2);
                packet.ReadXORByte(guid10[i], 3);

                packet.ReadSingle("Float1B8", i);
                packet.ReadSingle("Float1B8", i);

                packet.ReadXORByte(guid10[i], 6);
                packet.ReadXORByte(guid10[i], 7);

                packet.WriteGuid("Guid10", guid10[i], i);
            }

            if (hasPowerData)
            {
                packet.ReadInt32("Spell power");
                packet.ReadInt32("Attack power");

                for (var i = 0; i < powerCount; ++i)
                {
                    packet.ReadUInt32E<PowerType>("Power Type", i);
                    packet.ReadInt32("Power Value", i);
                }

                packet.ParseBitStream(powerGUID, 4, 7, 0, 2, 3, 5, 6, 1);

                packet.ReadInt32("Current Health");
                packet.WriteGuid("Power GUID", powerGUID);
            }

            packet.ReadXORByte(guid3, 6);
            packet.ReadXORByte(guid1, 3);

            if (bit180)
                packet.ReadByte("Byte180");

            packet.ParseBitStream(guid2, 3, 2, 1, 4, 6, 0, 7, 5);
            packet.ReadXORByte(guid3, 3);

            for (var i = 0; i < bits184; ++i)
                packet.ReadByte("Byte188", i);

            packet.ReadWoWString("StringF0", bitsF0);
            packet.ReadByte("Cast Count");

            if (bit1C4)
                packet.ReadInt32("Int1C4");

            packet.ReadXORByte(guid3, 7);

            if (bit1D8)
                packet.ReadInt32("Int1D8");

            if (bit198)
                packet.ReadSingle("Float198");

            packet.ReadInt32E<CastFlag>("Cast Flags");

            packet.ReadXORByte(guid3, 4);
            packet.ReadXORByte(guid3, 1);

            packet.ReadInt32<SpellId>("Spell ID");

            if (bit1DC)
                packet.ReadByte("Byte1DC");

            for (var i = 0; i < counter3; ++i)
            {
                packet.ReadByte("ByteED", i);
                packet.ReadInt32("IntED", i);
            }

            packet.ReadXORByte(guid1, 0);

            if (bit1A0)
                packet.ReadByte("Byte1A0");

            if (bit181)
                packet.ReadByte("Byte181");

            if (bit194)
                packet.ReadInt32("Int194");

            packet.ReadXORByte(guid1, 1);

            if (bit1C8)
                packet.ReadInt32("Int1C8");

            packet.ReadXORByte(guid3, 5);
            packet.ReadXORByte(guid3, 2);

            packet.WriteGuid("Guid8", guid1);
            packet.WriteGuid("Guid9", guid3);
            packet.WriteGuid("Guid2", guid2);
            packet.WriteGuid("Guid11", guid11);
            packet.WriteGuid("Guid5", guid5);
        }
Exemplo n.º 24
0
        public static void HandleUnknow5410(Packet packet)
        {
            var guid1 = new byte[8];
            var powerGUID = new byte[8];
            var guid3 = new byte[8];

            guid1[2] = packet.ReadBit();
            packet.StartBitStream(guid3, 2, 1);
            var bit20 = packet.ReadBit();
            packet.StartBitStream(guid1, 0, 5);
            var bit6C = packet.ReadBit();
            packet.StartBitStream(guid3, 7, 5);
            guid1[7] = packet.ReadBit();
            packet.StartBitStream(guid3, 0, 4);
            guid1[1] = packet.ReadBit();
            guid3[3] = packet.ReadBit();
            guid1[3] = packet.ReadBit();
            guid3[6] = packet.ReadBit();

            var hasPowerData = packet.ReadBit();
            var counter = packet.ReadBits(22);

            var powerCount = 0u;
            if (hasPowerData)
            {
                packet.StartBitStream(powerGUID, 2, 5, 7, 6);
                powerCount = packet.ReadBits(21);
                packet.StartBitStream(powerGUID, 4, 3, 0, 1);
            }

            guid1[6] = packet.ReadBit();
            guid1[4] = packet.ReadBit();

            var bitC = new bool[counter];
            var bit14 = new bool[counter];
            for (var i = 0; i < counter; ++i)
            {
                bitC[i] = packet.ReadBit();
                bit14[i] = packet.ReadBit();
                packet.ReadBit();
            }

            for (var i = 0; i < counter; ++i)
            {
                if (bitC[i])
                    packet.ReadInt32("IntC", i);

                if (bit14[i])
                    packet.ReadInt32("Int14", i);

                packet.ReadInt32<SpellId>("Spell ID", i);
            }

            if (hasPowerData)
            {
                packet.ReadXORByte(powerGUID, 3);
                packet.ReadInt32("Spell power");
                packet.ReadInt32("Current Health");
                packet.ReadXORByte(powerGUID, 6);
                packet.ReadXORByte(powerGUID, 7);

                for (var i = 0; i < powerCount; ++i)
                {
                    packet.ReadInt32("Power Value", i);
                    packet.ReadUInt32E<PowerType>("Power Type", i);
                }

                packet.ReadInt32("Attack power");
                packet.ReadXORByte(powerGUID, 2);
                packet.ReadXORByte(powerGUID, 4);
                packet.ReadXORByte(powerGUID, 1);
                packet.ReadXORByte(powerGUID, 5);
                packet.ReadXORByte(powerGUID, 0);

                packet.WriteGuid("Power GUID", powerGUID);
            }

            packet.ReadInt32("Int68");
            packet.ReadXORByte(guid3, 0);
            packet.ReadXORByte(guid1, 5);
            packet.ReadXORByte(guid1, 6);
            packet.ReadXORByte(guid1, 4);
            packet.ReadXORByte(guid3, 3);
            packet.ReadXORByte(guid1, 3);
            packet.ReadXORByte(guid3, 4);
            packet.ReadXORByte(guid3, 5);
            packet.ReadXORByte(guid3, 7);
            packet.ReadXORByte(guid1, 2);
            packet.ReadXORByte(guid3, 2);
            packet.ReadXORByte(guid1, 0);
            packet.ReadXORByte(guid3, 1);
            packet.ReadXORByte(guid3, 6);
            packet.ReadXORByte(guid1, 1);
            packet.ReadXORByte(guid1, 7);

            packet.WriteGuid("Guid1", guid1);
            packet.WriteGuid("Guid2", guid3);
        }
Exemplo n.º 25
0
        public static void ReadLFGRoleCheckUpdateMember(Packet packet, params object[] idx)
        {
            packet.ReadPackedGuid128("Guid", idx);
            packet.ReadUInt32E<LfgRoleFlag>("RolesDesired", idx);
            packet.ReadByte("Level", idx);
            packet.ReadBit("RoleCheckComplete", idx);

            packet.ResetBitReader();
        }
Exemplo n.º 26
0
 public static void HandleRoleChosen(Packet packet)
 {
     packet.ReadPackedGuid128("Player");
     packet.ReadUInt32E<LfgRoleFlag>("RoleMask");
     packet.ReadBit("Accepted");
 }
Exemplo n.º 27
0
        public static void HandleCreatureQueryResponse(Packet packet)
        {
            var entry = packet.ReadEntry("Entry");

            CreatureTemplate creature = new CreatureTemplate
            {
                Entry = (uint)entry.Key
            };

            Bit hasData = packet.ReadBit();
            if (!hasData)
                return; // nothing to do

            packet.ResetBitReader();
            uint titleLen = packet.ReadBits(11);
            uint titleAltLen = packet.ReadBits(11);
            uint cursorNameLen = packet.ReadBits(6);
            creature.RacialLeader = packet.ReadBit("Leader");

            var stringLens = new int[4][];
            for (int i = 0; i < 4; i++)
            {
                stringLens[i] = new int[2];
                stringLens[i][0] = (int)packet.ReadBits(11);
                stringLens[i][1] = (int)packet.ReadBits(11);
            }

            for (var i = 0; i < 4; ++i)
            {
                if (stringLens[i][0] > 1)
                    creature.Name = packet.ReadCString("Name");
                if (stringLens[i][1] > 1)
                    creature.FemaleName = packet.ReadCString("NameAlt");
            }

            creature.TypeFlags = packet.ReadUInt32E<CreatureTypeFlag>("Type Flags");
            creature.TypeFlags2 = packet.ReadUInt32("Creature Type Flags 2");

            creature.Type = packet.ReadInt32E<CreatureType>("CreatureType");
            creature.Family = packet.ReadInt32E<CreatureFamily>("CreatureFamily");
            creature.Rank = packet.ReadInt32E<CreatureRank>("Classification");

            creature.KillCredits = new uint?[2];
            for (int i = 0; i < 2; ++i)
                creature.KillCredits[i] = packet.ReadUInt32("ProxyCreatureID", i);

            creature.ModelIDs = new uint?[4];
            for (int i = 0; i < 4; ++i)
                creature.ModelIDs[i] = packet.ReadUInt32("CreatureDisplayID", i);

            creature.HealthModifier = packet.ReadSingle("HpMulti");
            creature.ManaModifier = packet.ReadSingle("EnergyMulti");

            //TODO: move to creature_questitems
            //creature.QuestItems = new uint[6];
            int questItems = packet.ReadInt32("QuestItems");
            creature.MovementID = packet.ReadUInt32("CreatureMovementInfoID");
            creature.HealthScalingExpansion = packet.ReadUInt32E<ClientType>("HealthScalingExpansion");
            creature.RequiredExpansion = packet.ReadUInt32E<ClientType>("RequiredExpansion");

            if (titleLen > 1)
                creature.SubName = packet.ReadCString("Title");

            if (titleAltLen > 1)
                packet.ReadCString("TitleAlt");

            if (cursorNameLen > 1)
                creature.IconName = packet.ReadCString("CursorName");

            for (int i = 0; i < questItems; ++i)
                /*creature.QuestItems[i] = (uint)*/packet.ReadInt32<ItemId>("Quest Item", i);

            packet.AddSniffData(StoreNameType.Unit, entry.Key, "QUERY_RESPONSE");

            Storage.CreatureTemplates.Add(creature, packet.TimeSpan);

            ObjectName objectName = new ObjectName
            {
                ObjectType = ObjectType.Unit,
                ID = entry.Key,
                Name = creature.Name
            };
            Storage.ObjectNames.Add(objectName, packet.TimeSpan);
        }
Exemplo n.º 28
0
        public static void HandleNpcGossip(Packet packet)
        {
            var gossip = new Gossip();

            var guidBytes = new byte[8];

            guidBytes[7] = packet.ReadBit();
            guidBytes[6] = packet.ReadBit();
            guidBytes[1] = packet.ReadBit();

            var questgossips = packet.ReadBits(19);

            guidBytes[0] = packet.ReadBit();
            guidBytes[4] = packet.ReadBit();
            guidBytes[5] = packet.ReadBit();
            guidBytes[2] = packet.ReadBit();
            guidBytes[3] = packet.ReadBit();

            var amountOfOptions = packet.ReadBits(20);

            var boxTextLen = new uint[amountOfOptions];
            var optionTextLen = new uint[amountOfOptions];
            for (var i = 0; i < amountOfOptions; ++i)
            {
                boxTextLen[i] = packet.ReadBits(12);
                optionTextLen[i] = packet.ReadBits(12);
            }

            var titleLen = new uint[questgossips];
            for (var i = 0; i < questgossips; ++i)
            {
                packet.ReadBit("Change Icon", i);
                titleLen[i] = packet.ReadBits(9);
            }

            for (var i = 0; i < questgossips; ++i)
            {
                packet.ReadUInt32E<QuestFlags2>("Flags 2", i);
                packet.ReadUInt32<QuestId>("Quest ID", i);
                packet.ReadInt32("Level", i);
                packet.ReadUInt32("Icon", i);
                packet.ReadUInt32E<QuestFlags>("Flags", i);
                packet.ReadWoWString("Title", titleLen[i], i);
            }

            packet.ReadXORByte(guidBytes, 6);

            gossip.GossipOptions = new List<GossipOption>((int)amountOfOptions);
            for (var i = 0; i < amountOfOptions; ++i)
            {
                var gossipOption = new GossipOption
                {
                    RequiredMoney = packet.ReadUInt32("Required money", i),
                    OptionText = packet.ReadWoWString("Text", optionTextLen[i], i),
                    Index = packet.ReadUInt32("Index", i),
                    OptionIcon = packet.ReadByteE<GossipOptionIcon>("Icon", i),
                    BoxText = packet.ReadWoWString("Box Text", boxTextLen[i], i),
                    Box = packet.ReadBool("Box", i)
                };

                gossip.GossipOptions.Add(gossipOption);
            }

            packet.ReadXORByte(guidBytes, 2);

            var textId = packet.ReadUInt32("Text Id");

            packet.ReadXORByte(guidBytes, 1);
            packet.ReadXORByte(guidBytes, 5);

            var menuId = packet.ReadUInt32("Menu Id");
            packet.ReadUInt32("Friendship Faction");

            packet.ReadXORByte(guidBytes, 4);
            packet.ReadXORByte(guidBytes, 7);
            packet.ReadXORByte(guidBytes, 3);
            packet.ReadXORByte(guidBytes, 0);

            packet.WriteGuid("Guid", guidBytes);

            var guid = new WowGuid64(BitConverter.ToUInt64(guidBytes, 0));
            gossip.ObjectType = guid.GetObjectType();
            gossip.ObjectEntry = guid.GetEntry();

            if (guid.GetObjectType() == ObjectType.Unit)
                if (Storage.Objects.ContainsKey(guid))
                    ((Unit)Storage.Objects[guid].Item1).GossipId = menuId;

            if (Storage.Gossips.ContainsKey(Tuple.Create(menuId, textId)))
            {
                var oldGossipOptions = Storage.Gossips[Tuple.Create(menuId, textId)];
                if (oldGossipOptions != null)
                {
                    foreach (var gossipOptions in gossip.GossipOptions)
                        oldGossipOptions.Item1.GossipOptions.Add(gossipOptions);
                }
            }
            else
                Storage.Gossips.Add(Tuple.Create(menuId, textId), gossip, packet.TimeSpan);

            packet.AddSniffData(StoreNameType.Gossip, (int)menuId, guid.GetEntry().ToString(CultureInfo.InvariantCulture));
        }
Exemplo n.º 29
0
        public static void HandleQuestQueryResponse(Packet packet)
        {
            packet.ReadInt32("Entry");

            var hasData = packet.ReadBit("Has Data");
            if (!hasData)
                return; // nothing to do

            var quest = new QuestTemplateWod();

            var id = packet.ReadEntry("Quest ID");
            quest.QuestType = packet.ReadInt32E<QuestMethod>("QuestType");
            quest.QuestLevel = packet.ReadInt32("QuestLevel");
            quest.QuestPackageID = packet.ReadUInt32("QuestPackageID");
            quest.MinLevel = packet.ReadInt32("QuestMinLevel");
            quest.QuestSortID = (QuestSort)packet.ReadUInt32("QuestSortID");
            quest.QuestInfoID = packet.ReadInt32E<QuestType>("QuestInfoID");
            quest.SuggestedGroupNum = packet.ReadUInt32("SuggestedGroupNum");
            quest.RewardNextQuest = packet.ReadUInt32("RewardNextQuest");
            quest.RewardXPDifficulty = packet.ReadUInt32("RewardXPDifficulty");

            quest.RewardXPMultiplier = packet.ReadSingle("RewardXPMultiplier");

            quest.RewardMoney = packet.ReadInt32("RewardMoney");
            quest.RewardMoneyDifficulty = packet.ReadUInt32("RewardMoneyDifficulty");

            quest.RewardMoneyMultiplier = packet.ReadSingle("RewardMoneyMultiplier");

            quest.RewardBonusMoney = packet.ReadUInt32("RewardBonusMoney");
            quest.RewardDisplaySpell = packet.ReadUInt32("RewardDisplaySpell");
            quest.RewardSpell = packet.ReadUInt32("RewardSpell");
            quest.RewardHonor = packet.ReadUInt32("RewardHonor");

            quest.RewardKillHonor = packet.ReadSingle("RewardKillHonor");

            quest.StartItem = packet.ReadUInt32("StartItem");
            quest.Flags = packet.ReadUInt32E<QuestFlags>("Flags");
            quest.FlagsEx = packet.ReadUInt32("FlagsEx");

            quest.RewardItems = new uint[4];
            quest.RewardAmount = new uint[4];
            quest.ItemDrop = new uint[4];
            quest.ItemDropQuantity = new uint[4];
            for (var i = 0; i < 4; ++i)
            {
                quest.RewardItems[i] = packet.ReadUInt32("RewardItems", i);
                quest.RewardAmount[i] = packet.ReadUInt32("RewardAmount", i);
                quest.ItemDrop[i] = packet.ReadUInt32("ItemDrop", i);
                quest.ItemDropQuantity[i] = packet.ReadUInt32("ItemDropQuantity", i);
            }

            quest.RewardChoiceItemID = new uint[6];
            quest.RewardChoiceItemQuantity = new uint[6];
            quest.RewardChoiceItemDisplayID = new uint[6];
            for (var i = 0; i < 6; ++i) // CliQuestInfoChoiceItem
            {
                quest.RewardChoiceItemID[i] = packet.ReadUInt32("RewardChoiceItemID", i);
                quest.RewardChoiceItemQuantity[i] = packet.ReadUInt32("RewardChoiceItemQuantity", i);
                quest.RewardChoiceItemDisplayID[i] = packet.ReadUInt32("RewardChoiceItemDisplayID", i);
            }

            quest.POIContinent = packet.ReadUInt32("POIContinent");

            quest.POIx = packet.ReadSingle("POIx");
            quest.POIy = packet.ReadSingle("POIy");

            quest.POIPriority = packet.ReadInt32("POIPriority");
            quest.RewardTitle = packet.ReadUInt32("RewardTitle");
            quest.RewardTalents = packet.ReadUInt32("RewardTalents");
            quest.RewardArenaPoints = packet.ReadUInt32("RewardArenaPoints");
            quest.RewardSkillLineID = packet.ReadUInt32("RewardSkillLineID");
            quest.RewardNumSkillUps = packet.ReadUInt32("RewardNumSkillUps");
            quest.PortraitGiver = packet.ReadUInt32("PortraitGiver");
            quest.PortraitTurnIn = packet.ReadUInt32("PortraitTurnIn");

            quest.RewardFactionID = new uint[5];
            quest.RewardFactionValue = new int[5];
            quest.RewardFactionOverride = new int[5];
            for (var i = 0; i < 5; ++i)
            {
                quest.RewardFactionID[i] = packet.ReadUInt32("RewardFactionID", i);
                quest.RewardFactionValue[i] = packet.ReadInt32("RewardFactionValue", i);
                quest.RewardFactionOverride[i] = packet.ReadInt32("RewardFactionOverride", i);
            }

            quest.RewardFactionFlags = packet.ReadUInt32("RewardFactionFlags");

            quest.RewardCurrencyID = new uint[4];
            quest.RewardCurrencyQty = new uint[4];
            for (var i = 0; i < 4; ++i)
            {
                quest.RewardCurrencyID[i] = packet.ReadUInt32("RewardCurrencyID");
                quest.RewardCurrencyQty[i] = packet.ReadUInt32("RewardCurrencyQty");
            }

            quest.AcceptedSoundKitID = packet.ReadUInt32("AcceptedSoundKitID");
            quest.CompleteSoundKitID = packet.ReadUInt32("CompleteSoundKitID");
            quest.AreaGroupID = packet.ReadUInt32("AreaGroupID");
            quest.TimeAllowed = packet.ReadUInt32("TimeAllowed");
            var int2946 = packet.ReadUInt32("CliQuestInfoObjective");
            quest.AllowableRaces = packet.ReadInt32("AllowableRaces");

            for (var i = 0; i < int2946; ++i)
            {
                var questInfoObjective = new QuestInfoObjective
                {
                    QuestId = (uint) id.Key
                };

                var objectiveId = packet.ReadEntry("Id", i);
                questInfoObjective.Type = packet.ReadByteE<QuestRequirementType>("Quest Requirement Type", i);
                questInfoObjective.StorageIndex = packet.ReadSByte("StorageIndex", i);
                questInfoObjective.ObjectID = packet.ReadInt32("ObjectID", i);
                questInfoObjective.Amount = packet.ReadInt32("Amount", i);
                questInfoObjective.Flags = packet.ReadUInt32("Flags", i);
                questInfoObjective.UnkFloat = packet.ReadSingle("Float5", i);

                var int280 = packet.ReadInt32("VisualEffects", i);
                questInfoObjective.VisualEffectIds = new List<QuestVisualEffect>(int280);
                for (var j = 0; j < int280; ++j)
                {
                    var questVisualEffect = new QuestVisualEffect
                    {
                        Index = (uint) j,
                        VisualEffect = packet.ReadInt32("VisualEffectId", i, j)
                    };

                    questInfoObjective.VisualEffectIds.Add(questVisualEffect);
                }

                packet.ResetBitReader();

                var bits6 = packet.ReadBits(8);
                questInfoObjective.Description = packet.ReadWoWString("Description", bits6, i);

                if (BinaryPacketReader.GetLocale() != LocaleConstant.enUS && questInfoObjective.Description != string.Empty)
                {
                    var localesQuestObjectives = new LocalesQuestObjectives
                    {
                        QuestId = (uint)id.Key,
                        StorageIndex = questInfoObjective.StorageIndex,
                        Description = questInfoObjective.Description
                    };

                    Storage.LocalesQuestObjectives.Add(Tuple.Create((uint)objectiveId.Key, BinaryPacketReader.GetClientLocale()), localesQuestObjectives, packet.TimeSpan);
                }

                Storage.QuestObjectives.Add((uint)objectiveId.Key, questInfoObjective, packet.TimeSpan);
            }

            packet.ResetBitReader();

            var bits26 = packet.ReadBits(9);
            var bits154 = packet.ReadBits(12);
            var bits904 = packet.ReadBits(12);
            var bits1654 = packet.ReadBits(9);
            var bits1789 = packet.ReadBits(10);
            var bits2045 = packet.ReadBits(8);
            var bits2109 = packet.ReadBits(10);
            var bits2365 = packet.ReadBits(8);
            var bits2429 = packet.ReadBits(11);

            quest.LogTitle = packet.ReadWoWString("LogTitle", bits26);
            quest.LogDescription = packet.ReadWoWString("LogDescription", bits154);
            quest.QuestDescription = packet.ReadWoWString("QuestDescription", bits904);
            quest.AreaDescription = packet.ReadWoWString("AreaDescription", bits1654);
            quest.PortraitGiverText = packet.ReadWoWString("PortraitGiverText", bits1789);
            quest.PortraitGiverName = packet.ReadWoWString("PortraitGiverName", bits2045);
            quest.PortraitTurnInText = packet.ReadWoWString("PortraitTurnInText", bits2109);
            quest.PortraitTurnInName = packet.ReadWoWString("PortraitTurnInName", bits2365);
            quest.QuestCompletionLog = packet.ReadWoWString("QuestCompletionLog", bits2429);

            if (BinaryPacketReader.GetLocale() != LocaleConstant.enUS)
            {
                var localesQuest = new LocalesQuest
                {
                    LogTitle            = quest.LogTitle,
                    LogDescription      = quest.LogDescription,
                    QuestDescription    = quest.QuestDescription,
                    AreaDescription     = quest.AreaDescription,
                    PortraitGiverText   = quest.PortraitGiverText,
                    PortraitGiverName   = quest.PortraitGiverName,
                    PortraitTurnInText  = quest.PortraitTurnInText,
                    PortraitTurnInName  = quest.PortraitTurnInName,
                    QuestCompletionLog  = quest.QuestCompletionLog
                };

                Storage.LocalesQuests.Add(Tuple.Create((uint)id.Key, BinaryPacketReader.GetClientLocale()), localesQuest, packet.TimeSpan);
            }

            Storage.QuestTemplatesWod.Add((uint)id.Key, quest, packet.TimeSpan);
        }
Exemplo n.º 30
0
        public static void HandleQuestGiverInvalidQuest(Packet packet)
        {
            packet.ReadUInt32E<QuestReasonTypeWoD>("Reason");
            packet.ReadBit("SendErrorMessage");

            var len = packet.ReadBits(9);
            packet.ReadWoWString("ReasonText", len);
        }