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

2 files changed, 270 insertions, 6 deletions

diff --git a/src/server/game/Entities/Unit/UnitDefines.h b/src/server/game/Entities/Unit/UnitDefines.h
index 91a10a5b9c5..f19ef29ada0 100644
--- a/src/server/game/Entities/Unit/UnitDefines.h
+++ b/src/server/game/Entities/Unit/UnitDefines.h
@@ -353,6 +353,7 @@ enum NPCFlags2 : uint32
 
 DEFINE_ENUM_FLAG(NPCFlags2);
 
+// EnumUtils: DESCRIBE THIS
 enum MovementFlags : uint32
 {
     MOVEMENTFLAG_NONE                  = 0x00000000,
@@ -389,29 +390,30 @@ enum MovementFlags : uint32
 
     MOVEMENTFLAG_MASK_MOVING =
         MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_STRAFE_LEFT | MOVEMENTFLAG_STRAFE_RIGHT |
-        MOVEMENTFLAG_FALLING | MOVEMENTFLAG_ASCENDING | MOVEMENTFLAG_DESCENDING,
+        MOVEMENTFLAG_FALLING | MOVEMENTFLAG_ASCENDING | MOVEMENTFLAG_DESCENDING,// SKIP
 
     MOVEMENTFLAG_MASK_TURNING =
-        MOVEMENTFLAG_LEFT | MOVEMENTFLAG_RIGHT | MOVEMENTFLAG_PITCH_UP | MOVEMENTFLAG_PITCH_DOWN,
+        MOVEMENTFLAG_LEFT | MOVEMENTFLAG_RIGHT | MOVEMENTFLAG_PITCH_UP | MOVEMENTFLAG_PITCH_DOWN, // SKIP
 
     MOVEMENTFLAG_MASK_MOVING_FLY =
-        MOVEMENTFLAG_FLYING | MOVEMENTFLAG_ASCENDING | MOVEMENTFLAG_DESCENDING,
+        MOVEMENTFLAG_FLYING | MOVEMENTFLAG_ASCENDING | MOVEMENTFLAG_DESCENDING, // SKIP
 
     // Movement flags allowed for creature in CreateObject - we need to keep all other enabled serverside
     // to properly calculate all movement
     MOVEMENTFLAG_MASK_CREATURE_ALLOWED =
         MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_DISABLE_GRAVITY | MOVEMENTFLAG_ROOT | MOVEMENTFLAG_SWIMMING |
-        MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_WATERWALKING | MOVEMENTFLAG_FALLING_SLOW | MOVEMENTFLAG_HOVER | MOVEMENTFLAG_DISABLE_COLLISION,
+        MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_WATERWALKING | MOVEMENTFLAG_FALLING_SLOW | MOVEMENTFLAG_HOVER | MOVEMENTFLAG_DISABLE_COLLISION, // SKIP
 
     /// @todo if needed: add more flags to this masks that are exclusive to players
     MOVEMENTFLAG_MASK_PLAYER_ONLY =
-        MOVEMENTFLAG_FLYING,
+        MOVEMENTFLAG_FLYING, // SKIP
 
     /// Movement flags that have change status opcodes associated for players
     MOVEMENTFLAG_MASK_HAS_PLAYER_STATUS_OPCODE = MOVEMENTFLAG_DISABLE_GRAVITY | MOVEMENTFLAG_ROOT |
-        MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_WATERWALKING | MOVEMENTFLAG_FALLING_SLOW | MOVEMENTFLAG_HOVER | MOVEMENTFLAG_DISABLE_COLLISION
+        MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_WATERWALKING | MOVEMENTFLAG_FALLING_SLOW | MOVEMENTFLAG_HOVER | MOVEMENTFLAG_DISABLE_COLLISION // SKIP
 };
 
+// EnumUtils: DESCRIBE THIS
 enum MovementFlags2 : uint32
 {
     MOVEMENTFLAG2_NONE                                      = 0x00000000,
@@ -436,6 +438,7 @@ enum MovementFlags2 : uint32
     MOVEMENTFLAG2_INTERPOLATED_PITCHING                     = 0x00080000
 };
 
+// EnumUtils: DESCRIBE THIS
 enum MovementFlags3 : uint32
 {
     MOVEMENTFLAG3_NONE              = 0x00000000,
diff --git a/src/server/game/Entities/Unit/enuminfo_UnitDefines.cpp b/src/server/game/Entities/Unit/enuminfo_UnitDefines.cpp
index 3a9b8d1a5b0..af0544234ff 100644
--- a/src/server/game/Entities/Unit/enuminfo_UnitDefines.cpp
+++ b/src/server/game/Entities/Unit/enuminfo_UnitDefines.cpp
@@ -622,4 +622,265 @@ TC_API_EXPORT size_t EnumUtils<NPCFlags2>::ToIndex(NPCFlags2 value)
         default: throw std::out_of_range("value");
     }
 }
+
+/*******************************************************************\
+|* data for enum 'MovementFlags' in 'UnitDefines.h' auto-generated *|
+\*******************************************************************/
+template <>
+TC_API_EXPORT EnumText EnumUtils<MovementFlags>::ToString(MovementFlags value)
+{
+    switch (value)
+    {
+        case MOVEMENTFLAG_NONE: return { "MOVEMENTFLAG_NONE", "MOVEMENTFLAG_NONE", "" };
+        case MOVEMENTFLAG_FORWARD: return { "MOVEMENTFLAG_FORWARD", "MOVEMENTFLAG_FORWARD", "" };
+        case MOVEMENTFLAG_BACKWARD: return { "MOVEMENTFLAG_BACKWARD", "MOVEMENTFLAG_BACKWARD", "" };
+        case MOVEMENTFLAG_STRAFE_LEFT: return { "MOVEMENTFLAG_STRAFE_LEFT", "MOVEMENTFLAG_STRAFE_LEFT", "" };
+        case MOVEMENTFLAG_STRAFE_RIGHT: return { "MOVEMENTFLAG_STRAFE_RIGHT", "MOVEMENTFLAG_STRAFE_RIGHT", "" };
+        case MOVEMENTFLAG_LEFT: return { "MOVEMENTFLAG_LEFT", "MOVEMENTFLAG_LEFT", "" };
+        case MOVEMENTFLAG_RIGHT: return { "MOVEMENTFLAG_RIGHT", "MOVEMENTFLAG_RIGHT", "" };
+        case MOVEMENTFLAG_PITCH_UP: return { "MOVEMENTFLAG_PITCH_UP", "MOVEMENTFLAG_PITCH_UP", "" };
+        case MOVEMENTFLAG_PITCH_DOWN: return { "MOVEMENTFLAG_PITCH_DOWN", "MOVEMENTFLAG_PITCH_DOWN", "" };
+        case MOVEMENTFLAG_WALKING: return { "MOVEMENTFLAG_WALKING", "MOVEMENTFLAG_WALKING", "Walking" };
+        case MOVEMENTFLAG_DISABLE_GRAVITY: return { "MOVEMENTFLAG_DISABLE_GRAVITY", "MOVEMENTFLAG_DISABLE_GRAVITY", "Former MOVEMENTFLAG_LEVITATING. This is used when walking is not possible." };
+        case MOVEMENTFLAG_ROOT: return { "MOVEMENTFLAG_ROOT", "MOVEMENTFLAG_ROOT", "Must not be set along with MOVEMENTFLAG_MASK_MOVING" };
+        case MOVEMENTFLAG_FALLING: return { "MOVEMENTFLAG_FALLING", "MOVEMENTFLAG_FALLING", "damage dealt on that type of falling" };
+        case MOVEMENTFLAG_FALLING_FAR: return { "MOVEMENTFLAG_FALLING_FAR", "MOVEMENTFLAG_FALLING_FAR", "" };
+        case MOVEMENTFLAG_PENDING_STOP: return { "MOVEMENTFLAG_PENDING_STOP", "MOVEMENTFLAG_PENDING_STOP", "" };
+        case MOVEMENTFLAG_PENDING_STRAFE_STOP: return { "MOVEMENTFLAG_PENDING_STRAFE_STOP", "MOVEMENTFLAG_PENDING_STRAFE_STOP", "" };
+        case MOVEMENTFLAG_PENDING_FORWARD: return { "MOVEMENTFLAG_PENDING_FORWARD", "MOVEMENTFLAG_PENDING_FORWARD", "" };
+        case MOVEMENTFLAG_PENDING_BACKWARD: return { "MOVEMENTFLAG_PENDING_BACKWARD", "MOVEMENTFLAG_PENDING_BACKWARD", "" };
+        case MOVEMENTFLAG_PENDING_STRAFE_LEFT: return { "MOVEMENTFLAG_PENDING_STRAFE_LEFT", "MOVEMENTFLAG_PENDING_STRAFE_LEFT", "" };
+        case MOVEMENTFLAG_PENDING_STRAFE_RIGHT: return { "MOVEMENTFLAG_PENDING_STRAFE_RIGHT", "MOVEMENTFLAG_PENDING_STRAFE_RIGHT", "" };
+        case MOVEMENTFLAG_PENDING_ROOT: return { "MOVEMENTFLAG_PENDING_ROOT", "MOVEMENTFLAG_PENDING_ROOT", "" };
+        case MOVEMENTFLAG_SWIMMING: return { "MOVEMENTFLAG_SWIMMING", "MOVEMENTFLAG_SWIMMING", "appears with fly flag also" };
+        case MOVEMENTFLAG_ASCENDING: return { "MOVEMENTFLAG_ASCENDING", "MOVEMENTFLAG_ASCENDING", "press \042space\042 when flying" };
+        case MOVEMENTFLAG_DESCENDING: return { "MOVEMENTFLAG_DESCENDING", "MOVEMENTFLAG_DESCENDING", "" };
+        case MOVEMENTFLAG_CAN_FLY: return { "MOVEMENTFLAG_CAN_FLY", "MOVEMENTFLAG_CAN_FLY", "Appears when unit can fly. For example, appears when a player sits on a mount." };
+        case MOVEMENTFLAG_FLYING: return { "MOVEMENTFLAG_FLYING", "MOVEMENTFLAG_FLYING", "unit is actually flying. pretty sure this is only used for players. creatures use disable_gravity" };
+        case MOVEMENTFLAG_SPLINE_ELEVATION: return { "MOVEMENTFLAG_SPLINE_ELEVATION", "MOVEMENTFLAG_SPLINE_ELEVATION", "used for flight paths" };
+        case MOVEMENTFLAG_WATERWALKING: return { "MOVEMENTFLAG_WATERWALKING", "MOVEMENTFLAG_WATERWALKING", "prevent unit from falling through water" };
+        case MOVEMENTFLAG_FALLING_SLOW: return { "MOVEMENTFLAG_FALLING_SLOW", "MOVEMENTFLAG_FALLING_SLOW", "active rogue safe fall spell (passive)" };
+        case MOVEMENTFLAG_HOVER: return { "MOVEMENTFLAG_HOVER", "MOVEMENTFLAG_HOVER", "hover, cannot jump" };
+        case MOVEMENTFLAG_DISABLE_COLLISION: return { "MOVEMENTFLAG_DISABLE_COLLISION", "MOVEMENTFLAG_DISABLE_COLLISION", "" };
+        default: throw std::out_of_range("value");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MovementFlags>::Count() { return 31; }
+
+template <>
+TC_API_EXPORT MovementFlags EnumUtils<MovementFlags>::FromIndex(size_t index)
+{
+    switch (index)
+    {
+        case 0: return MOVEMENTFLAG_NONE;
+        case 1: return MOVEMENTFLAG_FORWARD;
+        case 2: return MOVEMENTFLAG_BACKWARD;
+        case 3: return MOVEMENTFLAG_STRAFE_LEFT;
+        case 4: return MOVEMENTFLAG_STRAFE_RIGHT;
+        case 5: return MOVEMENTFLAG_LEFT;
+        case 6: return MOVEMENTFLAG_RIGHT;
+        case 7: return MOVEMENTFLAG_PITCH_UP;
+        case 8: return MOVEMENTFLAG_PITCH_DOWN;
+        case 9: return MOVEMENTFLAG_WALKING;
+        case 10: return MOVEMENTFLAG_DISABLE_GRAVITY;
+        case 11: return MOVEMENTFLAG_ROOT;
+        case 12: return MOVEMENTFLAG_FALLING;
+        case 13: return MOVEMENTFLAG_FALLING_FAR;
+        case 14: return MOVEMENTFLAG_PENDING_STOP;
+        case 15: return MOVEMENTFLAG_PENDING_STRAFE_STOP;
+        case 16: return MOVEMENTFLAG_PENDING_FORWARD;
+        case 17: return MOVEMENTFLAG_PENDING_BACKWARD;
+        case 18: return MOVEMENTFLAG_PENDING_STRAFE_LEFT;
+        case 19: return MOVEMENTFLAG_PENDING_STRAFE_RIGHT;
+        case 20: return MOVEMENTFLAG_PENDING_ROOT;
+        case 21: return MOVEMENTFLAG_SWIMMING;
+        case 22: return MOVEMENTFLAG_ASCENDING;
+        case 23: return MOVEMENTFLAG_DESCENDING;
+        case 24: return MOVEMENTFLAG_CAN_FLY;
+        case 25: return MOVEMENTFLAG_FLYING;
+        case 26: return MOVEMENTFLAG_SPLINE_ELEVATION;
+        case 27: return MOVEMENTFLAG_WATERWALKING;
+        case 28: return MOVEMENTFLAG_FALLING_SLOW;
+        case 29: return MOVEMENTFLAG_HOVER;
+        case 30: return MOVEMENTFLAG_DISABLE_COLLISION;
+        default: throw std::out_of_range("index");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MovementFlags>::ToIndex(MovementFlags value)
+{
+    switch (value)
+    {
+        case MOVEMENTFLAG_NONE: return 0;
+        case MOVEMENTFLAG_FORWARD: return 1;
+        case MOVEMENTFLAG_BACKWARD: return 2;
+        case MOVEMENTFLAG_STRAFE_LEFT: return 3;
+        case MOVEMENTFLAG_STRAFE_RIGHT: return 4;
+        case MOVEMENTFLAG_LEFT: return 5;
+        case MOVEMENTFLAG_RIGHT: return 6;
+        case MOVEMENTFLAG_PITCH_UP: return 7;
+        case MOVEMENTFLAG_PITCH_DOWN: return 8;
+        case MOVEMENTFLAG_WALKING: return 9;
+        case MOVEMENTFLAG_DISABLE_GRAVITY: return 10;
+        case MOVEMENTFLAG_ROOT: return 11;
+        case MOVEMENTFLAG_FALLING: return 12;
+        case MOVEMENTFLAG_FALLING_FAR: return 13;
+        case MOVEMENTFLAG_PENDING_STOP: return 14;
+        case MOVEMENTFLAG_PENDING_STRAFE_STOP: return 15;
+        case MOVEMENTFLAG_PENDING_FORWARD: return 16;
+        case MOVEMENTFLAG_PENDING_BACKWARD: return 17;
+        case MOVEMENTFLAG_PENDING_STRAFE_LEFT: return 18;
+        case MOVEMENTFLAG_PENDING_STRAFE_RIGHT: return 19;
+        case MOVEMENTFLAG_PENDING_ROOT: return 20;
+        case MOVEMENTFLAG_SWIMMING: return 21;
+        case MOVEMENTFLAG_ASCENDING: return 22;
+        case MOVEMENTFLAG_DESCENDING: return 23;
+        case MOVEMENTFLAG_CAN_FLY: return 24;
+        case MOVEMENTFLAG_FLYING: return 25;
+        case MOVEMENTFLAG_SPLINE_ELEVATION: return 26;
+        case MOVEMENTFLAG_WATERWALKING: return 27;
+        case MOVEMENTFLAG_FALLING_SLOW: return 28;
+        case MOVEMENTFLAG_HOVER: return 29;
+        case MOVEMENTFLAG_DISABLE_COLLISION: return 30;
+        default: throw std::out_of_range("value");
+    }
+}
+
+/********************************************************************\
+|* data for enum 'MovementFlags2' in 'UnitDefines.h' auto-generated *|
+\********************************************************************/
+template <>
+TC_API_EXPORT EnumText EnumUtils<MovementFlags2>::ToString(MovementFlags2 value)
+{
+    switch (value)
+    {
+        case MOVEMENTFLAG2_NONE: return { "MOVEMENTFLAG2_NONE", "MOVEMENTFLAG2_NONE", "" };
+        case MOVEMENTFLAG2_NO_STRAFE: return { "MOVEMENTFLAG2_NO_STRAFE", "MOVEMENTFLAG2_NO_STRAFE", "" };
+        case MOVEMENTFLAG2_NO_JUMPING: return { "MOVEMENTFLAG2_NO_JUMPING", "MOVEMENTFLAG2_NO_JUMPING", "" };
+        case MOVEMENTFLAG2_FULL_SPEED_TURNING: return { "MOVEMENTFLAG2_FULL_SPEED_TURNING", "MOVEMENTFLAG2_FULL_SPEED_TURNING", "" };
+        case MOVEMENTFLAG2_FULL_SPEED_PITCHING: return { "MOVEMENTFLAG2_FULL_SPEED_PITCHING", "MOVEMENTFLAG2_FULL_SPEED_PITCHING", "" };
+        case MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING: return { "MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING", "MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING", "" };
+        case MOVEMENTFLAG2_IS_VEHICLE_EXIT_VOLUNTARY: return { "MOVEMENTFLAG2_IS_VEHICLE_EXIT_VOLUNTARY", "MOVEMENTFLAG2_IS_VEHICLE_EXIT_VOLUNTARY", "" };
+        case MOVEMENTFLAG2_WATERWALKING_FULL_PITCH: return { "MOVEMENTFLAG2_WATERWALKING_FULL_PITCH", "MOVEMENTFLAG2_WATERWALKING_FULL_PITCH", "will always waterwalk, even if facing the camera directly down" };
+        case MOVEMENTFLAG2_VEHICLE_PASSENGER_IS_TRANSITION_ALLOWED: return { "MOVEMENTFLAG2_VEHICLE_PASSENGER_IS_TRANSITION_ALLOWED", "MOVEMENTFLAG2_VEHICLE_PASSENGER_IS_TRANSITION_ALLOWED", "" };
+        case MOVEMENTFLAG2_CAN_SWIM_TO_FLY_TRANS: return { "MOVEMENTFLAG2_CAN_SWIM_TO_FLY_TRANS", "MOVEMENTFLAG2_CAN_SWIM_TO_FLY_TRANS", "" };
+        case MOVEMENTFLAG2_UNK9: return { "MOVEMENTFLAG2_UNK9", "MOVEMENTFLAG2_UNK9", "terrain normal calculation is disabled if this flag is not present, client automatically handles setting this flag" };
+        case MOVEMENTFLAG2_CAN_TURN_WHILE_FALLING: return { "MOVEMENTFLAG2_CAN_TURN_WHILE_FALLING", "MOVEMENTFLAG2_CAN_TURN_WHILE_FALLING", "" };
+        case MOVEMENTFLAG2_IGNORE_MOVEMENT_FORCES: return { "MOVEMENTFLAG2_IGNORE_MOVEMENT_FORCES", "MOVEMENTFLAG2_IGNORE_MOVEMENT_FORCES", "" };
+        case MOVEMENTFLAG2_CAN_DOUBLE_JUMP: return { "MOVEMENTFLAG2_CAN_DOUBLE_JUMP", "MOVEMENTFLAG2_CAN_DOUBLE_JUMP", "" };
+        case MOVEMENTFLAG2_DOUBLE_JUMP: return { "MOVEMENTFLAG2_DOUBLE_JUMP", "MOVEMENTFLAG2_DOUBLE_JUMP", "" };
+        case MOVEMENTFLAG2_AWAITING_LOAD: return { "MOVEMENTFLAG2_AWAITING_LOAD", "MOVEMENTFLAG2_AWAITING_LOAD", "" };
+        case MOVEMENTFLAG2_INTERPOLATED_MOVEMENT: return { "MOVEMENTFLAG2_INTERPOLATED_MOVEMENT", "MOVEMENTFLAG2_INTERPOLATED_MOVEMENT", "" };
+        case MOVEMENTFLAG2_INTERPOLATED_TURNING: return { "MOVEMENTFLAG2_INTERPOLATED_TURNING", "MOVEMENTFLAG2_INTERPOLATED_TURNING", "" };
+        case MOVEMENTFLAG2_INTERPOLATED_PITCHING: return { "MOVEMENTFLAG2_INTERPOLATED_PITCHING", "MOVEMENTFLAG2_INTERPOLATED_PITCHING", "" };
+        default: throw std::out_of_range("value");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MovementFlags2>::Count() { return 19; }
+
+template <>
+TC_API_EXPORT MovementFlags2 EnumUtils<MovementFlags2>::FromIndex(size_t index)
+{
+    switch (index)
+    {
+        case 0: return MOVEMENTFLAG2_NONE;
+        case 1: return MOVEMENTFLAG2_NO_STRAFE;
+        case 2: return MOVEMENTFLAG2_NO_JUMPING;
+        case 3: return MOVEMENTFLAG2_FULL_SPEED_TURNING;
+        case 4: return MOVEMENTFLAG2_FULL_SPEED_PITCHING;
+        case 5: return MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING;
+        case 6: return MOVEMENTFLAG2_IS_VEHICLE_EXIT_VOLUNTARY;
+        case 7: return MOVEMENTFLAG2_WATERWALKING_FULL_PITCH;
+        case 8: return MOVEMENTFLAG2_VEHICLE_PASSENGER_IS_TRANSITION_ALLOWED;
+        case 9: return MOVEMENTFLAG2_CAN_SWIM_TO_FLY_TRANS;
+        case 10: return MOVEMENTFLAG2_UNK9;
+        case 11: return MOVEMENTFLAG2_CAN_TURN_WHILE_FALLING;
+        case 12: return MOVEMENTFLAG2_IGNORE_MOVEMENT_FORCES;
+        case 13: return MOVEMENTFLAG2_CAN_DOUBLE_JUMP;
+        case 14: return MOVEMENTFLAG2_DOUBLE_JUMP;
+        case 15: return MOVEMENTFLAG2_AWAITING_LOAD;
+        case 16: return MOVEMENTFLAG2_INTERPOLATED_MOVEMENT;
+        case 17: return MOVEMENTFLAG2_INTERPOLATED_TURNING;
+        case 18: return MOVEMENTFLAG2_INTERPOLATED_PITCHING;
+        default: throw std::out_of_range("index");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MovementFlags2>::ToIndex(MovementFlags2 value)
+{
+    switch (value)
+    {
+        case MOVEMENTFLAG2_NONE: return 0;
+        case MOVEMENTFLAG2_NO_STRAFE: return 1;
+        case MOVEMENTFLAG2_NO_JUMPING: return 2;
+        case MOVEMENTFLAG2_FULL_SPEED_TURNING: return 3;
+        case MOVEMENTFLAG2_FULL_SPEED_PITCHING: return 4;
+        case MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING: return 5;
+        case MOVEMENTFLAG2_IS_VEHICLE_EXIT_VOLUNTARY: return 6;
+        case MOVEMENTFLAG2_WATERWALKING_FULL_PITCH: return 7;
+        case MOVEMENTFLAG2_VEHICLE_PASSENGER_IS_TRANSITION_ALLOWED: return 8;
+        case MOVEMENTFLAG2_CAN_SWIM_TO_FLY_TRANS: return 9;
+        case MOVEMENTFLAG2_UNK9: return 10;
+        case MOVEMENTFLAG2_CAN_TURN_WHILE_FALLING: return 11;
+        case MOVEMENTFLAG2_IGNORE_MOVEMENT_FORCES: return 12;
+        case MOVEMENTFLAG2_CAN_DOUBLE_JUMP: return 13;
+        case MOVEMENTFLAG2_DOUBLE_JUMP: return 14;
+        case MOVEMENTFLAG2_AWAITING_LOAD: return 15;
+        case MOVEMENTFLAG2_INTERPOLATED_MOVEMENT: return 16;
+        case MOVEMENTFLAG2_INTERPOLATED_TURNING: return 17;
+        case MOVEMENTFLAG2_INTERPOLATED_PITCHING: return 18;
+        default: throw std::out_of_range("value");
+    }
+}
+
+/********************************************************************\
+|* data for enum 'MovementFlags3' in 'UnitDefines.h' auto-generated *|
+\********************************************************************/
+template <>
+TC_API_EXPORT EnumText EnumUtils<MovementFlags3>::ToString(MovementFlags3 value)
+{
+    switch (value)
+    {
+        case MOVEMENTFLAG3_NONE: return { "MOVEMENTFLAG3_NONE", "MOVEMENTFLAG3_NONE", "" };
+        case MOVEMENTFLAG3_DISABLE_INERTIA: return { "MOVEMENTFLAG3_DISABLE_INERTIA", "MOVEMENTFLAG3_DISABLE_INERTIA", "" };
+        case MOVEMENTFLAG3_CAN_ADV_FLY: return { "MOVEMENTFLAG3_CAN_ADV_FLY", "MOVEMENTFLAG3_CAN_ADV_FLY", "" };
+        case MOVEMENTFLAG3_ADV_FLYING: return { "MOVEMENTFLAG3_ADV_FLYING", "MOVEMENTFLAG3_ADV_FLYING", "" };
+        default: throw std::out_of_range("value");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MovementFlags3>::Count() { return 4; }
+
+template <>
+TC_API_EXPORT MovementFlags3 EnumUtils<MovementFlags3>::FromIndex(size_t index)
+{
+    switch (index)
+    {
+        case 0: return MOVEMENTFLAG3_NONE;
+        case 1: return MOVEMENTFLAG3_DISABLE_INERTIA;
+        case 2: return MOVEMENTFLAG3_CAN_ADV_FLY;
+        case 3: return MOVEMENTFLAG3_ADV_FLYING;
+        default: throw std::out_of_range("index");
+    }
+}
+
+template <>
+TC_API_EXPORT size_t EnumUtils<MovementFlags3>::ToIndex(MovementFlags3 value)
+{
+    switch (value)
+    {
+        case MOVEMENTFLAG3_NONE: return 0;
+        case MOVEMENTFLAG3_DISABLE_INERTIA: return 1;
+        case MOVEMENTFLAG3_CAN_ADV_FLY: return 2;
+        case MOVEMENTFLAG3_ADV_FLYING: return 3;
+        default: throw std::out_of_range("value");
+    }
+}
 }