diff --git a/WowPacketParser/App.config b/WowPacketParser/App.config
index a5414ae0d4..6e0d715339 100644
--- a/WowPacketParser/App.config
+++ b/WowPacketParser/App.config
@@ -201,6 +201,8 @@
         <add key="hotfix_optional_data"                   value="false"/>
         <add key="hotfixes"                               value="false"/>
 
+        <add key="creature_movement"                      value="false"/>
+
 
         <!--
                  Option:      ParseAllHotfixes
diff --git a/WowPacketParser/Enums/SQLOutput.cs b/WowPacketParser/Enums/SQLOutput.cs
index a24439a9d5..ca3142a687 100644
--- a/WowPacketParser/Enums/SQLOutput.cs
+++ b/WowPacketParser/Enums/SQLOutput.cs
@@ -19,6 +19,7 @@ public enum SQLOutput
         creature_addon,
         creature_equip_template,
         creature_model_info,
+        creature_movement,
         creature_queststarter,
         creature_questender,
         creature_template,
diff --git a/WowPacketParser/Loading/SniffFile.cs b/WowPacketParser/Loading/SniffFile.cs
index fe23ffffc9..ed1278b410 100644
--- a/WowPacketParser/Loading/SniffFile.cs
+++ b/WowPacketParser/Loading/SniffFile.cs
@@ -83,18 +83,19 @@ private string FileName
             }
         }
 
-        public void ProcessFile()
+        public Packets ProcessFile()
         {
 
             try
             {
-                ProcessFileImpl();
+                return ProcessFileImpl();
             }
             catch (Exception ex)
             {
                 Trace.WriteLine(_logPrefix + " " + ex.GetType());
                 Trace.WriteLine(_logPrefix + " " + ex.Message);
                 Trace.WriteLine(_logPrefix + " " + ex.StackTrace);
+                return new Packets();
             }
             finally
             {
@@ -106,7 +107,7 @@ public void ProcessFile()
             }
         }
 
-        private void ProcessFileImpl()
+        private Packets ProcessFileImpl()
         {
             if (_compression != FileCompression.None)
                 _tempName = Decompress();
@@ -184,9 +185,9 @@ private void ProcessFileImpl()
 
                     var written = false;
 
+                    Packets packets = new() { Version = StructureVersion.ProtobufStructureVersion, DumpType = (uint)Settings.DumpFormat };
                     using (var writer = (Settings.DumpFormatWithTextToFile() ? new StreamWriter(outFileName, true) : null))
                     {
-                        Packets packets = new() { Version = StructureVersion.ProtobufStructureVersion, DumpType = (uint)Settings.DumpFormat };
                         var firstRead = true;
                         var firstWrite = true;
 
@@ -285,7 +286,7 @@ private void ProcessFileImpl()
                             // Close Writer, Stream - Dispose
                             packet.ClosePacket();
 
-                            if (_dumpFormat.IsUniversalProtobufType())
+                            if (_dumpFormat.IsUniversalProtobufType() || Settings.SQLOutputFlag != 0 || HotfixSettings.Instance.ShouldLog())
                                 packets.Packets_.Add(packet.Holder);
                         }, threadCount);
 
@@ -316,14 +317,14 @@ private void ProcessFileImpl()
                     Trace.WriteLine($"{_logPrefix}: {_stats}");
 
                     if (Settings.SQLOutputFlag != 0 || HotfixSettings.Instance.ShouldLog())
-                        WriteSQLs();
+                        WriteSQLs(packets);
 
                     if (Settings.LogPacketErrors)
                         WritePacketErrors();
 
                     GC.Collect(); // Force a GC collect after parsing a file. It seems to help.
 
-                    break;
+                    return packets;
                 }
                 case DumpFormatType.Pkt:
                 {
@@ -478,6 +479,8 @@ private void ProcessFileImpl()
                     break;
                 }
             }
+
+            return new Packets();
         }
 
         public static string GetHeader(string fileName)
@@ -560,14 +563,14 @@ private void BinaryDump(string fileName, ICollection<Packet> packets)
             BinaryPacketWriter.Write(SniffType.Pkt, fileName, Encoding.ASCII, packets);
         }
 
-        private void WriteSQLs()
+        private void WriteSQLs(Packets packets)
         {
             var sqlFileName = string.IsNullOrWhiteSpace(Settings.SQLFileName) ? $"{Utilities.FormattedDateTimeForFiles()}_{Path.GetFileName(FileName)}.sql" : Settings.SQLFileName;
 
             if (!string.IsNullOrWhiteSpace(Settings.SQLFileName))
                 return;
 
-            Builder.DumpSQL($"{_logPrefix}: Dumping sql", sqlFileName, GetHeader(FileName));
+            Builder.DumpSQL(new []{packets}, $"{_logPrefix}: Dumping sql", sqlFileName, GetHeader(FileName));
             Storage.ClearContainers();
         }
 
diff --git a/WowPacketParser/Misc/Extensions.cs b/WowPacketParser/Misc/Extensions.cs
index 66d5421a93..e8c82fc5df 100644
--- a/WowPacketParser/Misc/Extensions.cs
+++ b/WowPacketParser/Misc/Extensions.cs
@@ -56,6 +56,24 @@ public static bool HasAnyFlagBit(this IConvertible value, IConvertible bit)
             return (uThis & uFlag) != 0;
         }
 
+        /// <summary>
+        /// Returns true if bit is set in value (&)
+        /// </summary>
+        /// <param name="value">An enum, int, ...</param>
+        /// <param name="bit">An int</param>
+        /// <returns>A boolean</returns>
+        public static bool HasAnyFlagBit(this UInt128 value, IConvertible bit) // uint128 doesnt implement IConvertible
+        {
+            var uBit = bit.ToInt32(null);
+
+            Contract.Assert(uBit >= 0 && uBit <= 127);
+
+            var uFlag = ((UInt128)1) << uBit;
+            var uThis = value;
+
+            return (uThis & uFlag) != 0;
+        }
+
         /// <summary>
         /// Return true if our string is a substring of any filter (case insensitive)
         /// </summary>
diff --git a/WowPacketParser/Misc/Settings.cs b/WowPacketParser/Misc/Settings.cs
index f44eea14f0..de1a704de3 100644
--- a/WowPacketParser/Misc/Settings.cs
+++ b/WowPacketParser/Misc/Settings.cs
@@ -19,7 +19,7 @@ public static class Settings
         public static readonly TargetedDatabase TargetedDatabase = Conf.GetEnum("TargetedDatabase", TargetedDatabase.WrathOfTheLichKing);
         public static readonly TargetedProject TargetedProject = Conf.GetEnum("TargetedProject", TargetedProject.TrinityCore);
         public static readonly DumpFormatType DumpFormat = Conf.GetEnum("DumpFormat", DumpFormatType.Text);
-        public static readonly ulong SQLOutputFlag = GetSQLOutputFlag();
+        public static readonly UInt128 SQLOutputFlag = GetSQLOutputFlag();
         public static readonly bool SQLOrderByKey = Conf.GetBoolean("SqlOrderByKey", false);
         public static readonly bool SaveTempSpawns = Conf.GetBoolean("SaveTempSpawns", false);
         public static readonly bool SaveExistingSpawns = Conf.GetBoolean("SaveExistingSpawns", false);
@@ -67,17 +67,17 @@ public static class Settings
         public static readonly bool UseDBC = Conf.GetBoolean("UseDBC", false);
         public static readonly bool ParseSpellInfos = Conf.GetBoolean("ParseSpellInfos", false);
 
-        private static ulong GetSQLOutputFlag()
+        private static UInt128 GetSQLOutputFlag()
         {
             var names = Enum.GetNames(typeof(SQLOutput));
             var values = Enum.GetValues(typeof(SQLOutput));
 
-            var result = 0ul;
+            UInt128 result = 0;
 
             for (var i = 0; i < names.Length; ++i)
             {
                 if (Conf.GetBoolean(names[i], false))
-                    result += (1ul << (int)values.GetValue(i));
+                    result += (((UInt128)1) << (int)values.GetValue(i));
             }
 
             return result;
diff --git a/WowPacketParser/PacketStructures/ProtoExtensions.cs b/WowPacketParser/PacketStructures/ProtoExtensions.cs
index b5592c9a0b..e4985ff95a 100644
--- a/WowPacketParser/PacketStructures/ProtoExtensions.cs
+++ b/WowPacketParser/PacketStructures/ProtoExtensions.cs
@@ -256,5 +256,116 @@ public static CreateObjectType ToCreateObjectType(this UpdateTypeCataclysm updat
                 return CreateObjectType.Spawn;
             throw new ArgumentOutOfRangeException();
         }
+
+        public static ObjectType ToObjectType(this UniversalHighGuid highGuid)
+        {
+            switch (highGuid)
+            {
+                case UniversalHighGuid.Player:
+                    return ObjectType.Player;
+                case UniversalHighGuid.DynamicObject:
+                    return ObjectType.DynamicObject;
+                case UniversalHighGuid.Item:
+                    return ObjectType.Item;
+                case UniversalHighGuid.GameObject:
+                case UniversalHighGuid.Transport:
+                    return ObjectType.GameObject;
+                case UniversalHighGuid.Vehicle:
+                case UniversalHighGuid.Creature:
+                case UniversalHighGuid.Pet:
+                    return ObjectType.Unit;
+                case UniversalHighGuid.AreaTrigger:
+                    return ObjectType.AreaTrigger;
+                default:
+                    return ObjectType.Object;
+            }
+        }
+
+        public static string ToWowParserString(this UniversalGuid? guid)
+        {
+            if (guid == null)
+                return "0x0 (null)";
+            if (guid.KindCase == UniversalGuid.KindOneofCase.Guid128 && (guid.Guid128.High != 0 || guid.Guid128.Low != 0))
+            {
+                if (guid.HasEntry())
+                {
+                    // ReSharper disable once UseStringInterpolation
+                    return string.Format("Full: 0x{0:X16}{1:X16} {2}/{3} R{4}/S{5} Map: {6} Entry: {7} Low: {8}", guid.Guid128.High, guid.Guid128.Low,
+                        guid.Type, guid.Guid128.GetSubType(), guid.Guid128.GetRealmId(), guid.Guid128.GetServerId(), guid.Guid128.GetMapId(),
+                        guid.Entry, guid.GetLow());
+                }
+
+                // ReSharper disable once UseStringInterpolation
+                return string.Format("Full: 0x{0:X16}{1:X16} {2}/{3} R{4}/S{5} Map: {6} Low: {7}", guid.Guid128.High, guid.Guid128.Low,
+                    guid.Type, guid.Guid128.GetSubType(), guid.Guid128.GetRealmId(), guid.Guid128.GetServerId(), guid.Guid128.GetMapId(),
+                    guid.GetLow());
+            }
+            else if (guid.KindCase == UniversalGuid.KindOneofCase.Guid64 && (guid.Guid64.High != 0 || guid.Guid64.Low != 0))
+            {
+                if (guid.HasEntry())
+                {
+                    return string.Format("Full: 0x{0:X8} Type: {1} Entry: {2} Low: {0}", guid.GetLow(), guid.Type, guid.Entry);
+                }
+                return string.Format("Full: 0x{0:X8} Type: {1} Low: {0}", guid.GetLow(), guid.Type);
+            }
+
+            return "Full: 0x0";
+        }
+
+        public static uint GetLow(this UniversalGuid guid)
+        {
+            if (guid.KindCase == UniversalGuid.KindOneofCase.Guid128)
+                return (uint)(guid.Guid128.Low & 0xFFFFFFFFFF);
+            else if (guid.KindCase == UniversalGuid.KindOneofCase.Guid64)
+            {
+                switch (guid.Type)
+                {
+                    case UniversalHighGuid.Player:
+                    case UniversalHighGuid.DynamicObject:
+                    case UniversalHighGuid.RaidGroup:
+                    case UniversalHighGuid.Item:
+                        return (uint)(guid.Guid64.Low & 0x000FFFFFFFFFFFFF);
+                    case UniversalHighGuid.GameObject:
+                    case UniversalHighGuid.Transport:
+                    //case HighGuidType.MOTransport: ??
+                    case UniversalHighGuid.Vehicle:
+                    case UniversalHighGuid.Creature:
+                    case UniversalHighGuid.Pet:
+                        return (uint)(guid.Guid64.Low & 0x00000000FFFFFFFFul);
+                }
+
+                return (uint)(guid.Guid64.Low & 0x00000000FFFFFFFFul);
+            }
+
+            return 0;
+        }
+
+        public static uint GetEntry(this UniversalGuid128 guid)
+        {
+            return (uint)((guid.High >> 6) & 0x7FFFFF);
+        }
+
+        public static byte GetSubType(this UniversalGuid128 guid) => (byte)(guid.High & 0x3F);
+
+        public static ushort GetRealmId(this UniversalGuid128 guid) => (ushort)((guid.High >> 42) & 0x1FFF);
+
+        public static uint GetServerId(this UniversalGuid128 guid) => (uint)((guid.Low >> 40) & 0xFFFFFF);
+
+        public static ushort GetMapId(this UniversalGuid128 guid) => (ushort)((guid.High >> 29) & 0x1FFF);
+
+        public static bool HasEntry(this UniversalGuid guid)
+        {
+            switch (guid.Type)
+            {
+                case UniversalHighGuid.Creature:
+                case UniversalHighGuid.GameObject:
+                case UniversalHighGuid.Pet:
+                case UniversalHighGuid.Vehicle:
+                case UniversalHighGuid.AreaTrigger:
+                    return true;
+                default:
+                    return false;
+            }
+        }
     }
 }
diff --git a/WowPacketParser/Parsing/Proto/BaseProtoQueryBuilder.cs b/WowPacketParser/Parsing/Proto/BaseProtoQueryBuilder.cs
new file mode 100644
index 0000000000..30c4b8caec
--- /dev/null
+++ b/WowPacketParser/Parsing/Proto/BaseProtoQueryBuilder.cs
@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using WowPacketParser.Proto;
+using WowPacketParser.Proto.Processing;
+
+namespace WowPacketParser.Parsing.Proto;
+
+public abstract class BaseProtoQueryBuilder : PacketProcessor<VoidType>, IProtoQueryBuilder
+{
+    public abstract bool IsEnabled();
+
+    public string Process(IReadOnlyList<Packets> packetsList)
+    {
+        foreach (var sniffFile in packetsList)
+        {
+            // more complex logic is possible, i.e. clear state after each file
+            foreach (var packet in sniffFile.Packets_)
+            {
+                Process(packet);
+            }
+        }
+
+        return GenerateQuery();
+    }
+
+    protected abstract string GenerateQuery();
+}
\ No newline at end of file
diff --git a/WowPacketParser/Parsing/Proto/IProtoQueryBuilder.cs b/WowPacketParser/Parsing/Proto/IProtoQueryBuilder.cs
new file mode 100644
index 0000000000..e9b08dc6aa
--- /dev/null
+++ b/WowPacketParser/Parsing/Proto/IProtoQueryBuilder.cs
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using WowPacketParser.Proto;
+
+namespace WowPacketParser.Parsing.Proto;
+
+public interface IProtoQueryBuilder
+{
+    bool IsEnabled();
+    string Process(IReadOnlyList<Packets> packets);
+}
\ No newline at end of file
diff --git a/WowPacketParser/Parsing/Proto/VoidType.cs b/WowPacketParser/Parsing/Proto/VoidType.cs
new file mode 100644
index 0000000000..7d0e7f8203
--- /dev/null
+++ b/WowPacketParser/Parsing/Proto/VoidType.cs
@@ -0,0 +1,3 @@
+namespace WowPacketParser.Parsing.Proto;
+
+public struct VoidType { }
\ No newline at end of file
diff --git a/WowPacketParser/Program.cs b/WowPacketParser/Program.cs
index 465d284678..6dcc040cc2 100644
--- a/WowPacketParser/Program.cs
+++ b/WowPacketParser/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
 using System.IO;
@@ -7,6 +8,7 @@
 using WowPacketParser.Loading;
 using WowPacketParser.Misc;
 using WowPacketParser.Parsing.Parsers;
+using WowPacketParser.Proto;
 using WowPacketParser.SQL;
 
 namespace WowPacketParser
@@ -58,6 +60,8 @@ private static void Main(string[] args)
 
             SQLConnector.ReadDB();
 
+            List<Packets> parserPacketsList = new();
+
             var processStartTime = DateTime.Now;
             var count = 0;
             foreach (var file in files)
@@ -71,7 +75,7 @@ private static void Main(string[] args)
                 try
                 {
                     var sf = new SniffFile(file, Settings.DumpFormat, Tuple.Create(++count, files.Count));
-                    sf.ProcessFile();
+                    parserPacketsList.Add(sf.ProcessFile());
                 }
                 catch (IOException ex)
                 {
@@ -80,7 +84,7 @@ private static void Main(string[] args)
             }
 
             if (!string.IsNullOrWhiteSpace(Settings.SQLFileName) && Settings.DumpFormatWithSQL())
-                Builder.DumpSQL("Dumping global sql", Settings.SQLFileName, SniffFile.GetHeader("multi"));
+                Builder.DumpSQL(parserPacketsList, "Dumping global sql", Settings.SQLFileName, SniffFile.GetHeader("multi"));
 
             var processTime = DateTime.Now.Subtract(processStartTime);
             Trace.WriteLine($"Processing {files.Count} sniffs took { processTime.ToFormattedString() }.");
diff --git a/WowPacketParser/SQL/Builder.cs b/WowPacketParser/SQL/Builder.cs
index df0d0bfc3e..01965204e9 100644
--- a/WowPacketParser/SQL/Builder.cs
+++ b/WowPacketParser/SQL/Builder.cs
@@ -5,6 +5,8 @@
 using System.Reflection;
 using WowPacketParser.Enums;
 using WowPacketParser.Misc;
+using WowPacketParser.Parsing.Proto;
+using WowPacketParser.Proto;
 using WowPacketParser.SQL.Builders;
 using WowPacketParser.Store;
 using WowPacketParser.Store.Objects;
@@ -63,16 +65,39 @@ private static void LoadNames()
             }
         }
 
-        public static void DumpFile(string prefix, string fileName, string header, List<MethodInfo> builderMethods, Dictionary<WowGuid, Unit> units, Dictionary<WowGuid, GameObject> gameObjects)
+        public static void DumpFile(IReadOnlyList<Packets> packets, string prefix, string fileName, string header, List<Type> protoBuilders, List<MethodInfo> builderMethods, Dictionary<WowGuid, Unit> units, Dictionary<WowGuid, GameObject> gameObjects)
         {
             var startTime = DateTime.Now;
             using (var store = new SQLFile(fileName))
             {
                 store.WriteData(UnitMisc.CreatureEquip(units)); // ensure this is run before spawns
 
-                for (int i = 1; i <= builderMethods.Count; i++)
+                var currentBuilder = 0;
+                var totalCount = protoBuilders.Count + builderMethods.Count;
+
+                foreach (var builderType in protoBuilders)
+                {
+                    currentBuilder++;
+                    var builder = (IProtoQueryBuilder)Activator.CreateInstance(builderType);
+
+                    if (!builder.IsEnabled())
+                        continue;
+
+                    Trace.WriteLine($"{currentBuilder}/{totalCount} - Write {builderType}");
+                    try
+                    {
+                        store.WriteData(builder.Process(packets));
+                    }
+                    catch (TargetInvocationException e)
+                    {
+                        Trace.WriteLine($"{currentBuilder}/{totalCount} - Error: Failed writing {builderType}");
+                        Trace.TraceError(e.InnerException?.ToString() ?? e.ToString());
+                    }
+                }
+
+                foreach (var method in builderMethods)
                 {
-                    var method = builderMethods[i - 1];
+                    currentBuilder++;
                     var attr = method.GetCustomAttribute<BuilderMethodAttribute>();
 
                     if (attr.CheckVersionMismatch)
@@ -80,7 +105,7 @@ public static void DumpFile(string prefix, string fileName, string header, List<
                         if (!GetExpectedTargetDatabasesForExpansion(ClientVersion.Expansion).Contains(Settings.TargetedDatabase))
                         {
                             Trace.WriteLine(
-                                $"{i}/{builderMethods.Count} - Error: Couldn't generate SQL output of {method.Name} since the targeted database and the sniff version don't match.");
+                                $"{currentBuilder}/{totalCount} - Error: Couldn't generate SQL output of {method.Name} since the targeted database and the sniff version don't match.");
                             continue;
                         }
                     }
@@ -92,14 +117,14 @@ public static void DumpFile(string prefix, string fileName, string header, List<
                     if (attr.Gameobjects)
                         parameters.Add(gameObjects);
 
-                    Trace.WriteLine($"{i}/{builderMethods.Count} - Write {method.Name}");
+                    Trace.WriteLine($"{currentBuilder}/{totalCount} - Write {method.Name}");
                     try
                     {
                         store.WriteData(method.Invoke(null, parameters.ToArray()).ToString());
                     }
                     catch (TargetInvocationException e)
                     {
-                        Trace.WriteLine($"{i}/{builderMethods.Count} - Error: Failed writing {method.Name}");
+                        Trace.WriteLine($"{currentBuilder}/{totalCount} - Error: Failed writing {method.Name}");
                         Trace.TraceError(e.InnerException?.ToString() ?? e.ToString());
                     }
                 }
@@ -113,7 +138,7 @@ public static void DumpFile(string prefix, string fileName, string header, List<
             }
         }
 
-        public static void DumpSQL(string prefix, string fileName, string header)
+        public static void DumpSQL(IReadOnlyList<Packets> packets, string prefix, string fileName, string header)
         {
             var startTime = DateTime.Now;
 
@@ -140,23 +165,33 @@ public static void DumpSQL(string prefix, string fileName, string header)
                     .SelectMany(x => x.GetMethods());
             var allMethods = methods.Select(y => new { Method = y, Attributes = y.GetCustomAttributes().OfType<BuilderMethodAttribute>()}).Where(y => y.Attributes.Any()).ToList();
 
+            var allProtoBuilders = Assembly.GetExecutingAssembly()
+                .GetTypes()
+                .Select(type => (Type: type, Attributes: type.GetCustomAttributes(typeof(ProtoBuilderClassAttribute), true).OfType<ProtoBuilderClassAttribute>().ToList()))
+                .Where(pair => pair.Attributes.Count > 0)
+                .ToList();
+
             if (Settings.SplitSQLFile)
             {
                 fileName = System.IO.Path.ChangeExtension(fileName, null); // remove .sql
 
                 var hotfixMethods = allMethods.Where(x => x.Attributes.First().Database == TargetSQLDatabase.Hotfixes).Select(x => x.Method).ToList();
-                DumpFile(prefix, $"{fileName}_hotfixes.sql", header, hotfixMethods, units, gameObjects);
+                var hotfixProtoBuilders = allProtoBuilders.Where(x => x.Attributes.First().Database == TargetSQLDatabase.Hotfixes).Select(x => x.Type).ToList();
+                DumpFile(packets, prefix, $"{fileName}_hotfixes.sql", header, hotfixProtoBuilders, hotfixMethods, units, gameObjects);
 
                 var worldMethods = allMethods.Where(x => x.Attributes.First().Database == TargetSQLDatabase.World).Select(x => x.Method).ToList();
-                DumpFile(prefix, $"{fileName}_world.sql", header, worldMethods, units, gameObjects);
+                var worldProtoBuilders = allProtoBuilders.Where(x => x.Attributes.First().Database == TargetSQLDatabase.World).Select(x => x.Type).ToList();
+                DumpFile(packets, prefix, $"{fileName}_world.sql", header, worldProtoBuilders, worldMethods, units, gameObjects);
 
                 var wppMethods = allMethods.Where(x => x.Attributes.First().Database == TargetSQLDatabase.WPP).Select(x => x.Method).ToList();
-                DumpFile(prefix, $"{fileName}_wpp.sql", header, wppMethods, units, gameObjects);
+                var wppProtoBuilders = allProtoBuilders.Where(x => x.Attributes.First().Database == TargetSQLDatabase.WPP).Select(x => x.Type).ToList();
+                DumpFile(packets, prefix, $"{fileName}_wpp.sql", header, wppProtoBuilders, wppMethods, units, gameObjects);
             }
             else
             {
+                var protoBuilderTypes = allProtoBuilders.Select(x => x.Type).ToList();
                 var builderMethods = allMethods.Select(x => x.Method).ToList();
-                DumpFile(prefix, fileName, header, builderMethods, units, gameObjects);
+                DumpFile(packets, prefix, fileName, header, protoBuilderTypes, builderMethods, units, gameObjects);
             }
         }
 
diff --git a/WowPacketParser/SQL/Builders/BuilderAttributes.cs b/WowPacketParser/SQL/Builders/BuilderAttributes.cs
index 68c2f5d2dd..9acb063770 100644
--- a/WowPacketParser/SQL/Builders/BuilderAttributes.cs
+++ b/WowPacketParser/SQL/Builders/BuilderAttributes.cs
@@ -55,4 +55,39 @@ public BuilderMethodAttribute(bool checkVersionMissmatch, TargetSQLDatabase data
     public sealed class BuilderClassAttribute : Attribute
     {
     }
+
+    [AttributeUsage(AttributeTargets.Class)]
+    public sealed class ProtoBuilderClassAttribute : Attribute
+    {
+        public ProtoBuilderClassAttribute()
+        {
+            Database = TargetSQLDatabase.World;
+        }
+        public ProtoBuilderClassAttribute(TargetSQLDatabase database)
+        {
+            Database = database;
+        }
+
+        public ProtoBuilderClassAttribute(bool checkVersionMissmatch)
+        {
+            Database = TargetSQLDatabase.World;
+            CheckVersionMismatch = checkVersionMissmatch;
+        }
+
+        public ProtoBuilderClassAttribute(bool checkVersionMissmatch, TargetSQLDatabase database)
+        {
+            Database = database;
+            CheckVersionMismatch = checkVersionMissmatch;
+        }
+
+        /// <summary>
+        /// True if mismatch between targeted database and sniff version should be checked
+        /// </summary>
+        public bool CheckVersionMismatch { get; private set; }
+
+        // <summary>
+        // Defines the targeted database
+        // </summary>
+        public TargetSQLDatabase Database;
+    }
 }
diff --git a/WowPacketParser/SQL/Builders/Movement.cs b/WowPacketParser/SQL/Builders/Movement.cs
new file mode 100644
index 0000000000..a5e9a17f0d
--- /dev/null
+++ b/WowPacketParser/SQL/Builders/Movement.cs
@@ -0,0 +1,150 @@
+using System.Collections.Generic;
+using System.Text;
+using WowPacketParser.Enums;
+using WowPacketParser.Misc;
+using WowPacketParser.PacketStructures;
+using WowPacketParser.Parsing.Proto;
+using WowPacketParser.Proto;
+
+namespace WowPacketParser.SQL.Builders
+{
+    [ProtoBuilderClass]
+    public class Movement : BaseProtoQueryBuilder
+    {
+        private struct Waypoint
+        {
+            public Vec3 Position { get; init; }
+            public float Orientation { get; init; }
+        }
+
+        public enum PathType
+        {
+            None                    = 0, // pathfinding
+            ExactPath               = 1, // sent fully
+            ExactPathFlying         = 2, // sent fully + flying flag
+            ExactPathFlyingCyclic   = 3, // sent fully + flying flag + cyclic flag
+            ExactPathAndJump        = 4, // sent fully + parabolic movement at the end
+            Invalid                 = 100,
+        }
+
+        private class Path
+        {
+            public List<Waypoint> Waypoints { get; init; }
+            public PathType Type { get; init; }
+        }
+
+        private Dictionary<UniversalGuid, List<Path>> pathsPerGuid = new();
+
+        public override bool IsEnabled() => Settings.SQLOutputFlag.HasAnyFlagBit(SQLOutput.creature_movement) &&
+                                            Settings.TargetedProject is TargetedProject.Cmangos or TargetedProject.TrinityCore;
+
+        private PathType GetMovementType(PacketMonsterMove packet)
+        {
+            PathType flags = PathType.None;
+            if (packet.Flags.HasFlag(UniversalSplineFlag.EnterCycle) || packet.Flags.HasFlag(UniversalSplineFlag.Cyclic))
+                flags = PathType.ExactPathFlyingCyclic;
+            else if (packet.Flags.HasFlag(UniversalSplineFlag.Flying))
+                flags = PathType.ExactPathFlying;
+            else if (packet.Flags.HasFlag(UniversalSplineFlag.UncompressedPath))
+                flags = PathType.ExactPath;
+            else if (packet.LookTarget != null)
+                flags = PathType.Invalid;
+            else if (packet.Jump != null && packet.Jump.StartTime > 0)
+                flags = PathType.ExactPathAndJump;
+            return flags;
+        }
+
+        protected override VoidType Process(PacketBase basePacket, PacketMonsterMove packet)
+        {
+            if (packet.PackedPoints.Count == 0)
+                return default;
+
+            var movementType = GetMovementType(packet);
+            if (movementType == PathType.Invalid)
+                return default;
+
+            Path path = new Path()
+            {
+                Waypoints = new List<Waypoint>(),
+                Type = movementType
+            };
+
+            for (var index = 0; index < packet.PackedPoints.Count; index++)
+            {
+                var node = packet.PackedPoints[index];
+                bool finalP = packet.Destination == null && packet.PackedPoints.Count - 1 != index;
+                float ori = finalP ? (packet.HasLookOrientation ? packet.LookOrientation : 100f) : 100f;
+                path.Waypoints.Add(new Waypoint()
+                {
+                    Position = node,
+                    Orientation = ori
+                });
+            }
+
+            if (packet.Destination != null)
+            {
+                float ori = packet.HasLookOrientation ? packet.LookOrientation : 100f;
+                path.Waypoints.Add(new Waypoint()
+                {
+                    Position = packet.Destination,
+                    Orientation = ori
+                });
+            }
+
+            if (!pathsPerGuid.TryGetValue(packet.Mover, out var pathList))
+            {
+                pathList = new List<Path>();
+                pathsPerGuid.Add(packet.Mover, pathList);
+            }
+            pathList.Add(path);
+
+            return default;
+        }
+
+        protected override string GenerateQuery()
+        {
+            StringBuilder output = new();
+            output.AppendLine("SET @MOVID = 0;");
+            int pathIdCounter = 0;
+            foreach (var (mover, paths) in pathsPerGuid)
+            {
+                foreach (var path in paths)
+                {
+                    string commentInformation = $"GUID: {mover.ToWowParserString()} PathType: {path.Type}";
+                    output.AppendLine("-- " + commentInformation);
+                    if (Settings.TargetedProject == TargetedProject.Cmangos)
+                    {
+                        output.AppendLine($"INSERT INTO waypoint_path_name(PathId, Name) VALUES(@MOVID + {pathIdCounter},'{SQLUtil.EscapeString(StoreGetters.GetName(Utilities.ObjectTypeToStore(mover.Type.ToObjectType()), (int)mover.Entry))}');");
+                        output.AppendLine("INSERT INTO waypoint_path (PathId, Point, PositionX, PositionY, PositionZ, Orientation, WaitTime, ScriptId, Comment) VALUES");
+                    }
+                    else if (Settings.TargetedProject == TargetedProject.TrinityCore)
+                    {
+                        output.AppendLine("INSERT INTO waypoint_path_node (PathId, NodeId, PositionX, PositionY, PositionZ, Orientation, Delay) VALUES");
+                    }
+
+                    int pointIdCounter = 1;
+                    foreach (var node in path.Waypoints)
+                    {
+                        var isLast = pointIdCounter == path.Waypoints.Count;
+                        if (Settings.TargetedProject == TargetedProject.Cmangos)
+                            output.Append($"(@MOVID + {pathIdCounter}, {pointIdCounter}, {node.Position.X}, {node.Position.Y}, {node.Position.Z}, {node.Orientation}, 0, 0, NULL)");
+                        else if (Settings.TargetedProject == TargetedProject.TrinityCore)
+                            output.Append($"(@MOVID + {pathIdCounter}, {pointIdCounter}, {node.Position.X}, {node.Position.Y}, {node.Position.Z}, {node.Orientation})");
+
+                        if (!isLast)
+                            output.AppendLine(",");
+                        else
+                            output.AppendLine(";");
+
+                        ++pointIdCounter;
+                    }
+
+                    ++pathIdCounter;
+
+                    output.AppendLine();
+                }
+            }
+            return output.ToString();
+        }
+    }
+}
diff --git a/WowPacketParser/Store/StoreDictionaries.cs b/WowPacketParser/Store/StoreDictionaries.cs
index e76d0f519d..f8650f5948 100644
--- a/WowPacketParser/Store/StoreDictionaries.cs
+++ b/WowPacketParser/Store/StoreDictionaries.cs
@@ -12,7 +12,7 @@ namespace WowPacketParser.Store
 {
     public abstract class Store
     {
-        public static ulong SQLEnabledFlags { protected get; set; }
+        public static UInt128 SQLEnabledFlags { protected get; set; }
         public List<SQLOutput> Types { get; protected set; }
 
         protected bool ProcessFlags()
diff --git a/WowPacketParserModule.V8_0_1_27101/Parsers/MovementHandler.cs b/WowPacketParserModule.V8_0_1_27101/Parsers/MovementHandler.cs
index aaac430d2a..6c2f58231b 100644
--- a/WowPacketParserModule.V8_0_1_27101/Parsers/MovementHandler.cs
+++ b/WowPacketParserModule.V8_0_1_27101/Parsers/MovementHandler.cs
@@ -6,6 +6,8 @@
 using WowPacketParser.Misc;
 using WowPacketParser.Parsing;
 using WowPacketParser.Proto;
+using WowPacketParser.Store;
+using WowPacketParserModule.V6_0_2_19033.Parsers;
 using WowPacketParserModule.V7_0_3_22248.Enums;
 using CoreParsers = WowPacketParser.Parsing.Parsers;
 using SplineFacingType = WowPacketParserModule.V6_0_2_19033.Enums.SplineFacingType;
@@ -54,7 +56,9 @@ public static SplineJump ReadMonsterSplineJumpExtraData(Packet packet, params ob
         public static void ReadMovementSpline(Packet packet, Vector3 pos, params object[] indexes)
         {
             PacketMonsterMove monsterMove = packet.Holder.MonsterMove;
-            monsterMove.Flags = packet.ReadUInt32E<SplineFlag>("Flags", indexes).ToUniversal();
+            var splineFlag = packet.ReadUInt32E<SplineFlag>("Flags", indexes);
+            monsterMove.Flags = splineFlag.ToUniversal();
+
             if (ClientVersion.RemovedInVersion(ClientType.Shadowlands))
             {
                 packet.ReadByte("AnimTier", indexes);
@@ -144,7 +148,9 @@ public static void ReadMovementSpline(Packet packet, Vector3 pos, params object[
                 ReadMonsterSplineSpellEffectExtraData(packet, indexes, "MonsterSplineSpellEffectExtra");
 
             if (hasJumpExtraData)
+            {
                 monsterMove.Jump = ReadMonsterSplineJumpExtraData(packet, indexes, "MonsterSplineJumpExtraData");
+            }
 
             if (hasAnimTier)
             {
@@ -190,12 +196,15 @@ public static void ReadMovementSpline(Packet packet, Vector3 pos, params object[
             packet.AddValue("CalculatedSpeedXY", speedXY, indexes);
         }
 
-        public static void ReadMovementMonsterSpline(Packet packet, Vector3 pos, params object[] indexes)
+        public static void ReadMovementMonsterSpline(Packet packet, Vector3 pos, WowGuid guid, params object[] indexes)
         {
             PacketMonsterMove monsterMove = packet.Holder.MonsterMove;
             monsterMove.Id = packet.ReadUInt32("Id", indexes);
             if (ClientVersion.RemovedInVersion(ClientBranch.Retail, ClientVersionBuild.V10_2_0_52038) || ClientVersion.Branch != ClientBranch.Retail)
-                monsterMove.Destination = packet.ReadVector3("Destination", indexes);
+            {
+                var destination = packet.ReadVector3("Destination", indexes);
+                monsterMove.Destination = destination;
+            }
 
             packet.ResetBitReader();
 
@@ -209,10 +218,11 @@ public static void ReadMovementMonsterSpline(Packet packet, Vector3 pos, params
         public static void HandleOnMonsterMove(Packet packet)
         {
             PacketMonsterMove monsterMove = packet.Holder.MonsterMove = new();
-            monsterMove.Mover = packet.ReadPackedGuid128("MoverGUID");
+            var moverGuid = packet.ReadPackedGuid128("MoverGUID");
+            monsterMove.Mover = moverGuid;
             Vector3 pos = monsterMove.Position = packet.ReadVector3("Position");
 
-            ReadMovementMonsterSpline(packet, pos, "MovementMonsterSpline");
+            ReadMovementMonsterSpline(packet, pos, moverGuid, "MovementMonsterSpline");
         }
 
         [Parser(Opcode.SMSG_PHASE_SHIFT_CHANGE)]