Core/Movement: Refactor MoveSplineFlag to get rid of undefined behavior (cast in raw()) and unify enum to string formatting for it

8 files changed, 353 insertions, 258 deletions

diff --git a/src/server/game/Movement/Spline/MoveSpline.cpp b/src/server/game/Movement/Spline/MoveSpline.cpp
index fba77681236..e22c8c634b9 100644
--- a/src/server/game/Movement/Spline/MoveSpline.cpp
+++ b/src/server/game/Movement/Spline/MoveSpline.cpp
@@ -37,14 +37,14 @@ Location MoveSpline::computePosition(int32 time_point, int32 point_index) const
     c.orientation = initialOrientation;
     spline.evaluate_percent(point_index, u, c);
 
-    if (splineflags.animation)
+    if (splineflags.Animation)
         ;// MoveSplineFlag::Animation disables falling or parabolic movement
-    else if (splineflags.parabolic)
+    else if (splineflags.Parabolic)
         computeParabolicElevation(time_point, c.z);
-    else if (splineflags.falling)
+    else if (splineflags.Falling)
         computeFallElevation(time_point, c.z);
 
-    if (splineflags.done && facing.type != MONSTER_MOVE_NORMAL)
+    if (splineflags.Done && facing.type != MONSTER_MOVE_NORMAL)
     {
         if (facing.type == MONSTER_MOVE_FACING_ANGLE)
             c.orientation = facing.angle;
@@ -54,7 +54,7 @@ Location MoveSpline::computePosition(int32 time_point, int32 point_index) const
     }
     else
     {
-        if (!splineflags.hasFlag(MoveSplineFlag::OrientationFixed | MoveSplineFlag::Falling | MoveSplineFlag::Unknown_0x8))
+        if (!splineflags.HasFlag(MoveSplineFlagEnum::OrientationFixed | MoveSplineFlagEnum::Falling | MoveSplineFlagEnum::Unknown_0x8))
         {
             Vector3 hermite;
             spline.evaluate_derivative(point_Idx, u, hermite);
@@ -62,7 +62,7 @@ Location MoveSpline::computePosition(int32 time_point, int32 point_index) const
                 c.orientation = std::atan2(hermite.y, hermite.x);
         }
 
-        if (splineflags.backward)
+        if (splineflags.Backward)
             c.orientation = c.orientation - float(M_PI);
     }
     return c;
@@ -148,10 +148,10 @@ struct CommonInitializer
 void MoveSpline::init_spline(MoveSplineInitArgs const& args)
 {
     static SplineBase::EvaluationMode const modes[2] = { SplineBase::ModeLinear, SplineBase::ModeCatmullrom };
-    if (args.flags.cyclic)
+    if (args.flags.Cyclic)
     {
         uint32 cyclic_point = 0;
-        if (splineflags.enter_cycle)
+        if (splineflags.Enter_Cycle)
             cyclic_point = 1;   // shouldn't be modified, came from client
         spline.init_cyclic_spline(&args.path[0], args.path.size(), modes[args.flags.isSmooth()], cyclic_point, args.initialOrientation);
     }
@@ -159,7 +159,7 @@ void MoveSpline::init_spline(MoveSplineInitArgs const& args)
         spline.init_spline(&args.path[0], args.path.size(), modes[args.flags.isSmooth()], args.initialOrientation);
 
     // init spline timestamps
-    if (splineflags.falling)
+    if (splineflags.Falling)
     {
         FallInitializer init(spline.getPoint(spline.first()).z);
         spline.initLengths(init);
@@ -197,7 +197,7 @@ void MoveSpline::Initialize(MoveSplineInitArgs const& args)
     velocity = args.velocity;
 
     // Check if its a stop spline
-    if (args.flags.done)
+    if (args.flags.Done)
     {
         spline.clear();
         return;
@@ -207,14 +207,14 @@ void MoveSpline::Initialize(MoveSplineInitArgs const& args)
 
     // init parabolic / animation
     // spline initialized, duration known and i able to compute parabolic acceleration
-    if (args.flags & (MoveSplineFlag::Parabolic | MoveSplineFlag::Animation | MoveSplineFlag::FadeObject))
+    if (args.flags.HasFlag(MoveSplineFlagEnum::Parabolic | MoveSplineFlagEnum::Animation | MoveSplineFlagEnum::FadeObject))
     {
         int32 spline_duration = Duration();
         effect_start_time = spline_duration * args.effect_start_time_percent + args.effect_start_time.count();
         if (effect_start_time > spline_duration)
             effect_start_time = spline_duration;
 
-        if (args.flags.parabolic && effect_start_time < spline_duration)
+        if (args.flags.Parabolic && effect_start_time < spline_duration)
         {
             if (args.parabolic_amplitude != 0.0f)
             {
@@ -233,7 +233,7 @@ MoveSpline::MoveSpline() : m_Id(0), time_passed(0),
     vertical_acceleration(0.f), initialOrientation(0.f), effect_start_time(0), point_Idx(0), point_Idx_offset(0), velocity(0.f),
     onTransport(false), splineIsFacingOnly(false)
 {
-    splineflags.done = true;
+    splineflags.Done = true;
 }
 
 /// ============================================================================================
@@ -284,11 +284,11 @@ bool MoveSplineInitArgs::_checkPathLengths()
                 return false;
 
             // when compression is enabled, each point coord is packed into 11 bits (10 for Z)
-            if (!flags.uncompressedPath)
+            if (!flags.UncompressedPath)
                 if (!isValidPackedXYOffset(std::fabs(path[i].x - middle.x))
                     || !isValidPackedXYOffset(std::fabs(path[i].y - middle.y))
                     || !isValidPackedZOffset(std::fabs(path[i].z - middle.z)))
-                    flags.uncompressedPath = true;
+                    flags.UncompressedPath = true;
         }
     }
     return true;
@@ -340,9 +340,9 @@ MoveSpline::UpdateResult MoveSpline::_updateState(int32& ms_time_diff)
 
                 // Remove first point from the path after one full cycle.
                 // That point was the position of the unit prior to entering the cycle and it shouldn't be repeated with continuous cycles.
-                if (splineflags.enter_cycle)
+                if (splineflags.Enter_Cycle)
                 {
-                    splineflags.enter_cycle = false;
+                    splineflags.Enter_Cycle = false;
 
                     MoveSplineInitArgs args{ (size_t)spline.getPointCount() };
                     args.path.assign(spline.getPoints().begin() + spline.first() + 1, spline.getPoints().begin() + spline.last());
@@ -407,7 +407,7 @@ std::string MoveSpline::ToString() const
 
 void MoveSpline::_Finalize()
 {
-    splineflags.done = true;
+    splineflags.Done = true;
     point_Idx = spline.last() - 1;
     time_passed = Duration();
 }
diff --git a/src/server/game/Movement/Spline/MoveSpline.h b/src/server/game/Movement/Spline/MoveSpline.h
index c37fbec0f52..df68e6c2369 100644
--- a/src/server/game/Movement/Spline/MoveSpline.h
+++ b/src/server/game/Movement/Spline/MoveSpline.h
@@ -106,7 +106,7 @@ namespace Movement
         int32 _currentSplineIdx() const { return point_Idx; }
         float Velocity() const { return velocity; }
         void _Finalize();
-        void _Interrupt() { splineflags.done = true; }
+        void _Interrupt() { splineflags.Done = true; }
 
     public:
         void Initialize(MoveSplineInitArgs const&);
@@ -134,9 +134,9 @@ namespace Movement
         Location ComputePosition(int32 time_offset) const;
 
         uint32 GetId() const { return m_Id; }
-        bool Finalized() const { return splineflags.done; }
-        bool isCyclic() const { return splineflags.cyclic; }
-        bool isFalling() const { return splineflags.falling; }
+        bool Finalized() const { return splineflags.Done; }
+        bool isCyclic() const { return splineflags.Cyclic; }
+        bool isFalling() const { return splineflags.Falling; }
         Vector3 const& FinalDestination() const { return Initialized() ? spline.getPoint(spline.last()) : Vector3::zero(); }
         Vector3 const& CurrentDestination() const { return Initialized() ? spline.getPoint(point_Idx + 1) : Vector3::zero(); }
         int32 currentPathIdx() const;
diff --git a/src/server/game/Movement/Spline/MoveSplineFlag.h b/src/server/game/Movement/Spline/MoveSplineFlag.h
index 5936f8d7067..0434657df25 100644
--- a/src/server/game/Movement/Spline/MoveSplineFlag.h
+++ b/src/server/game/Movement/Spline/MoveSplineFlag.h
@@ -19,124 +19,145 @@
 #define TRINITYSERVER_MOVESPLINEFLAG_H
 
 #include "Define.h"
+#include "EnumFlag.h"
 #include <string>
 
 namespace Movement
 {
-#pragma pack(push, 1)
+    // EnumUtils: DESCRIBE THIS
+    enum class MoveSplineFlagEnum : uint32
+    {
+        None                = 0x00000000,
+        Unknown_0x1         = 0x00000001,           // NOT VERIFIED
+        Unknown_0x2         = 0x00000002,           // NOT VERIFIED
+        Unknown_0x4         = 0x00000004,           // NOT VERIFIED
+        Unknown_0x8         = 0x00000008,           // NOT VERIFIED - does someting related to falling/fixed orientation
+        FallingSlow         = 0x00000010,
+        Done                = 0x00000020,
+        Falling             = 0x00000040,           // Affects elevation computation, can't be combined with Parabolic flag
+        No_Spline           = 0x00000080,
+        Unknown_0x100       = 0x00000100,           // NOT VERIFIED
+        Flying              = 0x00000200,           // Smooth movement(Catmullrom interpolation mode), flying animation
+        OrientationFixed    = 0x00000400,           // Model orientation fixed
+        Catmullrom          = 0x00000800,           // Used Catmullrom interpolation mode
+        Cyclic              = 0x00001000,           // Movement by cycled spline
+        Enter_Cycle         = 0x00002000,           // Everytimes appears with cyclic flag in monster move packet, erases first spline vertex after first cycle done
+        Frozen              = 0x00004000,           // Will never arrive
+        TransportEnter      = 0x00008000,
+        TransportExit       = 0x00010000,
+        Unknown_0x20000     = 0x00020000,           // NOT VERIFIED
+        Unknown_0x40000     = 0x00040000,           // NOT VERIFIED
+        Backward            = 0x00080000,
+        SmoothGroundPath    = 0x00100000,
+        CanSwim             = 0x00200000,
+        UncompressedPath    = 0x00400000,
+        Unknown_0x800000    = 0x00800000,           // NOT VERIFIED
+        FastSteering        = 0x01000000,           // Predicts spline only 500ms into the future for smoothing instead of 1s (making turns sharper) and turns off clientside obstacle detection
+        Animation           = 0x02000000,           // Plays animation after some time passed
+        Parabolic           = 0x04000000,           // Affects elevation computation, can't be combined with Falling flag
+        FadeObject          = 0x08000000,
+        Steering            = 0x10000000,
+        UnlimitedSpeed      = 0x20000000,
+        Unknown_0x40000000  = 0x40000000,           // NOT VERIFIED
+        Unknown_0x80000000  = 0x80000000,           // NOT VERIFIED
+
+        // Masks
+        // flags that shouldn't be appended into SMSG_MONSTER_MOVE\SMSG_MONSTER_MOVE_TRANSPORT packet, should be more probably
+        Mask_No_Monster_Move = Done, // SKIP
+        // Unused, not suported flags
+        Mask_Unused         = No_Spline | Enter_Cycle | Frozen | Unknown_0x8 | Unknown_0x100 | Unknown_0x20000 | Unknown_0x40000
+                            | Unknown_0x800000 | FastSteering | FadeObject | UnlimitedSpeed | Unknown_0x40000000 | Unknown_0x80000000 // SKIP
+    };
+
+    DEFINE_ENUM_FLAG(MoveSplineFlagEnum);
 
-    class MoveSplineFlag
+    consteval MoveSplineFlagEnum GetDisallowedFlagsFor(MoveSplineFlagEnum flag)
     {
-    public:
-        enum eFlags : uint32
+        switch (flag)
         {
-            None                = 0x00000000,
-            Unknown_0x1         = 0x00000001,           // NOT VERIFIED
-            Unknown_0x2         = 0x00000002,           // NOT VERIFIED
-            Unknown_0x4         = 0x00000004,           // NOT VERIFIED
-            Unknown_0x8         = 0x00000008,           // NOT VERIFIED - does someting related to falling/fixed orientation
-            FallingSlow         = 0x00000010,
-            Done                = 0x00000020,
-            Falling             = 0x00000040,           // Affects elevation computation, can't be combined with Parabolic flag
-            No_Spline           = 0x00000080,
-            Unknown_0x100       = 0x00000100,           // NOT VERIFIED
-            Flying              = 0x00000200,           // Smooth movement(Catmullrom interpolation mode), flying animation
-            OrientationFixed    = 0x00000400,           // Model orientation fixed
-            Catmullrom          = 0x00000800,           // Used Catmullrom interpolation mode
-            Cyclic              = 0x00001000,           // Movement by cycled spline
-            Enter_Cycle         = 0x00002000,           // Everytimes appears with cyclic flag in monster move packet, erases first spline vertex after first cycle done
-            Frozen              = 0x00004000,           // Will never arrive
-            TransportEnter      = 0x00008000,
-            TransportExit       = 0x00010000,
-            Unknown_0x20000     = 0x00020000,           // NOT VERIFIED
-            Unknown_0x40000     = 0x00040000,           // NOT VERIFIED
-            Backward            = 0x00080000,
-            SmoothGroundPath    = 0x00100000,
-            CanSwim             = 0x00200000,
-            UncompressedPath    = 0x00400000,
-            Unknown_0x800000    = 0x00800000,           // NOT VERIFIED
-            FastSteering        = 0x01000000,           // Predicts spline only 500ms into the future for smoothing instead of 1s (making turns sharper) and turns off clientside obstacle detection
-            Animation           = 0x02000000,           // Plays animation after some time passed
-            Parabolic           = 0x04000000,           // Affects elevation computation, can't be combined with Falling flag
-            FadeObject          = 0x08000000,
-            Steering            = 0x10000000,
-            UnlimitedSpeed      = 0x20000000,
-            Unknown_0x40000000  = 0x40000000,           // NOT VERIFIED
-            Unknown_0x80000000  = 0x80000000,           // NOT VERIFIED
-
-            // Masks
-            // flags that shouldn't be appended into SMSG_MONSTER_MOVE\SMSG_MONSTER_MOVE_TRANSPORT packet, should be more probably
-            Mask_No_Monster_Move = Done,
-            // Unused, not suported flags
-            Mask_Unused         = No_Spline | Enter_Cycle | Frozen | Unknown_0x8 | Unknown_0x100 | Unknown_0x20000 | Unknown_0x40000
-                                | Unknown_0x800000 | FastSteering | FadeObject | UnlimitedSpeed | Unknown_0x40000000 | Unknown_0x80000000
-        };
-
-        inline uint32& raw() { return (uint32&)*this; }
-        inline uint32 const& raw() const { return (uint32 const&)*this; }
+            case MoveSplineFlagEnum::Falling: return MoveSplineFlagEnum::Parabolic | MoveSplineFlagEnum::Animation | MoveSplineFlagEnum::Flying;
+            case MoveSplineFlagEnum::Flying: return MoveSplineFlagEnum::FallingSlow | MoveSplineFlagEnum::Falling;
+            case MoveSplineFlagEnum::Catmullrom: return MoveSplineFlagEnum::SmoothGroundPath;
+            case MoveSplineFlagEnum::TransportEnter: return MoveSplineFlagEnum::TransportExit;
+            case MoveSplineFlagEnum::TransportExit: return MoveSplineFlagEnum::TransportEnter;
+            case MoveSplineFlagEnum::SmoothGroundPath: return MoveSplineFlagEnum::Steering;
+            case MoveSplineFlagEnum::Animation: return MoveSplineFlagEnum::Falling | MoveSplineFlagEnum::Parabolic | MoveSplineFlagEnum::FallingSlow | MoveSplineFlagEnum::FadeObject;
+            case MoveSplineFlagEnum::Parabolic: return MoveSplineFlagEnum::Falling | MoveSplineFlagEnum::Animation | MoveSplineFlagEnum::FallingSlow | MoveSplineFlagEnum::FadeObject;
+            case MoveSplineFlagEnum::FadeObject: return MoveSplineFlagEnum::Falling | MoveSplineFlagEnum::Parabolic | MoveSplineFlagEnum::FallingSlow | MoveSplineFlagEnum::Animation;
+            case MoveSplineFlagEnum::Steering: return MoveSplineFlagEnum::SmoothGroundPath;
+            default: break;
+        }
+        return MoveSplineFlagEnum::None;
+    }
 
-        MoveSplineFlag() { raw() = 0; }
-        MoveSplineFlag(uint32 f) { raw() = f; }
+    union MoveSplineFlag
+    {
+        constexpr MoveSplineFlag() : Raw(MoveSplineFlagEnum::None) { }
+        constexpr MoveSplineFlag(MoveSplineFlagEnum f) : Raw(f) { }
 
         // Constant interface
 
-        bool isSmooth() const { return (raw() & Catmullrom) != 0; }
-        bool isLinear() const { return !isSmooth(); }
+        constexpr bool isSmooth() const { return Raw.HasFlag(MoveSplineFlagEnum::Catmullrom); }
+        constexpr bool isLinear() const { return !isSmooth(); }
 
-        bool hasAllFlags(uint32 f) const { return (raw() & f) == f; }
-        bool hasFlag(uint32 f) const { return (raw() & f) != 0; }
-        uint32 operator & (uint32 f) const { return (raw() & f); }
-        uint32 operator | (uint32 f) const { return (raw() | f); }
+        constexpr bool HasAllFlags(MoveSplineFlagEnum f) const { return Raw.HasAllFlags(f); }
+        constexpr bool HasFlag(MoveSplineFlagEnum f) const { return Raw.HasFlag(f); }
+        constexpr MoveSplineFlagEnum operator&(MoveSplineFlagEnum f) const { return (Raw & f); }
+        constexpr MoveSplineFlagEnum operator|(MoveSplineFlagEnum f) const { return (Raw | f); }
         std::string ToString() const;
 
         // Not constant interface
 
-        void operator &= (uint32 f) { raw() &= f; }
-        void operator |= (uint32 f) { raw() |= f; }
-
-        void EnableAnimation() { raw() = (raw() & ~(Falling | Parabolic | FallingSlow | FadeObject)) | Animation; }
-        void EnableParabolic() { raw() = (raw() & ~(Falling | Animation | FallingSlow | FadeObject)) | Parabolic; }
-        void EnableFlying() { raw() = (raw() & ~(Falling)) | Flying; }
-        void EnableFalling() { raw() = (raw() & ~(Parabolic | Animation | Flying)) | Falling; }
-        void EnableCatmullRom() { raw() = (raw() & ~SmoothGroundPath) | Catmullrom; }
-        void EnableTransportEnter() { raw() = (raw() & ~TransportExit) | TransportEnter; }
-        void EnableTransportExit() { raw() = (raw() & ~TransportEnter) | TransportExit; }
-        void EnableSteering() { raw() = (raw() & ~SmoothGroundPath) | Steering; }
-
-        bool unknown0x1          : 1;
-        bool unknown0x2          : 1;
-        bool unknown0x4          : 1;
-        bool unknown0x8          : 1;
-        bool fallingSlow         : 1;
-        bool done                : 1;
-        bool falling             : 1;
-        bool no_spline           : 1;
-        bool unknown0x100        : 1;
-        bool flying              : 1;
-        bool orientationFixed    : 1;
-        bool catmullrom          : 1;
-        bool cyclic              : 1;
-        bool enter_cycle         : 1;
-        bool frozen              : 1;
-        bool transportEnter      : 1;
-        bool transportExit       : 1;
-        bool unknown0x20000      : 1;
-        bool unknown0x40000      : 1;
-        bool backward            : 1;
-        bool smoothGroundPath    : 1;
-        bool canSwim             : 1;
-        bool uncompressedPath    : 1;
-        bool unknown0x800000     : 1;
-        bool fastSteering        : 1;
-        bool animation           : 1;
-        bool parabolic           : 1;
-        bool fadeObject          : 1;
-        bool steering            : 1;
-        bool unlimitedSpeed      : 1;
-        bool unknown0x40000000   : 1;
-        bool unknown0x80000000   : 1;
+        constexpr MoveSplineFlag& operator&=(MoveSplineFlagEnum f) { Raw &= f; return *this; }
+        constexpr MoveSplineFlag& operator|=(MoveSplineFlagEnum f) { Raw |= f; return *this; }
+
+        EnumFlag<MoveSplineFlagEnum> Raw;
+
+        template <MoveSplineFlagEnum Flag>
+        struct FlagAccessor
+        {
+            constexpr operator bool() const { return (Raw & Flag) != MoveSplineFlagEnum::None; }
+            constexpr FlagAccessor& operator=(bool val) { if (val) { Raw = Raw & ~GetDisallowedFlagsFor(Flag) | Flag; } else Raw &= ~Flag; return *this; }
+            MoveSplineFlagEnum Raw;
+        };
+
+#define MAKE_FLAG_ACCESSOR_FIELD(flag) FlagAccessor<MoveSplineFlagEnum::flag> flag
+
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x1);
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x2);
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x4);
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x8);
+        MAKE_FLAG_ACCESSOR_FIELD(FallingSlow);
+        MAKE_FLAG_ACCESSOR_FIELD(Done);
+        MAKE_FLAG_ACCESSOR_FIELD(Falling);
+        MAKE_FLAG_ACCESSOR_FIELD(No_Spline);
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x100);
+        MAKE_FLAG_ACCESSOR_FIELD(Flying);
+        MAKE_FLAG_ACCESSOR_FIELD(OrientationFixed);
+        MAKE_FLAG_ACCESSOR_FIELD(Catmullrom);
+        MAKE_FLAG_ACCESSOR_FIELD(Cyclic);
+        MAKE_FLAG_ACCESSOR_FIELD(Enter_Cycle);
+        MAKE_FLAG_ACCESSOR_FIELD(Frozen);
+        MAKE_FLAG_ACCESSOR_FIELD(TransportEnter);
+        MAKE_FLAG_ACCESSOR_FIELD(TransportExit);
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x20000);
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x40000);
+        MAKE_FLAG_ACCESSOR_FIELD(Backward);
+        MAKE_FLAG_ACCESSOR_FIELD(SmoothGroundPath);
+        MAKE_FLAG_ACCESSOR_FIELD(CanSwim);
+        MAKE_FLAG_ACCESSOR_FIELD(UncompressedPath);
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x800000);
+        MAKE_FLAG_ACCESSOR_FIELD(FastSteering);
+        MAKE_FLAG_ACCESSOR_FIELD(Animation);
+        MAKE_FLAG_ACCESSOR_FIELD(Parabolic);
+        MAKE_FLAG_ACCESSOR_FIELD(FadeObject);
+        MAKE_FLAG_ACCESSOR_FIELD(Steering);
+        MAKE_FLAG_ACCESSOR_FIELD(UnlimitedSpeed);
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x40000000);
+        MAKE_FLAG_ACCESSOR_FIELD(Unknown_0x80000000);
+
+#undef MAKE_FLAG_ACCESSOR_FIELD
     };
-#pragma pack(pop)
 }
 
 #endif // TRINITYSERVER_MOVESPLINEFLAG_H
diff --git a/src/server/game/Movement/Spline/MoveSplineInit.cpp b/src/server/game/Movement/Spline/MoveSplineInit.cpp
index 2fb04440358..decaf4fb4b8 100644
--- a/src/server/game/Movement/Spline/MoveSplineInit.cpp
+++ b/src/server/game/Movement/Spline/MoveSplineInit.cpp
@@ -86,11 +86,11 @@ namespace Movement
         // correct first vertex
         args.path[0] = real_position;
         args.initialOrientation = real_position.orientation;
-        args.flags.enter_cycle = args.flags.cyclic;
+        args.flags.Enter_Cycle = args.flags.Cyclic;
         move_spline.onTransport = transport;
 
         uint32 moveFlags = unit->m_movementInfo.GetMovementFlags();
-        if (!args.flags.backward)
+        if (!args.flags.Backward)
             moveFlags = (moveFlags & ~MOVEMENTFLAG_BACKWARD) | MOVEMENTFLAG_FORWARD;
         else
             moveFlags = (moveFlags & ~MOVEMENTFLAG_FORWARD) | MOVEMENTFLAG_BACKWARD;
@@ -117,10 +117,10 @@ namespace Movement
         // limit the speed in the same way the client does
         float speedLimit = [&]()
         {
-            if (args.flags.unlimitedSpeed)
+            if (args.flags.UnlimitedSpeed)
                 return std::numeric_limits<float>::max();
 
-            if (args.flags.falling || args.flags.catmullrom || args.flags.flying || args.flags.parabolic)
+            if (args.flags.Falling || args.flags.Catmullrom || args.flags.Flying || args.flags.Parabolic)
                 return 50.0f;
 
             return std::max(28.0f, unit->GetSpeed(MOVE_RUN) * 4.0f);
@@ -175,7 +175,7 @@ namespace Movement
             loc.orientation = unit->GetOrientation();
         }
 
-        args.flags = MoveSplineFlag::Done;
+        args.flags = MoveSplineFlagEnum::Done;
         unit->m_movementInfo.RemoveMovementFlag(MOVEMENTFLAG_FORWARD);
         move_spline.onTransport = transport;
         move_spline.Initialize(args);
@@ -201,11 +201,11 @@ namespace Movement
         // Elevators also use MOVEMENTFLAG_ONTRANSPORT but we do not keep track of their position changes
         args.TransformForTransport = !unit->GetTransGUID().IsEmpty();
         // mix existing state into new
-        args.flags.canSwim = unit->CanSwim();
         args.walk = unit->HasUnitMovementFlag(MOVEMENTFLAG_WALKING);
-        args.flags.flying = unit->HasUnitMovementFlag(MovementFlags(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_DISABLE_GRAVITY));
-        args.flags.steering = unit->HasNpcFlag2(UNIT_NPC_FLAG_2_STEERING);
-        args.flags.smoothGroundPath = !args.flags.flying && !args.flags.steering; // enabled by default, CatmullRom mode or client config "pathSmoothing" will disable this
+        args.flags.CanSwim = unit->CanSwim();
+        args.flags.Flying = unit->HasUnitMovementFlag(MovementFlags(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_DISABLE_GRAVITY));
+        args.flags.Steering = unit->HasNpcFlag2(UNIT_NPC_FLAG_2_STEERING);
+        args.flags.SmoothGroundPath = !args.flags.Flying && !args.flags.Steering; // enabled by default, CatmullRom mode or client config "pathSmoothing" will disable this
     }
 
     MoveSplineInit::~MoveSplineInit() = default;
@@ -279,8 +279,8 @@ namespace Movement
 
     void MoveSplineInit::SetFall()
     {
-        args.flags.EnableFalling();
-        args.flags.fallingSlow = unit->HasUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
+        args.flags.Falling = true;
+        args.flags.FallingSlow = unit->HasUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
     }
 
     Vector3 TransportPathTransform::operator()(Vector3 input)
diff --git a/src/server/game/Movement/Spline/MoveSplineInit.h b/src/server/game/Movement/Spline/MoveSplineInit.h
index 02642e06846..880ada0c33d 100644
--- a/src/server/game/Movement/Spline/MoveSplineInit.h
+++ b/src/server/game/Movement/Spline/MoveSplineInit.h
@@ -176,25 +176,25 @@ namespace Movement
         Unit*  unit;
     };
 
-    inline void MoveSplineInit::SetFly() { args.flags.EnableFlying(); }
+    inline void MoveSplineInit::SetFly() { args.flags.Flying = true; }
     inline void MoveSplineInit::SetWalk(bool enable) { args.walk = enable; }
-    inline void MoveSplineInit::SetSmooth() { args.flags.EnableCatmullRom(); }
-    inline void MoveSplineInit::SetUncompressed() { args.flags.uncompressedPath = true; }
-    inline void MoveSplineInit::SetCyclic() { args.flags.cyclic = true; }
+    inline void MoveSplineInit::SetSmooth() { args.flags.Catmullrom = true; }
+    inline void MoveSplineInit::SetUncompressed() { args.flags.UncompressedPath = true; }
+    inline void MoveSplineInit::SetCyclic() { args.flags.Cyclic = true; }
     inline void MoveSplineInit::SetVelocity(float vel) { args.velocity = vel; args.HasVelocity = true; }
-    inline void MoveSplineInit::SetBackward() { args.flags.backward = true; }
-    inline void MoveSplineInit::SetTransportEnter() { args.flags.EnableTransportEnter(); }
-    inline void MoveSplineInit::SetTransportExit() { args.flags.EnableTransportExit(); }
-    inline void MoveSplineInit::SetOrientationFixed(bool enable) { args.flags.orientationFixed = enable; }
-    inline void MoveSplineInit::SetSteering() { args.flags.EnableSteering(); }
-    inline void MoveSplineInit::SetUnlimitedSpeed() { args.flags.unlimitedSpeed = true; }
+    inline void MoveSplineInit::SetBackward() { args.flags.Backward = true; }
+    inline void MoveSplineInit::SetTransportEnter() { args.flags.TransportEnter = true; }
+    inline void MoveSplineInit::SetTransportExit() { args.flags.TransportExit = true; }
+    inline void MoveSplineInit::SetOrientationFixed(bool enable) { args.flags.OrientationFixed = enable; }
+    inline void MoveSplineInit::SetSteering() { args.flags.Steering = true; }
+    inline void MoveSplineInit::SetUnlimitedSpeed() { args.flags.UnlimitedSpeed = true; }
 
     inline void MoveSplineInit::SetParabolic(float amplitude, float time_shift)
     {
         args.effect_start_time_percent = time_shift;
         args.parabolic_amplitude = amplitude;
         args.vertical_acceleration = 0.0f;
-        args.flags.EnableParabolic();
+        args.flags.Parabolic = true;
     }
 
     inline void MoveSplineInit::SetParabolicVerticalAcceleration(float vertical_acceleration, float time_shift)
@@ -202,7 +202,7 @@ namespace Movement
         args.effect_start_time_percent = time_shift;
         args.parabolic_amplitude = 0.0f;
         args.vertical_acceleration = vertical_acceleration;
-        args.flags.EnableParabolic();
+        args.flags.Parabolic = true;
     }
 
     inline void MoveSplineInit::SetAnimation(AnimTier anim, uint32 tierTransitionId /*= 0*/, Milliseconds transitionStartTime /*= 0ms*/)
@@ -213,7 +213,7 @@ namespace Movement
         args.animTier->TierTransitionId = tierTransitionId;
         args.animTier->AnimTier = anim;
         if (!tierTransitionId)
-            args.flags.EnableAnimation();
+            args.flags.Animation = true;
     }
 
     inline void MoveSplineInit::DisableTransportPathTransformations() { args.TransformForTransport = false; }
diff --git a/src/server/game/Movement/Spline/MovementTypedefs.h b/src/server/game/Movement/Spline/MovementTypedefs.h
index 31760ff01ce..8fae9bb4d95 100644
--- a/src/server/game/Movement/Spline/MovementTypedefs.h
+++ b/src/server/game/Movement/Spline/MovementTypedefs.h
@@ -20,6 +20,10 @@
 
 #include "Common.h"
 
+enum MovementFlags : uint32;
+enum MovementFlags2 : uint32;
+enum MovementFlags3 : uint32;
+
 namespace G3D
 {
     class Vector3;
@@ -78,8 +82,9 @@ namespace Movement
 
     float constexpr gravity = static_cast<float>(19.29110527038574);
     TC_GAME_API extern UInt32Counter splineIdGen;
-    TC_GAME_API extern std::string MovementFlags_ToString(uint32 flags);
-    TC_GAME_API extern std::string MovementFlagsExtra_ToString(uint32 flags);
+    TC_GAME_API extern std::string MovementFlags_ToString(MovementFlags flags);
+    TC_GAME_API extern std::string MovementFlags_ToString(MovementFlags2 flags);
+    TC_GAME_API extern std::string MovementFlags_ToString(MovementFlags3 flags);
 }
 
 #endif // TRINITYSERVER_TYPEDEFS_H
diff --git a/src/server/game/Movement/Spline/MovementUtil.cpp b/src/server/game/Movement/Spline/MovementUtil.cpp
index 15b9fbe2ab6..71fc20db485 100644
--- a/src/server/game/Movement/Spline/MovementUtil.cpp
+++ b/src/server/game/Movement/Spline/MovementUtil.cpp
@@ -15,8 +15,9 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "MovementTypedefs.h"
 #include "MoveSplineFlag.h"
+#include "MovementTypedefs.h"
+#include "SmartEnum.h"
 #include <cmath>
 
 namespace Movement
@@ -83,130 +84,39 @@ namespace Movement
         return result;
     }
 
-    char const* MovementFlagNames[] =
-    {
-        STRINGIZE(Forward           ), // 0x00000001
-        STRINGIZE(Backward          ), // 0x00000002
-        STRINGIZE(Strafe_Left       ), // 0x00000004
-        STRINGIZE(Strafe_Right      ), // 0x00000008
-        STRINGIZE(Turn_Left         ), // 0x00000010
-        STRINGIZE(Turn_Right        ), // 0x00000020
-        STRINGIZE(Pitch_Up          ), // 0x00000040
-        STRINGIZE(Pitch_Down        ), // 0x00000080
-        STRINGIZE(Walking           ), // 0x00000100               // Walking
-        STRINGIZE(DisableGravity    ), // 0x00000200
-        STRINGIZE(Root              ), // 0x00000400
-        STRINGIZE(Falling           ), // 0x00000800
-        STRINGIZE(FallingFar        ), // 0x00001000
-        STRINGIZE(PendingStop       ), // 0x00002000
-        STRINGIZE(PendingStrafeStop ), // 0x00004000
-        STRINGIZE(PendingForward    ), // 0x00008000
-        STRINGIZE(PendingBackward   ), // 0x00010000
-        STRINGIZE(PendingStrafeLeft ), // 0x00020000
-        STRINGIZE(PendingStrafeRight), // 0x00040000
-        STRINGIZE(PendingRoot       ), // 0x00080000
-        STRINGIZE(Swimming          ), // 0x00100000               // Appears With Fly Flag Also
-        STRINGIZE(Ascending         ), // 0x00200000               // Swim Up Also
-        STRINGIZE(Descending        ), // 0x00400000               // Swim Down Also
-        STRINGIZE(Can_Fly           ), // 0x00800000               // Can Fly In 3.3?
-        STRINGIZE(Flying            ), // 0x01000000               // Actual Flying Mode
-        STRINGIZE(Spline_Elevation  ), // 0x02000000               // Used For Flight Paths
-        STRINGIZE(Waterwalking      ), // 0x04000000               // Prevent Unit From Falling Through Water
-        STRINGIZE(Safe_Fall         ), // 0x08000000               // Active Rogue Safe Fall Spell (Passive)
-        STRINGIZE(Hover             ), // 0x10000000
-        STRINGIZE(Local_Dirty       ), // 0x20000000
-        STRINGIZE(None31            ), // 0x40000000
-        STRINGIZE(None32            ), // 0x80000000
-    };
-
-    char const* MovementFlagExtraNames[] =
+    template<class Flags>
+    void PrintFlags(Flags t, std::string& str)
     {
-        STRINGIZE(NoStrafe                           ), // 0x00000001
-        STRINGIZE(NoJump                             ), // 0x00000002
-        STRINGIZE(FullSpeedTurning                   ), // 0x00000004
-        STRINGIZE(FullSpeedPitching                  ), // 0x00000008
-        STRINGIZE(Allow_Pitching                     ), // 0x00000010
-        STRINGIZE(VehicleExitVoluntary               ), // 0x00000020
-        STRINGIZE(WaterwalkingFullPitch              ), // 0x00000040
-        STRINGIZE(VehiclePassengerIsTransitionAllowed), // 0x00000080
-        STRINGIZE(CanSwimToFlyTrans                  ), // 0x00000100
-        STRINGIZE(Unk9                               ), // 0x00000200
-        STRINGIZE(CanTurnWhileFalling                ), // 0x00000400
-        STRINGIZE(IgnoreMovementForces               ), // 0x00000800
-        STRINGIZE(CanDoubleJump                      ), // 0x00001000
-        STRINGIZE(DoubleJump                         ), // 0x00002000
-        STRINGIZE(Unk14                              ), // 0x00004000
-        STRINGIZE(Unk15                              ), // 0x00008000
-        STRINGIZE(AwaitingLoad                       ), // 0x00010000
-        STRINGIZE(InterpolatedMovement               ), // 0x00020000
-        STRINGIZE(InterpolatedTurning                ), // 0x00040000
-        STRINGIZE(InterpolatedPitching               ), // 0x00080000
-    };
-
-    char const* SplineFlagNames[32] =
-    {
-        STRINGIZE(Unknown_0x1       ), // 0x00000001
-        STRINGIZE(Unknown_0x2       ), // 0x00000002
-        STRINGIZE(Unknown_0x4       ), // 0x00000004
-        STRINGIZE(Unknown_0x8       ), // 0x00000008
-        STRINGIZE(FallingSlow       ), // 0x00000010
-        STRINGIZE(Done              ), // 0x00000020
-        STRINGIZE(Falling           ), // 0x00000040           // Not Compartible With Trajectory Movement
-        STRINGIZE(No_Spline         ), // 0x00000080
-        STRINGIZE(Unknown_0x100     ), // 0x00000100
-        STRINGIZE(Flying            ), // 0x00000200           // Smooth Movement(Catmullrom Interpolation Mode), Flying Animation
-        STRINGIZE(OrientationFixed  ), // 0x00000400           // Model Orientation Fixed
-        STRINGIZE(Catmullrom        ), // 0x00000800           // Used Catmullrom Interpolation Mode
-        STRINGIZE(Cyclic            ), // 0x00001000           // Movement By Cycled Spline
-        STRINGIZE(Enter_Cycle       ), // 0x00002000           // Everytime Appears With Cyclic Flag In Monster Move Packet
-        STRINGIZE(Frozen            ), // 0x00004000
-        STRINGIZE(TransportEnter    ), // 0x00008000
-        STRINGIZE(TransportExit     ), // 0x00010000
-        STRINGIZE(Unknown_0x20000   ), // 0x00020000
-        STRINGIZE(Unknown_0x40000   ), // 0x00040000
-        STRINGIZE(Backward          ), // 0x00080000           // Appears With Runmode Flag, Nodes ), // 1, Handles Orientation
-        STRINGIZE(SmoothGroundPath  ), // 0x00100000
-        STRINGIZE(CanSwim           ), // 0x00200000
-        STRINGIZE(UncompressedPath  ), // 0x00400000
-        STRINGIZE(Unknown_0x800000  ), // 0x00800000
-        STRINGIZE(FastSteering      ), // 0x01000000           // Predicts spline only 500ms into the future for smoothing instead of 1s and turns off clientside obstacle detection
-        STRINGIZE(Animation         ), // 0x02000000           // Animationid (0...3), Uint32 Time, Not Compartible With Trajectory And Fall Movement
-        STRINGIZE(Parabolic         ), // 0x04000000           // Not Compartible With Fall Movement
-        STRINGIZE(FadeObject        ), // 0x08000000
-        STRINGIZE(Steering          ), // 0x10000000
-        STRINGIZE(UnlimitedSpeed    ), // 0x20000000
-        STRINGIZE(Unknown_0x40000000), // 0x40000000
-        STRINGIZE(Unknown_0x80000000), // 0x80000000
-    };
-
-    template<class Flags, int N>
-    void PrintFlags(Flags t, char const* (&names)[N], std::string& str)
-    {
-        for (int i = 0; i < N; ++i)
-        {
-            if ((t & Flags(1 << i)) && names[i] != nullptr)
-                str.append(" ").append(names[i]);
-        }
+        for (Flags flag : EnumUtils::Iterate<Flags>())
+            if ((t & flag) != Flags(0))
+                str.append(" ").append(EnumUtils::ToConstant(flag));
     }
 
     std::string MoveSplineFlag::ToString() const
     {
         std::string str;
-        PrintFlags(raw(), SplineFlagNames, str);
+        PrintFlags<MoveSplineFlagEnum>(Raw, str);
+        return str;
+    }
+
+    std::string MovementFlags_ToString(MovementFlags flags)
+    {
+        std::string str;
+        PrintFlags(flags, str);
         return str;
     }
 
-    std::string MovementFlags_ToString(uint32 flags)
+    std::string MovementFlags_ToString(MovementFlags2 flags)
     {
         std::string str;
-        PrintFlags(flags, MovementFlagNames, str);
+        PrintFlags(flags, str);
         return str;
     }
 
-    std::string MovementFlagsExtra_ToString(uint32 flags)
+    std::string MovementFlags_ToString(MovementFlags3 flags)
     {
         std::string str;
-        PrintFlags(flags, MovementFlagExtraNames, str);
+        PrintFlags(flags, str);
         return str;
     }
 }
diff --git a/src/server/game/Movement/Spline/enuminfo_MoveSplineFlag.cpp b/src/server/game/Movement/Spline/enuminfo_MoveSplineFlag.cpp
new file mode 100644
index 00000000000..41fd7622ed0
--- /dev/null
+++ b/src/server/game/Movement/Spline/enuminfo_MoveSplineFlag.cpp
@@ -0,0 +1,159 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "MoveSplineFlag.h"
+#include "Define.h"
+#include "SmartEnum.h"
+#include <stdexcept>
+
+using Movement::MoveSplineFlagEnum;
+
+namespace Trinity::Impl::EnumUtilsImpl
+{
+
+/***************************************************************************\
+|* data for enum 'MoveSplineFlagEnum' in 'MoveSplineFlag.h' auto-generated *|
+\***************************************************************************/
+template <>
+TC_API_EXPORT EnumText EnumUtils<MoveSplineFlagEnum>::ToString(MoveSplineFlagEnum value)
+{
+    switch (value)
+    {
+        case MoveSplineFlagEnum::None: return { "None", "None", "" };
+        case MoveSplineFlagEnum::Unknown_0x1: return { "Unknown_0x1", "Unknown_0x1", "NOT VERIFIED" };
+        case MoveSplineFlagEnum::Unknown_0x2: return { "Unknown_0x2", "Unknown_0x2", "NOT VERIFIED" };
+        case MoveSplineFlagEnum::Unknown_0x4: return { "Unknown_0x4", "Unknown_0x4", "NOT VERIFIED" };
+        case MoveSplineFlagEnum::Unknown_0x8: return { "Unknown_0x8", "Unknown_0x8", "NOT VERIFIED - does someting related to falling/fixed orientation" };
+        case MoveSplineFlagEnum::FallingSlow: return { "FallingSlow", "FallingSlow", "" };
+        case MoveSplineFlagEnum::Done: return { "Done", "Done", "" };
+        case MoveSplineFlagEnum::Falling: return { "Falling", "Falling", "Affects elevation computation, can't be combined with Parabolic flag" };
+        case MoveSplineFlagEnum::No_Spline: return { "No_Spline", "No_Spline", "" };
+        case MoveSplineFlagEnum::Unknown_0x100: return { "Unknown_0x100", "Unknown_0x100", "NOT VERIFIED" };
+        case MoveSplineFlagEnum::Flying: return { "Flying", "Flying", "Smooth movement(Catmullrom interpolation mode), flying animation" };
+        case MoveSplineFlagEnum::OrientationFixed: return { "OrientationFixed", "OrientationFixed", "Model orientation fixed" };
+        case MoveSplineFlagEnum::Catmullrom: return { "Catmullrom", "Catmullrom", "Used Catmullrom interpolation mode" };
+        case MoveSplineFlagEnum::Cyclic: return { "Cyclic", "Cyclic", "Movement by cycled spline" };
+        case MoveSplineFlagEnum::Enter_Cycle: return { "Enter_Cycle", "Enter_Cycle", "Everytimes appears with cyclic flag in monster move packet, erases first spline vertex after first cycle done" };
+        case MoveSplineFlagEnum::Frozen: return { "Frozen", "Frozen", "Will never arrive" };
+        case MoveSplineFlagEnum::TransportEnter: return { "TransportEnter", "TransportEnter", "" };
+        case MoveSplineFlagEnum::TransportExit: return { "TransportExit", "TransportExit", "" };
+        case MoveSplineFlagEnum::Unknown_0x20000: return { "Unknown_0x20000", "Unknown_0x20000", "NOT VERIFIED" };
+        case MoveSplineFlagEnum::Unknown_0x40000: return { "Unknown_0x40000", "Unknown_0x40000", "NOT VERIFIED" };
+        case MoveSplineFlagEnum::Backward: return { "Backward", "Backward", "" };
+        case MoveSplineFlagEnum::SmoothGroundPath: return { "SmoothGroundPath", "SmoothGroundPath", "" };
+        case MoveSplineFlagEnum::CanSwim: return { "CanSwim", "CanSwim", "" };
+        case MoveSplineFlagEnum::UncompressedPath: return { "UncompressedPath", "UncompressedPath", "" };
+        case MoveSplineFlagEnum::Unknown_0x800000: return { "Unknown_0x800000", "Unknown_0x800000", "NOT VERIFIED" };
+        case MoveSplineFlagEnum::FastSteering: return { "FastSteering", "FastSteering", "Predicts spline only 500ms into the future for smoothing instead of 1s (making turns sharper) and turns off clientside obstacle detection" };
+        case MoveSplineFlagEnum::Animation: return { "Animation", "Animation", "Plays animation after some time passed" };
+        case MoveSplineFlagEnum::Parabolic: return { "Parabolic", "Parabolic", "Affects elevation computation, can't be combined with Falling flag" };
+        case MoveSplineFlagEnum::FadeObject: return { "FadeObject", "FadeObject", "" };
+        case MoveSplineFlagEnum::Steering: return { "Steering", "Steering", "" };
+        case MoveSplineFlagEnum::UnlimitedSpeed: return { "UnlimitedSpeed", "UnlimitedSpeed", "" };
+        case MoveSplineFlagEnum::Unknown_0x40000000: return { "Unknown_0x40000000", "Unknown_0x40000000", "NOT VERIFIED" };
+        case MoveSplineFlagEnum::Unknown_0x80000000: return { "Unknown_0x80000000", "Unknown_0x80000000", "NOT VERIFIED" };
+        default: throw std::out_of_range("value");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MoveSplineFlagEnum>::Count() { return 33; }
+
+template <>
+TC_API_EXPORT MoveSplineFlagEnum EnumUtils<MoveSplineFlagEnum>::FromIndex(size_t index)
+{
+    switch (index)
+    {
+        case 0: return MoveSplineFlagEnum::None;
+        case 1: return MoveSplineFlagEnum::Unknown_0x1;
+        case 2: return MoveSplineFlagEnum::Unknown_0x2;
+        case 3: return MoveSplineFlagEnum::Unknown_0x4;
+        case 4: return MoveSplineFlagEnum::Unknown_0x8;
+        case 5: return MoveSplineFlagEnum::FallingSlow;
+        case 6: return MoveSplineFlagEnum::Done;
+        case 7: return MoveSplineFlagEnum::Falling;
+        case 8: return MoveSplineFlagEnum::No_Spline;
+        case 9: return MoveSplineFlagEnum::Unknown_0x100;
+        case 10: return MoveSplineFlagEnum::Flying;
+        case 11: return MoveSplineFlagEnum::OrientationFixed;
+        case 12: return MoveSplineFlagEnum::Catmullrom;
+        case 13: return MoveSplineFlagEnum::Cyclic;
+        case 14: return MoveSplineFlagEnum::Enter_Cycle;
+        case 15: return MoveSplineFlagEnum::Frozen;
+        case 16: return MoveSplineFlagEnum::TransportEnter;
+        case 17: return MoveSplineFlagEnum::TransportExit;
+        case 18: return MoveSplineFlagEnum::Unknown_0x20000;
+        case 19: return MoveSplineFlagEnum::Unknown_0x40000;
+        case 20: return MoveSplineFlagEnum::Backward;
+        case 21: return MoveSplineFlagEnum::SmoothGroundPath;
+        case 22: return MoveSplineFlagEnum::CanSwim;
+        case 23: return MoveSplineFlagEnum::UncompressedPath;
+        case 24: return MoveSplineFlagEnum::Unknown_0x800000;
+        case 25: return MoveSplineFlagEnum::FastSteering;
+        case 26: return MoveSplineFlagEnum::Animation;
+        case 27: return MoveSplineFlagEnum::Parabolic;
+        case 28: return MoveSplineFlagEnum::FadeObject;
+        case 29: return MoveSplineFlagEnum::Steering;
+        case 30: return MoveSplineFlagEnum::UnlimitedSpeed;
+        case 31: return MoveSplineFlagEnum::Unknown_0x40000000;
+        case 32: return MoveSplineFlagEnum::Unknown_0x80000000;
+        default: throw std::out_of_range("index");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MoveSplineFlagEnum>::ToIndex(MoveSplineFlagEnum value)
+{
+    switch (value)
+    {
+        case MoveSplineFlagEnum::None: return 0;
+        case MoveSplineFlagEnum::Unknown_0x1: return 1;
+        case MoveSplineFlagEnum::Unknown_0x2: return 2;
+        case MoveSplineFlagEnum::Unknown_0x4: return 3;
+        case MoveSplineFlagEnum::Unknown_0x8: return 4;
+        case MoveSplineFlagEnum::FallingSlow: return 5;
+        case MoveSplineFlagEnum::Done: return 6;
+        case MoveSplineFlagEnum::Falling: return 7;
+        case MoveSplineFlagEnum::No_Spline: return 8;
+        case MoveSplineFlagEnum::Unknown_0x100: return 9;
+        case MoveSplineFlagEnum::Flying: return 10;
+        case MoveSplineFlagEnum::OrientationFixed: return 11;
+        case MoveSplineFlagEnum::Catmullrom: return 12;
+        case MoveSplineFlagEnum::Cyclic: return 13;
+        case MoveSplineFlagEnum::Enter_Cycle: return 14;
+        case MoveSplineFlagEnum::Frozen: return 15;
+        case MoveSplineFlagEnum::TransportEnter: return 16;
+        case MoveSplineFlagEnum::TransportExit: return 17;
+        case MoveSplineFlagEnum::Unknown_0x20000: return 18;
+        case MoveSplineFlagEnum::Unknown_0x40000: return 19;
+        case MoveSplineFlagEnum::Backward: return 20;
+        case MoveSplineFlagEnum::SmoothGroundPath: return 21;
+        case MoveSplineFlagEnum::CanSwim: return 22;
+        case MoveSplineFlagEnum::UncompressedPath: return 23;
+        case MoveSplineFlagEnum::Unknown_0x800000: return 24;
+        case MoveSplineFlagEnum::FastSteering: return 25;
+        case MoveSplineFlagEnum::Animation: return 26;
+        case MoveSplineFlagEnum::Parabolic: return 27;
+        case MoveSplineFlagEnum::FadeObject: return 28;
+        case MoveSplineFlagEnum::Steering: return 29;
+        case MoveSplineFlagEnum::UnlimitedSpeed: return 30;
+        case MoveSplineFlagEnum::Unknown_0x40000000: return 31;
+        case MoveSplineFlagEnum::Unknown_0x80000000: return 32;
+        default: throw std::out_of_range("value");
+    }
+}
+}