Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-19 17:05:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
(cherry picked from commit a02804fa02)
This commit is contained in:
Shauren
2024-04-23 11:09:59 +02:00
committed by Ovahlord
parent 10df0cba8e
commit d4e18bdef4
12 changed files with 634 additions and 274 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/server/game/Entities/Object/Object.cpp
View File

@@ -863,8 +863,9 @@ void MovementInfo::OutDebug()
{
TC_LOG_DEBUG("misc", "MOVEMENT INFO");
TC_LOG_DEBUG("misc", "{}", guid.ToString());
TC_LOG_DEBUG("misc", "flags {} ({})", Movement::MovementFlags_ToString(flags), flags);
TC_LOG_DEBUG("misc", "flags2 {} ({})", Movement::MovementFlagsExtra_ToString(flags2), flags2);
TC_LOG_DEBUG("misc", "flags {} ({})", Movement::MovementFlags_ToString(MovementFlags(flags)), flags);
TC_LOG_DEBUG("misc", "flags2 {} ({})", Movement::MovementFlags_ToString(MovementFlags2(flags2)), flags2);
TC_LOG_DEBUG("misc", "flags3 {} ({})", Movement::MovementFlags_ToString(MovementFlags3(flags3)), flags2);
TC_LOG_DEBUG("misc", "time {} current time {}", time, getMSTime());
TC_LOG_DEBUG("misc", "position: `{}`", pos.ToString());
if (!transport.guid.IsEmpty())

15
src/server/game/Entities/Unit/UnitDefines.h
View File

@@ -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,

261
src/server/game/Entities/Unit/enuminfo_UnitDefines.cpp
View File

@@ -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");
}
}
}

36
src/server/game/Movement/Spline/MoveSpline.cpp
View File

@@ -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();
}

8
src/server/game/Movement/Spline/MoveSpline.h
View File

@@ -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;

221
src/server/game/Movement/Spline/MoveSplineFlag.h
View File

@@ -19,124 +19,145 @@
#define TRINITYSERVER_MOVESPLINEFLAG_H
#include "Define.h"
#include "EnumFlag.h"
#include <string>
namespace Movement
{
#pragma pack(push, 1)
class MoveSplineFlag
// EnumUtils: DESCRIBE THIS
enum class MoveSplineFlagEnum : uint32
{
public:
enum eFlags : 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);
consteval MoveSplineFlagEnum GetDisallowedFlagsFor(MoveSplineFlagEnum flag)
{
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
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;
}
// 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; }
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; }
constexpr MoveSplineFlag& operator&=(MoveSplineFlagEnum f) { Raw &= f; return *this; }
constexpr MoveSplineFlag& operator|=(MoveSplineFlagEnum f) { Raw |= f; return *this; }
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; }
EnumFlag<MoveSplineFlagEnum> Raw;
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;
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

22
src/server/game/Movement/Spline/MoveSplineInit.cpp
View File

@@ -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)

26
src/server/game/Movement/Spline/MoveSplineInit.h
View File

@@ -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; }

9
src/server/game/Movement/Spline/MovementTypedefs.h
View File

@@ -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

128
src/server/game/Movement/Spline/MovementUtil.cpp
View File

@@ -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[] =
template<class Flags>
void PrintFlags(Flags t, std::string& str)
{
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[] =
{
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(uint32 flags)
std::string MovementFlags_ToString(MovementFlags flags)
{
std::string str;
PrintFlags(flags, MovementFlagNames, str);
PrintFlags(flags, str);
return str;
}
std::string MovementFlagsExtra_ToString(uint32 flags)
std::string MovementFlags_ToString(MovementFlags2 flags)
{
std::string str;
PrintFlags(flags, MovementFlagExtraNames, str);
PrintFlags(flags, str);
return str;
}
std::string MovementFlags_ToString(MovementFlags3 flags)
{
std::string str;
PrintFlags(flags, str);
return str;
}
}

159
src/server/game/Movement/Spline/enuminfo_MoveSplineFlag.cpp Normal file
View File

@@ -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");
}
}
}

18
src/server/game/Server/Packets/MovementPackets.cpp
View File

@@ -365,17 +365,17 @@ void WorldPackets::Movement::CommonMovement::WriteCreateObjectSplineDataBlock(::
if (hasSplineMove) // MovementSplineMove
{
data << uint32(moveSpline.splineflags.raw()); // SplineFlags
data << uint32(moveSpline.splineflags.Raw.AsUnderlyingType()); // SplineFlags
data << int32(moveSpline.timePassed()); // Elapsed
data << uint32(moveSpline.Duration()); // Duration
data << float(1.0f); // DurationModifier
data << float(1.0f); // NextDurationModifier
data.WriteBits(moveSpline.facing.type, 2); // Face
bool hasFadeObjectTime = data.WriteBit(moveSpline.splineflags.fadeObject && moveSpline.effect_start_time < moveSpline.Duration());
bool hasFadeObjectTime = data.WriteBit(moveSpline.splineflags.FadeObject && moveSpline.effect_start_time < moveSpline.Duration());
data.WriteBits(moveSpline.getPath().size(), 16);
data.WriteBit(false); // HasSplineFilter
data.WriteBit(moveSpline.spell_effect_extra.has_value()); // HasSpellEffectExtraData
bool hasJumpExtraData = data.WriteBit(moveSpline.splineflags.parabolic && (!moveSpline.spell_effect_extra || moveSpline.effect_start_time));
bool hasJumpExtraData = data.WriteBit(moveSpline.splineflags.Parabolic && (!moveSpline.spell_effect_extra || moveSpline.effect_start_time));
data.WriteBit(moveSpline.anim_tier.has_value()); // HasAnimTierTransition
data.WriteBit(false); // HasUnknown901
data.FlushBits();
@@ -506,7 +506,7 @@ void WorldPackets::Movement::MonsterMove::InitializeSplineData(::Movement::MoveS
WorldPackets::Movement::MovementSpline& movementSpline = SplineData.Move;
::Movement::MoveSplineFlag splineFlags = moveSpline.splineflags;
movementSpline.Flags = uint32(splineFlags & uint32(~::Movement::MoveSplineFlag::Mask_No_Monster_Move));
movementSpline.Flags = uint32(splineFlags & ~::Movement::MoveSplineFlagEnum::Mask_No_Monster_Move);
movementSpline.Face = moveSpline.facing.type;
movementSpline.FaceDirection = moveSpline.facing.angle;
movementSpline.FaceGUID = moveSpline.facing.target;
@@ -522,14 +522,14 @@ void WorldPackets::Movement::MonsterMove::InitializeSplineData(::Movement::MoveS
movementSpline.MoveTime = moveSpline.Duration();
if (splineFlags.parabolic && (!moveSpline.spell_effect_extra || moveSpline.effect_start_time))
if (splineFlags.Parabolic && (!moveSpline.spell_effect_extra || moveSpline.effect_start_time))
{
movementSpline.JumpExtraData.emplace();
movementSpline.JumpExtraData->JumpGravity = moveSpline.vertical_acceleration;
movementSpline.JumpExtraData->StartTime = moveSpline.effect_start_time;
}
if (splineFlags.fadeObject)
if (splineFlags.FadeObject)
movementSpline.FadeObjectTime = moveSpline.effect_start_time;
if (moveSpline.spell_effect_extra)
@@ -545,15 +545,15 @@ void WorldPackets::Movement::MonsterMove::InitializeSplineData(::Movement::MoveS
::Movement::Spline<int32> const& spline = moveSpline.spline;
std::vector<G3D::Vector3> const& array = spline.getPoints();
if (splineFlags & ::Movement::MoveSplineFlag::UncompressedPath)
if (splineFlags.UncompressedPath)
{
uint32 count = spline.getPointCount() - (splineFlags.cyclic ? 4 : 3);
uint32 count = spline.getPointCount() - (splineFlags.Cyclic ? 4 : 3);
for (uint32 i = 0; i < count; ++i)
movementSpline.Points.emplace_back(array[i + 2].x, array[i + 2].y, array[i + 2].z);
}
else
{
uint32 lastIdx = spline.getPointCount() - (splineFlags.cyclic ? 4 : 3);
uint32 lastIdx = spline.getPointCount() - (splineFlags.Cyclic ? 4 : 3);
G3D::Vector3 const* realPath = &array[1];
movementSpline.Points.emplace_back(realPath[lastIdx].x, realPath[lastIdx].y, realPath[lastIdx].z);