Example #1
0
 public void UpdateSpellsByMovementPacket(MonsterMovePacket movePacket)
 {
     Parallel.ForEach(castedSpells, spell =>
     {
         spell.Value.SetConeDelayIfNeeded(movePacket);
     });
 }
Example #2
0
        public void AddScriptsForWaypoints(List <WaypointScript> scriptsList, MonsterMovePacket firstMovePacket, MonsterMovePacket lastMovePacket)
        {
            Waypoint waypoint = waypoints.GetLastWaypointWithTime(firstMovePacket.packetSendTime);

            uint id    = (entry * 100) + waypoints.GetPointsWithScriptsCount();
            uint _guid = id + waypoints.GetScriptsCount() == id ? id + waypoints.GetScriptsCount() : id + waypoints.GetScriptsCount() - 1;

            foreach (WaypointScript script in scriptsList)
            {
                int tempDelay = (int)Math.Floor((script.scriptTime.TotalMilliseconds - (firstMovePacket.packetSendTime.TotalMilliseconds + firstMovePacket.moveTime)) / 1000);

                if (script.type == WaypointScript.ScriptType.SetOrientation && tempDelay <= 1)
                {
                    waypoint.SetOrientation(script.o);
                    continue;
                }

                script.SetId(id);
                script.SetDelay(tempDelay < 0 ? 0 : (uint)tempDelay);
                script.SetGuid(_guid);
                _guid++;

                waypoint.scripts.Add(script);
            }

            waypoint.delay = (uint)(lastMovePacket.packetSendTime.TotalMilliseconds - scriptsList.First().scriptTime.TotalMilliseconds);
        }
Example #3
0
        public static WaypointScript GetScriptsFromMovementPacket(MonsterMovePacket movePacket)
        {
            if (movePacket.HasJump())
            {
                return(new WaypointScript(0, 0, ScriptType.Jump, movePacket.jumpInfo.moveTime, 0, 0, movePacket.jumpInfo.jumpPos.x, movePacket.jumpInfo.jumpPos.y, movePacket.jumpInfo.jumpPos.z, movePacket.jumpInfo.jumpGravity, 0, movePacket.packetSendTime));
            }

            return(new WaypointScript(0, 0, ScriptType.SetOrientation, 0, 0, 0, 0.0f, 0.0f, 0.0f, movePacket.creatureOrientation, 0, movePacket.packetSendTime));
        }
Example #4
0
        public void AddWaypointsFromMovementPacket(MonsterMovePacket movePacket)
        {
            foreach (Waypoint wp in movePacket.waypoints)
            {
                waypoints.Add(wp);
            }

            SortWaypoints();
        }
        public bool GetDataFromTxtFile(string fileName, bool multiSelect)
        {
            mainForm.SetCurrentStatus("Getting lines...");

            var lines = File.ReadAllLines(fileName);
            Dictionary <long, Packet.PacketTypes> packetIndexes = new Dictionary <long, Packet.PacketTypes>();
            BuildVersions buildVersion = LineGetters.GetBuildVersion(lines);

            if (!IsTxtFileValidForParse(fileName, lines, buildVersion))
            {
                return(false);
            }

            if (!multiSelect)
            {
                creaturesDict.Clear();
            }

            mainForm.SetCurrentStatus("Searching for packet indexes in lines...");

            Parallel.For(0, lines.Length, index =>
            {
                Packet.PacketTypes packetType = Packet.GetPacketTypeFromLine(lines[index]);

                if (packetType == Packet.PacketTypes.SMSG_UPDATE_OBJECT && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_UPDATE_OBJECT);
                }
                else if (packetType == Packet.PacketTypes.SMSG_AI_REACTION && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_AI_REACTION);
                }
                else if (packetType == Packet.PacketTypes.SMSG_SPELL_START && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_SPELL_START);
                }
                else if (packetType == Packet.PacketTypes.SMSG_CHAT && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_CHAT);
                }
                else if (packetType == Packet.PacketTypes.SMSG_ON_MONSTER_MOVE && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_ON_MONSTER_MOVE);
                }
                else if (packetType == Packet.PacketTypes.SMSG_ATTACK_STOP && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_ATTACK_STOP);
                }
            });

            mainForm.SetCurrentStatus("Parsing SMSG_UPDATE_OBJECT packets...");

            foreach (var value in packetIndexes)
            {
                if (value.Value == Packet.PacketTypes.SMSG_UPDATE_OBJECT)
                {
                    Parallel.ForEach(UpdateObjectPacket.ParseObjectUpdatePacket(lines, value.Key, buildVersion, 0), packet =>
                    {
                        lock (creaturesDict)
                        {
                            if (!creaturesDict.ContainsKey(packet.guid))
                            {
                                creaturesDict.Add(packet.guid, new Creature(packet));
                            }
                            else
                            {
                                creaturesDict[packet.guid].UpdateCreature(packet);
                            }
                        }
                    });
                }
            }

            Parallel.ForEach(creaturesDict.Values, creature =>
            {
                creature.name = MainForm.GetCreatureNameByEntry(creature.entry);
            });

            mainForm.SetCurrentStatus("Parsing SMSG_SPELL_START packets...");

            Parallel.ForEach(packetIndexes, value =>
            {
                if (value.Value == Packet.PacketTypes.SMSG_SPELL_START)
                {
                    SpellStartPacket spellPacket = SpellStartPacket.ParseSpellStartPacket(lines, value.Key, buildVersion, value.Value);
                    if (spellPacket.spellId == 0)
                    {
                        return;
                    }

                    lock (creaturesDict)
                    {
                        if (creaturesDict.ContainsKey(spellPacket.casterGuid))
                        {
                            if (!creaturesDict[spellPacket.casterGuid].castedSpells.ContainsKey(spellPacket.spellId))
                            {
                                creaturesDict[spellPacket.casterGuid].castedSpells.Add(spellPacket.spellId, new Spell(spellPacket));
                            }
                            else
                            {
                                creaturesDict[spellPacket.casterGuid].UpdateSpells(spellPacket);
                            }
                        }
                    }
                }
            });

            mainForm.SetCurrentStatus("Parsing SMSG_AI_REACTION packets...");

            Parallel.ForEach(packetIndexes, value =>
            {
                if (value.Value == Packet.PacketTypes.SMSG_AI_REACTION)
                {
                    AIReactionPacket reactionPacket = AIReactionPacket.ParseAIReactionPacket(lines, value.Key, buildVersion);
                    if (reactionPacket.creatureGuid == "")
                    {
                        return;
                    }

                    lock (creaturesDict)
                    {
                        if (creaturesDict.ContainsKey(reactionPacket.creatureGuid))
                        {
                            if (creaturesDict[reactionPacket.creatureGuid].combatStartTime == TimeSpan.Zero ||
                                creaturesDict[reactionPacket.creatureGuid].combatStartTime < reactionPacket.packetSendTime)
                            {
                                creaturesDict[reactionPacket.creatureGuid].combatStartTime = reactionPacket.packetSendTime;
                            }

                            creaturesDict[reactionPacket.creatureGuid].UpdateCombatSpells(reactionPacket);
                        }
                    }
                }
            });

            mainForm.SetCurrentStatus("Parsing SMSG_CHAT packets...");

            Parallel.ForEach(packetIndexes, value =>
            {
                if (value.Value == Packet.PacketTypes.SMSG_CHAT)
                {
                    ChatPacket chatPacket = ChatPacket.ParseChatPacket(lines, value.Key, buildVersion);
                    if (chatPacket.creatureGuid == "")
                    {
                        return;
                    }

                    lock (creaturesDict)
                    {
                        Parallel.ForEach(creaturesDict, creature =>
                        {
                            if (creature.Value.entry == chatPacket.creatureEntry)
                            {
                                CreatureText text = new CreatureText(chatPacket, true);

                                if (Math.Floor(creature.Value.combatStartTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) ||
                                    Math.Floor(creature.Value.combatStartTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) + 1 ||
                                    Math.Floor(creature.Value.combatStartTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) - 1)
                                {
                                    lock (creatureTextsDict)
                                    {
                                        if (creatureTextsDict.ContainsKey(chatPacket.creatureEntry) && creatureTextsDict[chatPacket.creatureEntry].Count(x => x.creatureText == text.creatureText) == 0)
                                        {
                                            creatureTextsDict[chatPacket.creatureEntry].Add(new CreatureText(chatPacket, true));
                                        }
                                        else if (!creatureTextsDict.ContainsKey(chatPacket.creatureEntry))
                                        {
                                            creatureTextsDict.Add(chatPacket.creatureEntry, new List <CreatureText>());
                                            creatureTextsDict[chatPacket.creatureEntry].Add(new CreatureText(chatPacket, true));
                                        }
                                    }
                                }

                                if (Math.Floor(creature.Value.deathTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) ||
                                    Math.Floor(creature.Value.deathTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) + 1 ||
                                    Math.Floor(creature.Value.deathTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) - 1)
                                {
                                    lock (creatureTextsDict)
                                    {
                                        if (creatureTextsDict.ContainsKey(chatPacket.creatureEntry) && creatureTextsDict[chatPacket.creatureEntry].Count(x => x.creatureText == text.creatureText) == 0)
                                        {
                                            creatureTextsDict[chatPacket.creatureEntry].Add(new CreatureText(chatPacket, false, true));
                                        }
                                        else if (!creatureTextsDict.ContainsKey(chatPacket.creatureEntry))
                                        {
                                            creatureTextsDict.Add(chatPacket.creatureEntry, new List <CreatureText>());
                                            creatureTextsDict[chatPacket.creatureEntry].Add(new CreatureText(chatPacket, false, true));
                                        }
                                    }
                                }
                            }
                        });
                    }
                }
            });

            mainForm.SetCurrentStatus("Parsing SMSG_ON_MONSTER_MOVE and SMSG_ATTACK_STOP packets...");

            Parallel.ForEach(packetIndexes, value =>
            {
                switch (value.Value)
                {
                case Packet.PacketTypes.SMSG_ON_MONSTER_MOVE:
                    {
                        MonsterMovePacket movePacket = MonsterMovePacket.ParseMovementPacket(lines, value.Key, buildVersion, 0);
                        if (movePacket.creatureGuid == "")
                        {
                            return;
                        }

                        lock (creaturesDict)
                        {
                            if (creaturesDict.ContainsKey(movePacket.creatureGuid))
                            {
                                creaturesDict[movePacket.creatureGuid].UpdateSpellsByMovementPacket(movePacket);
                            }
                        }

                        break;
                    }

                case Packet.PacketTypes.SMSG_ATTACK_STOP:
                    {
                        AttackStopPacket attackStopPacket = AttackStopPacket.ParseAttackStopkPacket(lines, value.Key, buildVersion);
                        if (attackStopPacket.creatureGuid == "")
                        {
                            return;
                        }

                        lock (creaturesDict)
                        {
                            if (creaturesDict.ContainsKey(attackStopPacket.creatureGuid))
                            {
                                creaturesDict[attackStopPacket.creatureGuid].UpdateSpellsByAttackStopPacket(attackStopPacket);

                                if (attackStopPacket.nowDead)
                                {
                                    creaturesDict[attackStopPacket.creatureGuid].deathTime = attackStopPacket.packetSendTime;
                                }
                            }
                        }

                        break;
                    }
                }
            });

            Parallel.ForEach(creaturesDict, creature =>
            {
                creature.Value.RemoveNonCombatCastTimes();
            });

            Parallel.ForEach(creaturesDict, creature =>
            {
                creature.Value.CreateCombatCastTimings();
            });

            Parallel.ForEach(creaturesDict, creature =>
            {
                creature.Value.CreateDeathSpells();
            });

            if (mainForm.checkBox_CreatureScriptsCreator_CreateDataFile.Checked)
            {
                BinaryFormatter binaryFormatter = new BinaryFormatter();

                if (!multiSelect)
                {
                    using (FileStream fileStream = new FileStream(fileName.Replace("_parsed.txt", "_script_packets.dat"), FileMode.OpenOrCreate))
                    {
                        Dictionary <uint, object> dictToSerialize = new Dictionary <uint, object>
                        {
                            { 0, creaturesDict },
                            { 1, creatureTextsDict }
                        };

                        binaryFormatter.Serialize(fileStream, dictToSerialize);
                    }
                }
                else
                {
                    using (FileStream fileStream = new FileStream(fileName.Replace("_parsed.txt", "multi_selected_script_packets.dat"), FileMode.OpenOrCreate))
                    {
                        Dictionary <uint, object> dictToSerialize = new Dictionary <uint, object>
                        {
                            { 0, creaturesDict },
                            { 1, creatureTextsDict }
                        };

                        binaryFormatter.Serialize(fileStream, dictToSerialize);
                    }
                }
            }

            mainForm.SetCurrentStatus("");
            return(true);
        }
        public bool GetDataFromSniffFile(string fileName)
        {
            mainForm.SetCurrentStatus("Loading DBC...");

            DBC.DBC.Load();

            mainForm.SetCurrentStatus("Getting lines...");

            var lines = File.ReadAllLines(fileName);
            SortedDictionary <long, Packet> updateObjectPacketsDict = new SortedDictionary <long, Packet>();
            SortedDictionary <long, Packet> movementPacketsDict     = new SortedDictionary <long, Packet>();
            SortedDictionary <long, Packet> spellPacketsDict        = new SortedDictionary <long, Packet>();
            SortedDictionary <long, Packet> auraPacketsDict         = new SortedDictionary <long, Packet>();
            SortedDictionary <long, Packet> emotePacketsDict        = new SortedDictionary <long, Packet>();

            buildVersion = LineGetters.GetBuildVersion(lines);
            if (buildVersion == BuildVersions.BUILD_UNKNOWN)
            {
                MessageBox.Show(fileName + " has non-supported build.", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                return(false);
            }

            mainForm.SetCurrentStatus("Searching for packet indexes in lines...");

            Parallel.For(0, lines.Length, index =>
            {
                if (Packet.GetPacketTypeFromLine(lines[index]) == Packet.PacketTypes.SMSG_UPDATE_OBJECT)
                {
                    TimeSpan sendTime = LineGetters.GetTimeSpanFromLine(lines[index]);
                    if (sendTime != TimeSpan.Zero)
                    {
                        lock (updateObjectPacketsDict)
                        {
                            if (!updateObjectPacketsDict.ContainsKey(index))
                            {
                                updateObjectPacketsDict.Add(index, new Packet(Packet.PacketTypes.SMSG_UPDATE_OBJECT, sendTime, index, new List <object>()));
                            }
                        }
                    }
                }
                else if (Packet.GetPacketTypeFromLine(lines[index]) == Packet.PacketTypes.SMSG_ON_MONSTER_MOVE)
                {
                    TimeSpan sendTime = LineGetters.GetTimeSpanFromLine(lines[index]);
                    if (sendTime != TimeSpan.Zero)
                    {
                        lock (movementPacketsDict)
                        {
                            if (!movementPacketsDict.ContainsKey(index))
                            {
                                movementPacketsDict.Add(index, new Packet(Packet.PacketTypes.SMSG_ON_MONSTER_MOVE, sendTime, index, new List <object>()));
                            }
                        }
                    }
                }
                else if (Properties.Settings.Default.Scripts && Packet.GetPacketTypeFromLine(lines[index]) == Packet.PacketTypes.SMSG_SPELL_START)
                {
                    TimeSpan sendTime = LineGetters.GetTimeSpanFromLine(lines[index]);
                    if (sendTime != TimeSpan.Zero)
                    {
                        lock (spellPacketsDict)
                        {
                            if (!spellPacketsDict.ContainsKey(index))
                            {
                                spellPacketsDict.Add(index, new Packet(Packet.PacketTypes.SMSG_SPELL_START, sendTime, index, new List <object>()));
                            }
                        }
                    }
                }
                else if (Properties.Settings.Default.Scripts && Packet.GetPacketTypeFromLine(lines[index]) == Packet.PacketTypes.SMSG_AURA_UPDATE)
                {
                    TimeSpan sendTime = LineGetters.GetTimeSpanFromLine(lines[index]);
                    if (sendTime != TimeSpan.Zero)
                    {
                        lock (auraPacketsDict)
                        {
                            if (!auraPacketsDict.ContainsKey(index))
                            {
                                auraPacketsDict.Add(index, new Packet(Packet.PacketTypes.SMSG_AURA_UPDATE, sendTime, index, new List <object>()));
                            }
                        }
                    }
                }
                else if (Properties.Settings.Default.Scripts && Packet.GetPacketTypeFromLine(lines[index]) == Packet.PacketTypes.SMSG_EMOTE)
                {
                    TimeSpan sendTime = LineGetters.GetTimeSpanFromLine(lines[index]);
                    if (sendTime != TimeSpan.Zero)
                    {
                        lock (emotePacketsDict)
                        {
                            if (!emotePacketsDict.ContainsKey(index))
                            {
                                emotePacketsDict.Add(index, new Packet(Packet.PacketTypes.SMSG_EMOTE, sendTime, index, new List <object>()));
                            }
                        }
                    }
                }
            });

            creaturesDict.Clear();

            mainForm.SetCurrentStatus("Parsing SMSG_UPDATE_OBJECT packets...");

            Parallel.ForEach(updateObjectPacketsDict.Values.AsEnumerable(), packet =>
            {
                Parallel.ForEach(UpdateObjectPacket.ParseObjectUpdatePacket(lines, packet.index, buildVersion).AsEnumerable(), updatePacket =>
                {
                    lock (updateObjectPacketsDict)
                    {
                        updateObjectPacketsDict.AddSourceFromUpdatePacket(updatePacket, packet.index);
                    }

                    lock (creaturesDict)
                    {
                        if (!creaturesDict.ContainsKey(updatePacket.creatureGuid))
                        {
                            creaturesDict.Add(updatePacket.creatureGuid, new Creature(updatePacket));
                        }
                        else
                        {
                            creaturesDict[updatePacket.creatureGuid].UpdateCreature(updatePacket);
                        }
                    }
                });
            });

            mainForm.SetCurrentStatus("Parsing SMSG_ON_MONSTER_MOVE packets...");

            Parallel.ForEach(movementPacketsDict.Values.AsEnumerable(), packet =>
            {
                MonsterMovePacket movePacket = MonsterMovePacket.ParseMovementPacket(lines, packet.index, buildVersion);
                if (movePacket.creatureGuid != "" && (movePacket.HasWaypoints() || movePacket.HasOrientation() || movePacket.HasJump()))
                {
                    lock (movementPacketsDict)
                    {
                        movementPacketsDict.AddSourceFromMovementPacket(movePacket, packet.index);
                    }

                    lock (creaturesDict)
                    {
                        if (creaturesDict.ContainsKey(movePacket.creatureGuid))
                        {
                            Creature creature = creaturesDict[movePacket.creatureGuid];

                            if (!creature.HasWaypoints() && movePacket.HasWaypoints())
                            {
                                creature.AddWaypointsFromMovementPacket(movePacket);
                            }
                            else if (creature.HasWaypoints() && movePacket.HasOrientation() && !movePacket.HasWaypoints())
                            {
                                creature.SortWaypoints();
                                creature.waypoints.Last().SetOrientation(movePacket.creatureOrientation);
                                creature.waypoints.Last().SetOrientationSetTime(movePacket.packetSendTime);
                            }
                            else if (creature.HasWaypoints() && movePacket.HasWaypoints())
                            {
                                if (creature.waypoints.Last().HasOrientation())
                                {
                                    creature.waypoints.Last().SetDelay((uint)((movePacket.packetSendTime - creature.waypoints.Last().orientationSetTime).TotalMilliseconds));
                                }

                                creature.AddWaypointsFromMovementPacket(movePacket);
                            }
                        }
                    }
                }
            });

            if (Properties.Settings.Default.Scripts)
            {
                mainForm.SetCurrentStatus("Parsing SMSG_SPELL_START packets...");

                Parallel.ForEach(spellPacketsDict.Values.AsEnumerable(), packet =>
                {
                    SpellStartPacket spellPacket = SpellStartPacket.ParseSpellStartPacket(lines, packet.index, buildVersion);
                    if (spellPacket.spellId == 0)
                    {
                        return;
                    }

                    lock (spellPacketsDict)
                    {
                        spellPacketsDict.AddSourceFromSpellPacket(spellPacket, packet.index);
                    }
                });

                mainForm.SetCurrentStatus("Parsing SMSG_AURA_UPDATE packets...");

                Parallel.ForEach(auraPacketsDict.Values.AsEnumerable(), packet =>
                {
                    Parallel.ForEach(AuraUpdatePacket.ParseAuraUpdatePacket(lines, packet.index, buildVersion).AsEnumerable(), auraPacket =>
                    {
                        lock (auraPacketsDict)
                        {
                            auraPacketsDict.AddSourceFromAuraUpdatePacket(auraPacket, packet.index);
                        }

                        lock (creaturesDict)
                        {
                            if (creaturesDict.ContainsKey(auraPacket.unitGuid))
                            {
                                Creature creature = creaturesDict[auraPacket.unitGuid];

                                creature.auras.Add(new Aura((uint)auraPacket.slot, (bool)auraPacket.HasAura, auraPacket.packetSendTime, auraPacket.spellId));
                            }
                        }
                    });
                });

                mainForm.SetCurrentStatus("Parsing SMSG_EMOTE packets...");

                Parallel.ForEach(emotePacketsDict.Values.AsEnumerable(), packet =>
                {
                    EmotePacket emotePacket = EmotePacket.ParseEmotePacket(lines, packet.index, buildVersion);
                    if (emotePacket.guid == "" || emotePacket.emoteId == 0)
                    {
                        return;
                    }

                    lock (emotePacketsDict)
                    {
                        emotePacketsDict.AddSourceFromEmotePacket(emotePacket, packet.index);
                    }
                });

                mainForm.SetCurrentStatus("Creating waypoint scripts for creatures...");

                Parallel.ForEach(creaturesDict.Values.AsEnumerable(), creature =>
                {
                    if (creature.HasWaypoints())
                    {
                        SortedDictionary <long, Packet> creaturePacketsDict = new SortedDictionary <long, Packet>();

                        foreach (var packet in updateObjectPacketsDict.Values.Where(packet => packet.HasCreatureWithGuid(creature.guid)))
                        {
                            creaturePacketsDict.Add(packet.index, packet);
                        }

                        foreach (var packet in movementPacketsDict.Values.Where(packet => packet.HasCreatureWithGuid(creature.guid)))
                        {
                            creaturePacketsDict.Add(packet.index, packet);
                        }

                        foreach (var packet in spellPacketsDict.Values.Where(packet => packet.HasCreatureWithGuid(creature.guid)))
                        {
                            creaturePacketsDict.Add(packet.index, packet);
                        }

                        foreach (var packet in auraPacketsDict.Values.Where(packet => packet.HasCreatureWithGuid(creature.guid)))
                        {
                            creaturePacketsDict.Add(packet.index, packet);
                        }

                        foreach (var packet in emotePacketsDict.Values.Where(packet => packet.HasCreatureWithGuid(creature.guid)))
                        {
                            creaturePacketsDict.Add(packet.index, packet);
                        }

                        List <WaypointScript> scriptsList = new List <WaypointScript>();
                        MonsterMovePacket startMovePacket = new MonsterMovePacket();
                        bool scriptsParsingStarted        = false;

                        foreach (Packet packet in creaturePacketsDict.Values)
                        {
                            switch (packet.packetType)
                            {
                            case Packet.PacketTypes.SMSG_ON_MONSTER_MOVE:
                                {
                                    MonsterMovePacket movePacket = (MonsterMovePacket)packet.parsedPacketsList.First();
                                    if (movePacket.HasWaypoints() && !scriptsParsingStarted)
                                    {
                                        startMovePacket       = movePacket;
                                        scriptsParsingStarted = true;
                                    }
                                    else if (movePacket.HasWaypoints() && scriptsParsingStarted)
                                    {
                                        if (scriptsList.Count != 0)
                                        {
                                            creature.AddScriptsForWaypoints(scriptsList, startMovePacket, movePacket);
                                            scriptsList.Clear();
                                        }

                                        startMovePacket = movePacket;
                                    }
                                    else if ((movePacket.HasOrientation() || movePacket.HasJump()) && scriptsParsingStarted)
                                    {
                                        scriptsList.Add(WaypointScript.GetScriptsFromMovementPacket(movePacket));
                                    }

                                    break;
                                }

                            case Packet.PacketTypes.SMSG_UPDATE_OBJECT:
                                {
                                    if (scriptsParsingStarted && packet.parsedPacketsList.Count != 0)
                                    {
                                        if (packet.parsedPacketsList.GetUpdatePacketForCreatureWithGuid(creature.guid) != null)
                                        {
                                            UpdateObjectPacket updatePacket = (UpdateObjectPacket)packet.parsedPacketsList.GetUpdatePacketForCreatureWithGuid(creature.guid);

                                            List <WaypointScript> updateScriptsList = WaypointScript.GetScriptsFromUpdatePacket(updatePacket);
                                            if (updateScriptsList.Count != 0)
                                            {
                                                scriptsList.AddRange(updateScriptsList);
                                            }
                                        }
                                    }

                                    break;
                                }

                            case Packet.PacketTypes.SMSG_SPELL_START:
                                {
                                    if (scriptsParsingStarted)
                                    {
                                        SpellStartPacket spellPacket = (SpellStartPacket)packet.parsedPacketsList.First();
                                        scriptsList.Add(WaypointScript.GetScriptsFromSpellPacket(spellPacket));
                                    }

                                    break;
                                }

                            case Packet.PacketTypes.SMSG_AURA_UPDATE:
                                {
                                    if (scriptsParsingStarted)
                                    {
                                        AuraUpdatePacket auraPacket = (AuraUpdatePacket)packet.parsedPacketsList.First();
                                        if (auraPacket.HasAura == false)
                                        {
                                            scriptsList.Add(WaypointScript.GetScriptsFromAuraUpdatePacket(auraPacket, creature));
                                        }
                                    }

                                    break;
                                }

                            case Packet.PacketTypes.SMSG_EMOTE:
                                {
                                    if (scriptsParsingStarted)
                                    {
                                        EmotePacket emotePacket = (EmotePacket)packet.parsedPacketsList.First();
                                        scriptsList.Add(WaypointScript.GetScriptsFromEmotePacket(emotePacket));
                                    }

                                    break;
                                }
                            }
                        }
                    }
                });
            }

            mainForm.SetCurrentStatus("");
            return(true);
        }
 public static void AddSourceFromMovementPacket(this SortedDictionary <long, Packet> dict, MonsterMovePacket movementPacket, long index)
 {
     foreach (var packet in dict.Values.Where(packet => packet.packetType == Packet.PacketTypes.SMSG_ON_MONSTER_MOVE && packet.index == index))
     {
         packet.parsedPacketsList.Add(movementPacket);
         return;
     }
 }
        public bool GetDataFromSniffFile(string fileName)
        {
            mainForm.SetCurrentStatus("Loading DBC...");

            DBC.DBC.Load();

            mainForm.SetCurrentStatus("Getting lines...");

            var lines = File.ReadAllLines(fileName);
            Dictionary <long, Packet.PacketTypes> packetIndexes = new Dictionary <long, Packet.PacketTypes>();

            buildVersion = LineGetters.GetBuildVersion(lines);
            if (buildVersion == BuildVersions.BUILD_UNKNOWN)
            {
                MessageBox.Show(fileName + " has non-supported build.", "File Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                return(false);
            }

            creaturesDict.Clear();

            mainForm.SetCurrentStatus("Searching for packet indexes in lines...");

            Parallel.For(0, lines.Length, index =>
            {
                if (lines[index].Contains("SMSG_UPDATE_OBJECT") && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_UPDATE_OBJECT);
                }
                else if (lines[index].Contains("SMSG_AI_REACTION") && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_AI_REACTION);
                }
                else if (lines[index].Contains("SMSG_SPELL_START") && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_SPELL_START);
                }
                else if (lines[index].Contains("SMSG_CHAT") && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_CHAT);
                }
                else if (lines[index].Contains("SMSG_ON_MONSTER_MOVE") && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_ON_MONSTER_MOVE);
                }
                else if (lines[index].Contains("SMSG_ATTACK_STOP") && !packetIndexes.ContainsKey(index))
                {
                    lock (packetIndexes)
                        packetIndexes.Add(index, Packet.PacketTypes.SMSG_ATTACK_STOP);
                }
            });

            mainForm.SetCurrentStatus("Parsing SMSG_UPDATE_OBJECT packets...");

            Parallel.ForEach(packetIndexes.AsEnumerable(), value =>
            {
                if (value.Value == Packet.PacketTypes.SMSG_UPDATE_OBJECT)
                {
                    Parallel.ForEach(UpdateObjectPacket.ParseObjectUpdatePacket(lines, value.Key, buildVersion).AsEnumerable(), packet =>
                    {
                        lock (creaturesDict)
                        {
                            if (!creaturesDict.ContainsKey(packet.creatureGuid))
                            {
                                creaturesDict.Add(packet.creatureGuid, new Creature(packet));
                            }
                            else
                            {
                                creaturesDict[packet.creatureGuid].UpdateCreature(packet);
                            }
                        }
                    });
                }
            });

            mainForm.SetCurrentStatus("Parsing SMSG_SPELL_START packets...");

            Parallel.ForEach(packetIndexes.AsEnumerable(), value =>
            {
                if (value.Value == Packet.PacketTypes.SMSG_SPELL_START)
                {
                    SpellStartPacket spellPacket = SpellStartPacket.ParseSpellStartPacket(lines, value.Key, buildVersion);
                    if (spellPacket.spellId == 0)
                    {
                        return;
                    }

                    lock (creaturesDict)
                    {
                        if (creaturesDict.ContainsKey(spellPacket.casterGuid))
                        {
                            if (!creaturesDict[spellPacket.casterGuid].castedSpells.ContainsKey(spellPacket.spellId))
                            {
                                creaturesDict[spellPacket.casterGuid].castedSpells.Add(spellPacket.spellId, new Spell(spellPacket));
                            }
                            else
                            {
                                creaturesDict[spellPacket.casterGuid].UpdateSpells(spellPacket);
                            }
                        }
                    }
                }
            });

            mainForm.SetCurrentStatus("Parsing SMSG_AI_REACTION packets...");

            Parallel.ForEach(packetIndexes.AsEnumerable(), value =>
            {
                if (value.Value == Packet.PacketTypes.SMSG_AI_REACTION)
                {
                    AIReactionPacket reactionPacket = AIReactionPacket.ParseAIReactionPacket(lines, value.Key, buildVersion);
                    if (reactionPacket.creatureGuid == "")
                    {
                        return;
                    }

                    lock (creaturesDict)
                    {
                        if (creaturesDict.ContainsKey(reactionPacket.creatureGuid))
                        {
                            if (creaturesDict[reactionPacket.creatureGuid].combatStartTime == TimeSpan.Zero ||
                                creaturesDict[reactionPacket.creatureGuid].combatStartTime < reactionPacket.packetSendTime)
                            {
                                creaturesDict[reactionPacket.creatureGuid].combatStartTime = reactionPacket.packetSendTime;
                            }

                            creaturesDict[reactionPacket.creatureGuid].UpdateCombatSpells(reactionPacket);
                        }
                    }
                }
            });

            mainForm.SetCurrentStatus("Parsing SMSG_CHAT packets...");

            Parallel.ForEach(packetIndexes.AsEnumerable(), value =>
            {
                if (value.Value == Packet.PacketTypes.SMSG_CHAT)
                {
                    ChatPacket chatPacket = ChatPacket.ParseChatPacket(lines, value.Key, buildVersion);
                    if (chatPacket.creatureGuid == "")
                    {
                        return;
                    }

                    lock (creaturesDict)
                    {
                        Parallel.ForEach(creaturesDict, creature =>
                        {
                            if (creature.Value.entry == chatPacket.creatureEntry)
                            {
                                if (Math.Floor(creature.Value.combatStartTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) ||
                                    Math.Floor(creature.Value.combatStartTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) + 1 ||
                                    Math.Floor(creature.Value.combatStartTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) - 1)
                                {
                                    if (creatureTextsDict.ContainsKey(chatPacket.creatureEntry))
                                    {
                                        if (!IsCreatureHasAggroText(chatPacket.creatureEntry))
                                        {
                                            lock (creatureTextsDict)
                                            {
                                                creatureTextsDict[chatPacket.creatureEntry].Add(new CreatureText(chatPacket, true));
                                            }
                                        }
                                    }
                                    else
                                    {
                                        lock (creatureTextsDict)
                                        {
                                            creatureTextsDict.Add(chatPacket.creatureEntry, new List <CreatureText>());
                                            creatureTextsDict[chatPacket.creatureEntry].Add(new CreatureText(chatPacket, true));
                                        }
                                    }
                                }

                                if (Math.Floor(creature.Value.deathTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) ||
                                    Math.Floor(creature.Value.deathTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) + 1 ||
                                    Math.Floor(creature.Value.deathTime.TotalSeconds) == Math.Floor(chatPacket.packetSendTime.TotalSeconds) - 1)
                                {
                                    if (creatureTextsDict.ContainsKey(chatPacket.creatureEntry))
                                    {
                                        if (!IsCreatureHasDeathText(chatPacket.creatureEntry))
                                        {
                                            lock (creatureTextsDict)
                                            {
                                                creatureTextsDict[chatPacket.creatureEntry].Add(new CreatureText(chatPacket, false, true));
                                            }
                                        }
                                    }
                                    else
                                    {
                                        lock (creatureTextsDict)
                                        {
                                            creatureTextsDict.Add(chatPacket.creatureEntry, new List <CreatureText>());
                                            creatureTextsDict[chatPacket.creatureEntry].Add(new CreatureText(chatPacket, false, true));
                                        }
                                    }
                                }
                            }
                        });
                    }
                }
            });

            mainForm.SetCurrentStatus("Parsing SMSG_ON_MONSTER_MOVE and SMSG_ATTACK_STOP packets...");

            Parallel.ForEach(packetIndexes.AsEnumerable(), value =>
            {
                switch (value.Value)
                {
                case Packet.PacketTypes.SMSG_ON_MONSTER_MOVE:
                    {
                        MonsterMovePacket movePacket = MonsterMovePacket.ParseMovementPacket(lines, value.Key, buildVersion);
                        if (movePacket.creatureGuid == "")
                        {
                            return;
                        }

                        lock (creaturesDict)
                        {
                            if (creaturesDict.ContainsKey(movePacket.creatureGuid))
                            {
                                creaturesDict[movePacket.creatureGuid].UpdateSpellsByMovementPacket(movePacket);
                            }
                        }

                        break;
                    }

                case Packet.PacketTypes.SMSG_ATTACK_STOP:
                    {
                        AttackStopPacket attackStopPacket = AttackStopPacket.ParseAttackStopkPacket(lines, value.Key, buildVersion);
                        if (attackStopPacket.creatureGuid == "")
                        {
                            return;
                        }

                        lock (creaturesDict)
                        {
                            if (creaturesDict.ContainsKey(attackStopPacket.creatureGuid))
                            {
                                creaturesDict[attackStopPacket.creatureGuid].UpdateSpellsByAttackStopPacket(attackStopPacket);

                                if (attackStopPacket.nowDead)
                                {
                                    creaturesDict[attackStopPacket.creatureGuid].deathTime = attackStopPacket.packetSendTime;
                                }
                            }
                        }

                        break;
                    }
                }
            });

            Parallel.ForEach(creaturesDict, creature =>
            {
                creature.Value.RemoveNonCombatCastTimes();
            });

            Parallel.ForEach(creaturesDict, creature =>
            {
                creature.Value.CreateCombatCastTimings();
            });

            Parallel.ForEach(creaturesDict, creature =>
            {
                creature.Value.CreateDeathSpells();
            });

            mainForm.SetCurrentStatus("");
            return(true);
        }
Example #9
0
            public static MonsterMovePacket ParseMovementPacket(string[] lines, long index, BuildVersions buildVersion)
            {
                MonsterMovePacket movePacket = new MonsterMovePacket("", 0.0f, LineGetters.GetTimeSpanFromLine(lines[index]), new List <Waypoint>(), 0, new Position(), new JumpInfo());

                if (LineGetters.IsCreatureLine(lines[index + 1]))
                {
                    Position lastPosition = new Position();

                    do
                    {
                        if (lines[index].Contains("FacingGUID: Full:"))
                        {
                            movePacket.creatureGuid = "";
                            break;
                        }

                        if (LineGetters.GetGuidFromLine(lines[index], buildVersion, moverGuid: true) != "")
                        {
                            movePacket.creatureGuid = LineGetters.GetGuidFromLine(lines[index], buildVersion, moverGuid: true);
                        }

                        if (GetStartPositionFromLine(lines[index]).IsValid())
                        {
                            movePacket.startPos = GetStartPositionFromLine(lines[index]);
                        }

                        if (GetMoveTimeFromLine(lines[index]) != 0)
                        {
                            movePacket.moveTime = GetMoveTimeFromLine(lines[index]);
                        }

                        if (GetFaceDirectionFromLine(lines[index]) != 0.0f)
                        {
                            movePacket.creatureOrientation = GetFaceDirectionFromLine(lines[index]);
                        }

                        if (GetPointPositionFromLine(lines[index]).IsValid())
                        {
                            if (ConsistsOfPoints(lines[index], lines[index + 1]))
                            {
                                uint pointId = 1;

                                do
                                {
                                    if (GetPointPositionFromLine(lines[index]).IsValid())
                                    {
                                        movePacket.waypoints.Add(new Waypoint(GetPointPositionFromLine(lines[index]), 0.0f, 0, movePacket.startPos, movePacket.moveTime, movePacket.packetSendTime, new TimeSpan(), new List <WaypointScript>(), pointId));
                                        pointId++;
                                    }

                                    index++;
                                }while (lines[index] != "");
                            }
                            else
                            {
                                if (GetPointPositionFromLine(lines[index]).IsValid())
                                {
                                    lastPosition = GetPointPositionFromLine(lines[index]);
                                }

                                uint pointId = 1;

                                do
                                {
                                    if (GetWayPointPositionFromLine(lines[index]).IsValid())
                                    {
                                        movePacket.waypoints.Add(new Waypoint(GetWayPointPositionFromLine(lines[index]), 0.0f, 0, movePacket.startPos, movePacket.moveTime, movePacket.packetSendTime, new TimeSpan(), new List <WaypointScript>(), pointId));
                                        pointId++;
                                    }

                                    if (GetJumpGravityFromLine(lines[index]) != 0.0f)
                                    {
                                        movePacket.jumpInfo.jumpGravity = GetJumpGravityFromLine(lines[index]);
                                    }

                                    index++;
                                }while (lines[index] != "");
                            }

                            if (lastPosition.IsValid())
                            {
                                if (movePacket.jumpInfo.jumpGravity != 0.0f)
                                {
                                    movePacket.jumpInfo.moveTime = movePacket.moveTime;
                                    movePacket.jumpInfo.jumpPos  = lastPosition;
                                }
                                else
                                {
                                    movePacket.waypoints.Add(new Waypoint(lastPosition, 0.0f, 0, movePacket.startPos, movePacket.moveTime, movePacket.packetSendTime, new TimeSpan(), new List <WaypointScript>(), (uint)(movePacket.waypoints.Count + 1)));
                                }
                            }

                            break;
                        }

                        index++;
                    }while (lines[index] != "");
                }

                return(movePacket);
            }
Example #10
0
            public static IEnumerable <UpdateObjectPacket> ParseObjectUpdatePacket(string[] lines, long index, BuildVersions buildVersion)
            {
                TimeSpan packetSendTime = LineGetters.GetTimeSpanFromLine(lines[index]);
                List <UpdateObjectPacket> updatePacketsList = new List <UpdateObjectPacket>();

                do
                {
                    if ((lines[index].Contains("UpdateType: CreateObject1") || lines[index].Contains("UpdateType: CreateObject2")) && LineGetters.IsCreatureLine(lines[index + 1]))
                    {
                        UpdateObjectPacket updatePacket = new UpdateObjectPacket(0, "", "Unknown", -1, 0, packetSendTime, new Position(), null, new List <Waypoint>(), null, null, null, false);

                        do
                        {
                            if (MonsterMovePacket.GetPointPositionFromLine(lines[index]).IsValid())
                            {
                                uint pointId = 1;

                                do
                                {
                                    updatePacket.waypoints.Add(new Waypoint(MonsterMovePacket.GetPointPositionFromLine(lines[index]), 0.0f, 0, new Position(), 0, packetSendTime, new TimeSpan(), new List <WaypointScript>(), pointId));
                                    pointId++;
                                    index++;
                                }while (lines[index].Contains("Points:"));
                            }

                            if (GetMapIdFromLine(lines[index]) != null)
                            {
                                updatePacket.mapId = GetMapIdFromLine(lines[index]);
                            }

                            if (GetSpawnPositionFromLine(lines[index], lines[index + 1]).IsValid())
                            {
                                updatePacket.spawnPosition = GetSpawnPositionFromLine(lines[index], lines[index + 1]);
                            }

                            if (GetEntryFromLine(lines[index]) != 0)
                            {
                                updatePacket.creatureEntry = GetEntryFromLine(lines[index]);
                            }

                            if (LineGetters.GetGuidFromLine(lines[index], buildVersion, objectFieldGuid: true) != "")
                            {
                                updatePacket.creatureGuid = LineGetters.GetGuidFromLine(lines[index], buildVersion, objectFieldGuid: true);
                            }

                            if (GetMaxHealthFromLine(lines[index]) != 0)
                            {
                                updatePacket.creatureMaxHealth = GetMaxHealthFromLine(lines[index]);
                            }

                            if (GetDisableGravityFromLine(lines[index]))
                            {
                                updatePacket.hasDisableGravity = true;
                            }

                            index++;
                        }while (IsLineValidForObjectParse(lines[index]));

                        if (updatePacket.creatureEntry == 0 || updatePacket.creatureGuid == "")
                        {
                            continue;
                        }

                        updatePacket.creatureName = MainForm.GetCreatureNameByEntry(updatePacket.creatureEntry);

                        updatePacketsList.Add(updatePacket);

                        --index;
                    }
                    else if (lines[index].Contains("UpdateType: Values") && LineGetters.IsCreatureLine(lines[index + 1]))
                    {
                        UpdateObjectPacket updatePacket = new UpdateObjectPacket(0, "", "Unknown", -1, 0, packetSendTime, new Position(), null, new List <Waypoint>(), null, null, null, false);

                        do
                        {
                            if (LineGetters.GetGuidFromLine(lines[index], buildVersion) != "")
                            {
                                updatePacket.creatureGuid = LineGetters.GetGuidFromLine(lines[index], buildVersion);
                            }

                            if (GetHealthFromLine(lines[index]) == 0)
                            {
                                updatePacket.creatureCurrentHealth = GetHealthFromLine(lines[index]);
                            }

                            if (GetEmoteStateFromLine(lines[index]) != null)
                            {
                                updatePacket.emoteStateId = GetEmoteStateFromLine(lines[index]);
                            }

                            if (GetSheatheStateFromLine(lines[index]) != null)
                            {
                                updatePacket.sheatheState = GetSheatheStateFromLine(lines[index]);
                            }

                            if (GetStandStateFromLine(lines[index]) != null)
                            {
                                updatePacket.standState = GetStandStateFromLine(lines[index]);
                            }

                            if (GetDisableGravityFromLine(lines[index]))
                            {
                                updatePacket.hasDisableGravity = true;
                            }

                            index++;
                        }while (IsLineValidForObjectParse(lines[index]));

                        updatePacket.creatureName = MainForm.GetCreatureNameByEntry(updatePacket.creatureEntry);

                        if (updatePacket.creatureGuid == "")
                        {
                            continue;
                        }

                        updatePacketsList.Add(updatePacket);

                        --index;
                    }

                    index++;
                } while (lines[index] != "");

                return(updatePacketsList);
            }
Example #11
0
 public static void AddSourceFromMovementPacket(this Packet packet, MonsterMovePacket movementPacket)
 {
     packet.parsedPacketsList.Add(movementPacket);
     packet.UsedGuids.Add(movementPacket.creatureGuid);
 }
Example #12
0
        private List <object> GetDataFromPackets(string[] lines, SynchronizedCollection <Packet> packets)
        {
            mainForm.toolStripStatusLabel_FileStatus.Text = "Current status: Getting data from packets...";
            mainForm.Update();

            List <object> packetsList = new List <object>();

            foreach (Packet packet in packets)
            {
                switch (packet.type)
                {
                case Packet.PacketTypes.SMSG_UPDATE_OBJECT:
                {
                    foreach (var updatePacket in UpdateObjectPacket.ParseObjectUpdatePacket(lines, packet))
                    {
                        packetsList.Add(updatePacket);
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_SPELL_START:
                case Packet.PacketTypes.SMSG_SPELL_GO:
                {
                    SpellStartPacket spellPacket = SpellStartPacket.ParseSpellStartPacket(lines, packet);

                    if (spellPacket.guid != "")
                    {
                        packetsList.Add(spellPacket);
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_ON_MONSTER_MOVE:
                {
                    MonsterMovePacket monsterMovePacket = MonsterMovePacket.ParseMovementPacket(lines, packet);

                    if (monsterMovePacket.guid != "" && (monsterMovePacket.waypoints.Count() != 0 || monsterMovePacket.HasJump() ||
                                                         monsterMovePacket.HasOrientation() || monsterMovePacket.hasFacingToPlayer))
                    {
                        packetsList.Add(monsterMovePacket);
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_PLAY_ONE_SHOT_ANIM_KIT:
                {
                    PlayOneShotAnimKit playOneShotAnimKitPacket = PlayOneShotAnimKit.ParsePlayOneShotAnimKitPacket(lines, packet);

                    if (playOneShotAnimKitPacket.guid != "")
                    {
                        packetsList.Add(playOneShotAnimKitPacket);
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_CHAT:
                {
                    ChatPacket chatPacket = ChatPacket.ParseChatPacket(lines, packet);

                    if (chatPacket.guid != "")
                    {
                        packetsList.Add(chatPacket);
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_EMOTE:
                {
                    EmotePacket emotePacket = EmotePacket.ParseEmotePacket(lines, packet);

                    if (emotePacket.guid != "")
                    {
                        packetsList.Add(emotePacket);
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_AURA_UPDATE:
                {
                    foreach (var auraPacket in AuraUpdatePacket.ParseAuraUpdatePacket(lines, packet))
                    {
                        packetsList.Add(auraPacket);
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_SET_AI_ANIM_KIT:
                {
                    SetAiAnimKit setAiAnimKitPacket = SetAiAnimKit.ParseSetAiAnimKitPacket(lines, packet);

                    if (setAiAnimKitPacket.guid != "")
                    {
                        packetsList.Add(setAiAnimKitPacket);
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_PLAY_SPELL_VISUAL_KIT:
                {
                    PlaySpellVisualKit playSpellVisualKitPacket = PlaySpellVisualKit.ParsePlaySpellVisualKitPacket(lines, packet);

                    if (playSpellVisualKitPacket.guid != "")
                    {
                        packetsList.Add(playSpellVisualKitPacket);
                    }

                    break;
                }

                default:
                    break;
                }
            }

            SpellStartPacket.FilterSpellPackets(packetsList);

            return(packetsList);
        }
Example #13
0
        public void CreateScriptsForCreatureWithGuid(string guid)
        {
            if (guid == "")
            {
                return;
            }

            List <object> creaturePacketsList = packetsList.Where(x => ((Packet)x).guid == guid).ToList();

            foreach (UpdateObjectPacket updatePacket in packetsList.Where(x => typeof(UpdateObjectPacket) == x.GetType() && ((UpdateObjectPacket)x).objectType == UpdateObjectPacket.ObjectType.Conversation))
            {
                if (updatePacket.conversationActors.FirstOrDefault(x => x == guid) != null)
                {
                    creaturePacketsList.Add(updatePacket);
                }
            }

            creaturePacketsList.AddRange(packetsList.Where(x => x.GetType() == typeof(SpellStartPacket) && ((SpellStartPacket)x).guid != guid && ((SpellStartPacket)x).targetGuids != null && ((SpellStartPacket)x).targetGuids.Contains(guid)));
            AuraUpdatePacket.FilterAuraPacketsForCreature(creaturePacketsList);
            creaturePacketsList = creaturePacketsList.OrderBy(x => ((Packet)x).number).ToList();

            for (int i = 0; i < creaturePacketsList.Count; i++)
            {
                Packet packet = (Packet)creaturePacketsList[i];

                if (packet.type == Packet.PacketTypes.SMSG_EMOTE)
                {
                    bool emoteRelatedToChat = false;

                    foreach (Packet chatPacket in creaturePacketsList.Where(x => x.GetType() == typeof(ChatPacket)))
                    {
                        if ((Math.Round(packet.time.TotalSeconds) == Math.Round(chatPacket.time.TotalSeconds) || Math.Round(packet.time.TotalSeconds) + 1 == Math.Round(chatPacket.time.TotalSeconds)) &&
                            IsEmoteRelatedToText(((ChatPacket)chatPacket).creatureText, ((EmotePacket)packet).emoteId))
                        {
                            emoteRelatedToChat = true;
                            break;
                        }
                    }

                    if (emoteRelatedToChat)
                    {
                        creaturePacketsList.RemoveAt(i);
                    }
                }
            }

            uint   creatureEntry = GetCreatureEntryUsingGuid(packetsList, guid);
            string creatureName  = GetCreatureNameFromDb(creatureEntry);
            string output        = "";

            output += "Parsed packet sequence for " + creatureName + " (Entry: " + creatureEntry + ") " + "(Guid: " + guid + ")" + "\r\n\r\n";
            output += "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*" + "\r\n";
            output += "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*" + "\r\n";

            for (int i = 0; i < creaturePacketsList.Count; i++)
            {
                Packet packet = (Packet)creaturePacketsList[i];

                if (i > 0)
                {
                    output += "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" + "\r\n";
                    output += "Time passed after previous packet: " + (packet.time - ((Packet)creaturePacketsList[i - 1]).time).TotalSeconds + " -- " + "Time passed after first packet: " + (packet.time - ((Packet)creaturePacketsList[0]).time).TotalSeconds + "\r\n";
                }

                output += "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" + "\r\n";
                output += "Packet Type: " + packet.type.ToString() + " -- " + "Packet Number: " + packet.number + "\r\n";
                output += "Packet Time: " + packet.time.Hours + ":" + packet.time.Minutes + ":" + packet.time.Seconds + ":" + packet.time.Milliseconds + "\r\n";

                switch (packet.type)
                {
                case Packet.PacketTypes.SMSG_UPDATE_OBJECT:
                {
                    UpdateObjectPacket updateObjectPacket = (UpdateObjectPacket)packet;

                    if (updateObjectPacket.updateType == UpdateObjectPacket.UpdateType.CreateObject)
                    {
                        if (updateObjectPacket.objectType == UpdateObjectPacket.ObjectType.Creature)
                        {
                            output += "Spawn Position: " + updateObjectPacket.spawnPosition.ToString() + "\r\n";
                            output += "Position const g_" + ConverNameToCoreFormat(creatureName) + "SpawnPosition = { " + updateObjectPacket.spawnPosition.ToString() + " };" + "\r\n";

                            if (updateObjectPacket.isSummonedByPlayer)
                            {
                                if (updateObjectPacket.hasReplacedObject)
                                {
                                    output += "if (Creature* l_" + ConverNameToCoreFormat(creatureName) + " = " + "l_Player->SummonCreature(me->GetEntry(), me->GetPosition(), TempSummonType::TEMPSUMMON_TIMED_DESPAWN, " + GetDespawnTimerForCreatureWithGuid(guid) * 1000 + ", 0, " + "l_Player->GetObjectGuid()))" + "\r\n" + "{" + "\r\n" + AddSpacesCount(4) + "\r\n" + "}" + "\r\n";
                                }
                                else
                                {
                                    output += ConverNameToCoreFormat(creatureName) + " = " + creatureEntry + "\r\n";
                                    output += "if (Creature* l_" + ConverNameToCoreFormat(creatureName) + " = " + "l_Player->SummonCreature(eCreatures::" + ConverNameToCoreFormat(creatureName) + ", " + "Positions::g_" + ConverNameToCoreFormat(creatureName) + ", TempSummonType::TEMPSUMMON_TIMED_DESPAWN, " + GetDespawnTimerForCreatureWithGuid(guid) * 1000 + ", 0, " + "l_Player->GetObjectGuid()))" + "\r\n" + "{" + "\r\n" + AddSpacesCount(4) + "\r\n" + "}" + "\r\n";
                                }
                            }

                            if (updateObjectPacket.moveData.waypoints.Count() != 0)
                            {
                                output += "Move Time: " + updateObjectPacket.moveData.moveTime + "\r\n";

                                if (!updateObjectPacket.moveData.HasJump())
                                {
                                    output += "Velocity: " + Convert.ToString(updateObjectPacket.moveData.GetWaypointsVelocity()).Replace(",", ".") + "f" + "\r\n";
                                    output += updateObjectPacket.moveData.GetSetSpeedString() + "\r\n";

                                    if (updateObjectPacket.moveData.waypoints.Count() == 1)
                                    {
                                        switch (updateObjectPacket.moveData.moveType)
                                        {
                                        case MonsterMovePacket.MoveTypes.WALK:
                                        {
                                            output += "Position const g_" + ConverNameToCoreFormat(creatureName) + "MovePos = { " + updateObjectPacket.moveData.waypoints.First().ToString() + " };" + "\r\n";
                                            output += "me->GetMotionMaster()->MoveSmoothPath(ePoints::MoveEnd, Positions::g_" + ConverNameToCoreFormat(creatureName) + "MovePos" + ");" + "\r\n";
                                            break;
                                        }

                                        case MonsterMovePacket.MoveTypes.RUN:
                                        {
                                            output += "Position const g_" + ConverNameToCoreFormat(creatureName) + "MovePos = { " + updateObjectPacket.moveData.waypoints.First().ToString() + " };" + "\r\n";
                                            output += "me->GetMotionMaster()->MoveSmoothPath(ePoints::MoveEnd, Positions::g_" + ConverNameToCoreFormat(creatureName) + "MovePos" + ");" + "\r\n";
                                            break;
                                        }

                                        case MonsterMovePacket.MoveTypes.FLY:
                                        {
                                            output += "Position const g_" + ConverNameToCoreFormat(creatureName) + "FlyPos = { " + updateObjectPacket.moveData.waypoints.First().ToString() + " };" + "\r\n";
                                            output += "me->GetMotionMaster()->MoveSmoothFlyPath(ePoints::FlyEnd, Positions::g_" + ConverNameToCoreFormat(creatureName) + "FlyPos" + ");" + "\r\n";
                                            break;
                                        }

                                        default:
                                            break;
                                        }
                                    }
                                    else
                                    {
                                        switch (updateObjectPacket.moveData.moveType)
                                        {
                                        case MonsterMovePacket.MoveTypes.WALK:
                                        {
                                            output += "me->GetMotionMaster()->MoveSmoothPath(ePoints::MoveEnd, Waypoints::g_Path" + ConverNameToCoreFormat(creatureName) + ", true);" + "\r\n";
                                            break;
                                        }

                                        case MonsterMovePacket.MoveTypes.RUN:
                                        {
                                            output += "me->GetMotionMaster()->MoveSmoothPath(ePoints::MoveEnd, Waypoints::g_Path" + ConverNameToCoreFormat(creatureName) + ", false);" + "\r\n";
                                            break;
                                        }

                                        case MonsterMovePacket.MoveTypes.FLY:
                                        {
                                            output += "me->GetMotionMaster()->MoveSmoothFlyPath(ePoints::MoveEnd, Waypoints::g_Path" + ConverNameToCoreFormat(creatureName) + ");" + "\r\n";
                                            break;
                                        }

                                        default:
                                            break;
                                        }

                                        output += "std::vector<G3D::Vector3> const g_Path" + ConverNameToCoreFormat(creatureName) + " =" + "\r\n";
                                        output += "{" + "\r\n";

                                        for (int j = 0; j < updateObjectPacket.moveData.waypoints.Count; j++)
                                        {
                                            Position waypoint = updateObjectPacket.moveData.waypoints[j];

                                            if (j < (updateObjectPacket.moveData.waypoints.Count - 1))
                                            {
                                                output += "{ " + waypoint.x.GetValueWithoutComma() + "f, " + waypoint.y.GetValueWithoutComma() + "f, " + waypoint.z.GetValueWithoutComma() + "f },\r\n";
                                            }
                                            else
                                            {
                                                output += "{ " + waypoint.x.GetValueWithoutComma() + "f, " + waypoint.y.GetValueWithoutComma() + "f, " + waypoint.z.GetValueWithoutComma() + "f }\r\n";
                                            }
                                        }

                                        output += "};" + "\r\n";
                                    }
                                }
                                else
                                {
                                    output += "Position const g_" + ConverNameToCoreFormat(creatureName) + "JumpPos = { " + updateObjectPacket.moveData.jumpInfo.jumpPos.ToString() + " };" + "\r\n";
                                    output += "me->GetMotionMaster()->MoveReverseJump(g_" + ConverNameToCoreFormat(creatureName) + "JumpPos" + ", " + updateObjectPacket.moveData.moveTime + ", " + updateObjectPacket.moveData.jumpInfo.jumpGravity.GetValueWithoutComma() + "f, " + "ePoints::" + ConverNameToCoreFormat(creatureName) + "JumpEnd);" + "\r\n";
                                    break;
                                }

                                break;
                            }
                        }
                        else if (updateObjectPacket.objectType == Packets.UpdateObjectPacket.ObjectType.Conversation)
                        {
                            output += "Creature is part of conversation: " + updateObjectPacket.conversationEntry + " (" + updateObjectPacket.guid + ")" + "\r\n";
                        }
                    }
                    else if (updateObjectPacket.updateType == UpdateObjectPacket.UpdateType.Values)
                    {
                        if (updateObjectPacket.sheatheState != null)
                        {
                            output += "me->SetSheath(" + (UpdateObjectPacket.SheathState)updateObjectPacket.sheatheState + ");" + "\r\n";
                        }

                        if (updateObjectPacket.standState != null)
                        {
                            output += "me->SetStandState(" + (UpdateObjectPacket.UnitStandStateType)updateObjectPacket.standState + ");" + "\r\n";
                        }

                        if (updateObjectPacket.emoteStateId != null)
                        {
                            output += "me->SetEmoteState(" + (EmotePacket.Emote)updateObjectPacket.emoteStateId + ");" + "\r\n";
                        }
                    }
                    else if (updateObjectPacket.updateType == UpdateObjectPacket.UpdateType.Destroy)
                    {
                        output += "me->DespawnOrUnsummon();" + "\r\n";
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_SPELL_START:
                case Packet.PacketTypes.SMSG_SPELL_GO:
                {
                    SpellStartPacket spellStartPacket = (SpellStartPacket)packet;

                    if (spellStartPacket.guid != guid)
                    {
                        uint   entry     = GetCreatureEntryUsingGuid(packetsList, spellStartPacket.guid);
                        string spellName = GetSpellName(spellStartPacket.spellId);

                        output += "Hitted by spell: " + spellStartPacket.spellId + " (" + spellName + ")" + "\r\n";

                        if (spellName != "Unknown")
                        {
                            output += ConverNameToCoreFormat(spellName) + " = " + spellStartPacket.spellId + "\r\n";
                        }

                        if (entry != 0)
                        {
                            output += "Caster: " + GetCreatureNameFromDb(entry) + " (Entry: " + entry + ") " + "(Guid: " + spellStartPacket.guid + ")" + "\r\n";
                        }
                        else
                        {
                            output += "Caster: Player " + "(Guid: " + spellStartPacket.guid + ")" + "\r\n";
                        }
                    }
                    else
                    {
                        string spellName = GetSpellName(spellStartPacket.spellId);

                        output += "Spell Id: " + spellStartPacket.spellId + " (" + spellName + ")" + "\r\n";

                        if (spellName != "Unknown")
                        {
                            output += ConverNameToCoreFormat(spellName) + " = " + spellStartPacket.spellId + "\r\n";
                            output += "me->CastSpell(me, eSpells::" + ConverNameToCoreFormat(spellName) + ", true);" + "\r\n";
                        }

                        if (spellStartPacket.destination.IsValid())
                        {
                            output += "Destination: " + spellStartPacket.destination.ToString() + "\r\n";
                        }

                        if (spellStartPacket.targetGuids != null)
                        {
                            if (spellStartPacket.targetGuids.Count == 1 && spellStartPacket.targetGuids.First() == spellStartPacket.guid)
                            {
                                break;
                            }
                            else
                            {
                                for (int j = 0; j < spellStartPacket.targetGuids.Count; j++)
                                {
                                    uint entry = GetCreatureEntryUsingGuid(packetsList, spellStartPacket.targetGuids[j]);
                                    output += "Hit Target " + j + ": " + GetCreatureNameFromDb(entry) + " (Entry: " + entry + ") " + "(Guid: " + spellStartPacket.targetGuids[j] + ")" + "\r\n";
                                }
                            }
                        }
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_ON_MONSTER_MOVE:
                {
                    MonsterMovePacket monsterMovePacket = (MonsterMovePacket)packet;

                    if (monsterMovePacket.HasOrientation())
                    {
                        output += "me->SetFacingTo(" + monsterMovePacket.creatureOrientation.GetValueWithoutComma() + "f);" + "\r\n";
                    }

                    if (monsterMovePacket.hasFacingToPlayer)
                    {
                        output += "if (Unit* l_Owner = me->GetAnyOwner())" + "\r\n" + "{" + "\r\n" + AddSpacesCount(4) + "me->SetFacingToObject(l_Owner);" + "\r\n" + "}" + "\r\n";
                    }

                    if (monsterMovePacket.waypoints.Count() != 0)
                    {
                        output += "Move Time: " + monsterMovePacket.moveTime + "\r\n";

                        if (!monsterMovePacket.HasJump())
                        {
                            output += "Velocity: " + Convert.ToString(monsterMovePacket.GetWaypointsVelocity()).Replace(",", ".") + "f" + "\r\n";
                            output += monsterMovePacket.GetSetSpeedString() + "\r\n";

                            if (monsterMovePacket.waypoints.Count() == 1)
                            {
                                switch (monsterMovePacket.moveType)
                                {
                                case MonsterMovePacket.MoveTypes.WALK:
                                {
                                    output += "Position const g_" + ConverNameToCoreFormat(creatureName) + "MovePos = { " + monsterMovePacket.waypoints.First().ToString() + " };" + "\r\n";
                                    output += "me->GetMotionMaster()->MoveSmoothPath(ePoints::MoveEnd, Positions::g_" + ConverNameToCoreFormat(creatureName) + "MovePos" + ");" + "\r\n";
                                    break;
                                }

                                case MonsterMovePacket.MoveTypes.RUN:
                                {
                                    output += "Position const g_" + ConverNameToCoreFormat(creatureName) + "MovePos = { " + monsterMovePacket.waypoints.First().ToString() + " };" + "\r\n";
                                    output += "me->GetMotionMaster()->MoveSmoothPath(ePoints::MoveEnd, Positions::g_" + ConverNameToCoreFormat(creatureName) + "MovePos" + ");" + "\r\n";
                                    break;
                                }

                                case MonsterMovePacket.MoveTypes.FLY:
                                {
                                    output += "Position const g_" + ConverNameToCoreFormat(creatureName) + "FlyPos = { " + monsterMovePacket.waypoints.First().ToString() + " };" + "\r\n";
                                    output += "me->GetMotionMaster()->MoveSmoothFlyPath(ePoints::FlyEnd, Positions::g_" + ConverNameToCoreFormat(creatureName) + "FlyPos" + ");" + "\r\n";
                                    break;
                                }

                                default:
                                    break;
                                }
                            }
                            else
                            {
                                switch (monsterMovePacket.moveType)
                                {
                                case MonsterMovePacket.MoveTypes.WALK:
                                {
                                    output += "me->GetMotionMaster()->MoveSmoothPath(ePoints::MoveEnd, Waypoints::g_Path" + ConverNameToCoreFormat(creatureName) + ", true);" + "\r\n";
                                    break;
                                }

                                case MonsterMovePacket.MoveTypes.RUN:
                                {
                                    output += "me->GetMotionMaster()->MoveSmoothPath(ePoints::MoveEnd, Waypoints::g_Path" + ConverNameToCoreFormat(creatureName) + ", false);" + "\r\n";
                                    break;
                                }

                                case MonsterMovePacket.MoveTypes.FLY:
                                {
                                    output += "me->GetMotionMaster()->MoveSmoothFlyPath(ePoints::MoveEnd, Waypoints::g_Path" + ConverNameToCoreFormat(creatureName) + ");" + "\r\n";
                                    break;
                                }

                                default:
                                    break;
                                }

                                output += "std::vector<G3D::Vector3> const g_Path" + ConverNameToCoreFormat(creatureName) + " =" + "\r\n";
                                output += "{" + "\r\n";

                                for (int j = 0; j < monsterMovePacket.waypoints.Count; j++)
                                {
                                    Position waypoint = monsterMovePacket.waypoints[j];

                                    if (j < (monsterMovePacket.waypoints.Count - 1))
                                    {
                                        output += "{ " + waypoint.x.GetValueWithoutComma() + "f, " + waypoint.y.GetValueWithoutComma() + "f, " + waypoint.z.GetValueWithoutComma() + "f },\r\n";
                                    }
                                    else
                                    {
                                        output += "{ " + waypoint.x.GetValueWithoutComma() + "f, " + waypoint.y.GetValueWithoutComma() + "f, " + waypoint.z.GetValueWithoutComma() + "f }\r\n";
                                    }
                                }

                                output += "};" + "\r\n";
                            }
                        }
                        else
                        {
                            output += "Position const g_" + ConverNameToCoreFormat(creatureName) + "JumpPos = { " + monsterMovePacket.jumpInfo.jumpPos.ToString() + " };" + "\r\n";
                            output += "me->GetMotionMaster()->MoveReverseJump(g_" + ConverNameToCoreFormat(creatureName) + "JumpPos" + ", " + monsterMovePacket.moveTime + ", " + monsterMovePacket.jumpInfo.jumpGravity.GetValueWithoutComma() + "f, " + "ePoints::" + ConverNameToCoreFormat(creatureName) + "JumpEnd);" + "\r\n";
                            break;
                        }

                        break;
                    }

                    break;
                }

                case Packet.PacketTypes.SMSG_PLAY_ONE_SHOT_ANIM_KIT:
                {
                    PlayOneShotAnimKit monsterMovePacket = (PlayOneShotAnimKit)packet;

                    output += "me->PlayOneShotAnimKitId(" + monsterMovePacket.AnimKitId + ");" + "\r\n";
                    break;
                }

                case Packet.PacketTypes.SMSG_CHAT:
                {
                    ChatPacket chatPacket = (ChatPacket)packet;

                    output += "Text: " + chatPacket.creatureText + "\r\n";
                    break;
                }

                case Packet.PacketTypes.SMSG_EMOTE:
                {
                    EmotePacket emotePacket = (EmotePacket)packet;
                    output += "me->HandleEmoteCommand(" + (EmotePacket.Emote)emotePacket.emoteId + ");" + "\r\n";
                    break;
                }

                case Packet.PacketTypes.SMSG_AURA_UPDATE:
                {
                    AuraUpdatePacket auraPacket = (AuraUpdatePacket)packet;

                    string spellName = ConverNameToCoreFormat(GetSpellName(auraPacket.spellId));

                    output += spellName + " = " + auraPacket.spellId + "\r\n";
                    output += "me->RemoveAura(eSpells::" + spellName + ");" + "\r\n";
                    break;
                }

                case Packet.PacketTypes.SMSG_SET_AI_ANIM_KIT:
                {
                    SetAiAnimKit animKitPacket = (SetAiAnimKit)packet;

                    output += "me->SetAIAnimKitId(" + animKitPacket.AiAnimKitId + ");" + "\r\n";
                    break;
                }

                case Packet.PacketTypes.SMSG_PLAY_SPELL_VISUAL_KIT:
                {
                    PlaySpellVisualKit playSpellVisualKitPacket = (PlaySpellVisualKit)packet;

                    output += "me->SendPlaySpellVisualKit(" + playSpellVisualKitPacket.KitRecId + ", " + playSpellVisualKitPacket.KitType + ", " + playSpellVisualKitPacket.Duration + ");" + "\r\n";
                    break;
                }

                default:
                    break;
                }

                output += "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" + "\r\n";
                output += "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*" + "\r\n";
                output += "/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*" + "\r\n";
            }

            mainForm.textBox_Output.Text = output;
        }