rerename

src/server/game/Movement/MotionMaster.cpp

@@ -63,9 +63,9 @@ void MotionMaster::Initialize()
 // set new default movement generator
 void MotionMaster::InitDefault()
 {
-    if (m_owner->GetTypeId() == TYPEID_UNIT)
+    if (_owner->GetTypeId() == TYPEID_UNIT)
     {
-        MovementGenerator* movement = FactorySelector::selectMovementGenerator(m_owner->ToCreature());
+        MovementGenerator* movement = FactorySelector::selectMovementGenerator(_owner->ToCreature());
         Mutate(movement == NULL ? &si_idleMovement : movement, MOTION_SLOT_IDLE);
     }
     else
@@ -76,56 +76,56 @@ void MotionMaster::InitDefault()
 
 void MotionMaster::UpdateMotion(uint32 diff)
 {
-    if (!m_owner)
+    if (!_owner)
         return;
 
-    if (m_owner->HasUnitState(UNIT_STATE_ROOT | UNIT_STATE_STUNNED)) // what about UNIT_STATE_DISTRACTED? Why is this not included?
+    if (_owner->HasUnitState(UNIT_STATE_ROOT | UNIT_STATE_STUNNED)) // what about UNIT_STATE_DISTRACTED? Why is this not included?
         return;
 
     ASSERT(!empty());
 
-    m_cleanFlag |= MMCF_UPDATE;
-    if (!top()->Update(m_owner, diff))
+    _cleanFlag |= MMCF_UPDATE;
+    if (!top()->Update(_owner, diff))
     {
-        m_cleanFlag &= ~MMCF_UPDATE;
+        _cleanFlag &= ~MMCF_UPDATE;
         MovementExpired();
     }
     else
-        m_cleanFlag &= ~MMCF_UPDATE;
+        _cleanFlag &= ~MMCF_UPDATE;
 
-    if (m_expireList)
+    if (_expireList)
     {
-        for (size_t i = 0; i < m_expireList->size(); ++i)
+        for (size_t i = 0; i < _expireList->size(); ++i)
         {
-            MovementGenerator* mg = (*m_expireList)[i];
+            MovementGenerator* mg = (*_expireList)[i];
             DirectDelete(mg);
         }
 
-        delete m_expireList;
-        m_expireList = nullptr;
+        delete _expireList;
+        _expireList = nullptr;
 
         if (empty())
             Initialize();
         else if (NeedInitTop())
             InitTop();
-        else if (m_cleanFlag & MMCF_RESET)
-            top()->Reset(m_owner);
+        else if (_cleanFlag & MMCF_RESET)
+            top()->Reset(_owner);
 
-        m_cleanFlag &= ~MMCF_RESET;
+        _cleanFlag &= ~MMCF_RESET;
     }
 
     // probably not the best place to pu this but im not really sure where else to put it.
-    m_owner->UpdateUnderwaterState(m_owner->GetMap(), m_owner->GetPositionX(), m_owner->GetPositionY(), m_owner->GetPositionZ());
+    _owner->UpdateUnderwaterState(_owner->GetMap(), _owner->GetPositionX(), _owner->GetPositionY(), _owner->GetPositionZ());
 }
 
 void MotionMaster::Clear(bool reset /*= true*/)
 {
-    if (m_cleanFlag & MMCF_UPDATE)
+    if (_cleanFlag & MMCF_UPDATE)
     {
         if (reset)
-            m_cleanFlag |= MMCF_RESET;
+            _cleanFlag |= MMCF_RESET;
         else
-            m_cleanFlag &= ~MMCF_RESET;
+            _cleanFlag &= ~MMCF_RESET;
         DelayedClean();
     }
     else
@@ -134,12 +134,12 @@ void MotionMaster::Clear(bool reset /*= true*/)
 
 void MotionMaster::MovementExpired(bool reset /*= true*/)
 {
-    if (m_cleanFlag & MMCF_UPDATE)
+    if (_cleanFlag & MMCF_UPDATE)
     {
         if (reset)
-            m_cleanFlag |= MMCF_RESET;
+            _cleanFlag |= MMCF_RESET;
         else
-            m_cleanFlag &= ~MMCF_RESET;
+            _cleanFlag &= ~MMCF_RESET;
         DelayedExpire();
     }
     else
@@ -156,33 +156,33 @@ MovementGeneratorType MotionMaster::GetCurrentMovementGeneratorType() const
 
 MovementGeneratorType MotionMaster::GetMotionSlotType(int slot) const
 {
-    if (!m_slot[slot])
+    if (!_slot[slot])
         return NULL_MOTION_TYPE;
     else
-        return m_slot[slot]->GetMovementGeneratorType();
+        return _slot[slot]->GetMovementGeneratorType();
 }
 
 MovementGenerator* MotionMaster::GetMotionSlot(int slot) const
 {
     ASSERT(slot >= 0);
-    return m_slot[slot];
+    return _slot[slot];
 }
 
 void MotionMaster::propagateSpeedChange()
 {
-    for (int i = 0; i <= m_top; ++i)
+    for (int i = 0; i <= _top; ++i)
     {
-        if (m_slot[i])
-            m_slot[i]->unitSpeedChanged();
+        if (_slot[i])
+            _slot[i]->unitSpeedChanged();
     }
 }
 
 bool MotionMaster::GetDestination(float &x, float &y, float &z)
 {
-    if (m_owner->movespline->Finalized())
+    if (_owner->movespline->Finalized())
         return false;
 
-    G3D::Vector3 const& dest = m_owner->movespline->FinalDestination();
+    G3D::Vector3 const& dest = _owner->movespline->FinalDestination();
     x = dest.x;
     y = dest.y;
     z = dest.z;
@@ -200,15 +200,15 @@ void MotionMaster::MoveTargetedHome()
 {
     Clear(false);
 
-    if (m_owner->GetTypeId() == TYPEID_UNIT && !m_owner->ToCreature()->GetCharmerOrOwnerGUID())
+    if (_owner->GetTypeId() == TYPEID_UNIT && !_owner->ToCreature()->GetCharmerOrOwnerGUID())
     {
-        TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) targeted home.", m_owner->GetEntry(), m_owner->GetGUID().GetCounter());
+        TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) targeted home.", _owner->GetEntry(), _owner->GetGUID().GetCounter());
         Mutate(new HomeMovementGenerator<Creature>(), MOTION_SLOT_ACTIVE);
     }
-    else if (m_owner->GetTypeId() == TYPEID_UNIT && m_owner->ToCreature()->GetCharmerOrOwnerGUID())
+    else if (_owner->GetTypeId() == TYPEID_UNIT && _owner->ToCreature()->GetCharmerOrOwnerGUID())
     {
-        TC_LOG_DEBUG("misc", "Pet or controlled creature (Entry: %u GUID: %u) is targeting home.", m_owner->GetEntry(), m_owner->GetGUID().GetCounter());
-        Unit* target = m_owner->ToCreature()->GetCharmerOrOwner();
+        TC_LOG_DEBUG("misc", "Pet or controlled creature (Entry: %u GUID: %u) is targeting home.", _owner->GetEntry(), _owner->GetGUID().GetCounter());
+        Unit* target = _owner->ToCreature()->GetCharmerOrOwner();
         if (target)
         {
             TC_LOG_DEBUG("misc", "Following %s (GUID: %u).", target->GetTypeId() == TYPEID_PLAYER ? "player" : "creature", target->GetTypeId() == TYPEID_PLAYER ? target->GetGUID().GetCounter() : ((Creature*)target)->GetSpawnId());
@@ -217,15 +217,15 @@ void MotionMaster::MoveTargetedHome()
     }
     else
     {
-        TC_LOG_ERROR("misc", "Player (GUID: %u) attempted to move towards target home.", m_owner->GetGUID().GetCounter());
+        TC_LOG_ERROR("misc", "Player (GUID: %u) attempted to move towards target home.", _owner->GetGUID().GetCounter());
     }
 }
 
 void MotionMaster::MoveRandom(float spawndist)
 {
-    if (m_owner->GetTypeId() == TYPEID_UNIT)
+    if (_owner->GetTypeId() == TYPEID_UNIT)
     {
-        TC_LOG_DEBUG("misc", "Creature (GUID: %u) started random movement.", m_owner->GetGUID().GetCounter());
+        TC_LOG_DEBUG("misc", "Creature (GUID: %u) started random movement.", _owner->GetGUID().GetCounter());
         Mutate(new RandomMovementGenerator<Creature>(spawndist), MOTION_SLOT_IDLE);
     }
 }
@@ -233,13 +233,13 @@ void MotionMaster::MoveRandom(float spawndist)
 void MotionMaster::MoveFollow(Unit* target, float dist, float angle, MovementSlot slot)
 {
     // ignore movement request if target not exist
-    if (!target || target == m_owner)
+    if (!target || target == _owner)
         return;
 
-    //m_owner->AddUnitState(UNIT_STATE_FOLLOW);
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    //_owner->AddUnitState(UNIT_STATE_FOLLOW);
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
-        TC_LOG_DEBUG("misc", "Player (GUID: %u) follows %s (GUID: %u).", m_owner->GetGUID().GetCounter(),
+        TC_LOG_DEBUG("misc", "Player (GUID: %u) follows %s (GUID: %u).", _owner->GetGUID().GetCounter(),
             target->GetTypeId() == TYPEID_PLAYER ? "player" : "creature",
             target->GetTypeId() == TYPEID_PLAYER ? target->GetGUID().GetCounter() : target->ToCreature()->GetSpawnId());
         Mutate(new FollowMovementGenerator<Player>(target, dist, angle), slot);
@@ -247,7 +247,7 @@ void MotionMaster::MoveFollow(Unit* target, float dist, float angle, MovementSlo
     else
     {
         TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) follows %s (GUID: %u).",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter(),
+            _owner->GetEntry(), _owner->GetGUID().GetCounter(),
             target->GetTypeId() == TYPEID_PLAYER ? "player" : "creature",
             target->GetTypeId() == TYPEID_PLAYER ? target->GetGUID().GetCounter() : target->ToCreature()->GetSpawnId());
         Mutate(new FollowMovementGenerator<Creature>(target, dist, angle), slot);
@@ -257,14 +257,14 @@ void MotionMaster::MoveFollow(Unit* target, float dist, float angle, MovementSlo
 void MotionMaster::MoveChase(Unit* target, float dist, float angle)
 {
     // ignore movement request if target not exist
-    if (!target || target == m_owner)
+    if (!target || target == _owner)
         return;
 
-    //m_owner->ClearUnitState(UNIT_STATE_FOLLOW);
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    //_owner->ClearUnitState(UNIT_STATE_FOLLOW);
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
         TC_LOG_DEBUG("misc", "Player (GUID: %u) chase to %s (GUID: %u)",
-            m_owner->GetGUID().GetCounter(),
+            _owner->GetGUID().GetCounter(),
             target->GetTypeId() == TYPEID_PLAYER ? "player" : "creature",
             target->GetTypeId() == TYPEID_PLAYER ? target->GetGUID().GetCounter() : target->ToCreature()->GetSpawnId());
         Mutate(new ChaseMovementGenerator<Player>(target, dist, angle), MOTION_SLOT_ACTIVE);
@@ -272,7 +272,7 @@ void MotionMaster::MoveChase(Unit* target, float dist, float angle)
     else
     {
         TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) chase to %s (GUID: %u)",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter(),
+            _owner->GetEntry(), _owner->GetGUID().GetCounter(),
             target->GetTypeId() == TYPEID_PLAYER ? "player" : "creature",
             target->GetTypeId() == TYPEID_PLAYER ? target->GetGUID().GetCounter() : target->ToCreature()->GetSpawnId());
         Mutate(new ChaseMovementGenerator<Creature>(target, dist, angle), MOTION_SLOT_ACTIVE);
@@ -281,15 +281,15 @@ void MotionMaster::MoveChase(Unit* target, float dist, float angle)
 
 void MotionMaster::MoveConfused()
 {
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
-        TC_LOG_DEBUG("misc", "Player (GUID: %u) move confused", m_owner->GetGUID().GetCounter());
+        TC_LOG_DEBUG("misc", "Player (GUID: %u) move confused", _owner->GetGUID().GetCounter());
         Mutate(new ConfusedMovementGenerator<Player>(), MOTION_SLOT_CONTROLLED);
     }
     else
     {
         TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) move confused",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter());
+            _owner->GetEntry(), _owner->GetGUID().GetCounter());
         Mutate(new ConfusedMovementGenerator<Creature>(), MOTION_SLOT_CONTROLLED);
     }
 }
@@ -299,9 +299,9 @@ void MotionMaster::MoveFleeing(Unit* enemy, uint32 time)
     if (!enemy)
         return;
 
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
-        TC_LOG_DEBUG("misc", "Player (GUID: %u) flees from %s (GUID: %u).", m_owner->GetGUID().GetCounter(),
+        TC_LOG_DEBUG("misc", "Player (GUID: %u) flees from %s (GUID: %u).", _owner->GetGUID().GetCounter(),
             enemy->GetTypeId() == TYPEID_PLAYER ? "player" : "creature",
             enemy->GetTypeId() == TYPEID_PLAYER ? enemy->GetGUID().GetCounter() : enemy->ToCreature()->GetSpawnId());
         Mutate(new FleeingMovementGenerator<Player>(enemy->GetGUID()), MOTION_SLOT_CONTROLLED);
@@ -309,7 +309,7 @@ void MotionMaster::MoveFleeing(Unit* enemy, uint32 time)
     else
     {
         TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) flees from %s (GUID: %u)%s.",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter(),
+            _owner->GetEntry(), _owner->GetGUID().GetCounter(),
             enemy->GetTypeId() == TYPEID_PLAYER ? "player" : "creature",
             enemy->GetTypeId() == TYPEID_PLAYER ? enemy->GetGUID().GetCounter() : enemy->ToCreature()->GetSpawnId(),
             time ? " for a limited time" : "");
@@ -322,34 +322,34 @@ void MotionMaster::MoveFleeing(Unit* enemy, uint32 time)
 
 void MotionMaster::MovePoint(uint32 id, float x, float y, float z, bool generatePath)
 {
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
-        TC_LOG_DEBUG("misc", "Player (GUID: %u) targeted point (Id: %u X: %f Y: %f Z: %f).", m_owner->GetGUID().GetCounter(), id, x, y, z);
+        TC_LOG_DEBUG("misc", "Player (GUID: %u) targeted point (Id: %u X: %f Y: %f Z: %f).", _owner->GetGUID().GetCounter(), id, x, y, z);
         Mutate(new PointMovementGenerator<Player>(id, x, y, z, generatePath), MOTION_SLOT_ACTIVE);
     }
     else
     {
         TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) targeted point (ID: %u X: %f Y: %f Z: %f).",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter(), id, x, y, z);
+            _owner->GetEntry(), _owner->GetGUID().GetCounter(), id, x, y, z);
         Mutate(new PointMovementGenerator<Creature>(id, x, y, z, generatePath), MOTION_SLOT_ACTIVE);
     }
 }
 
 void MotionMaster::MoveCloserAndStop(uint32 id, Unit* target, float distance)
 {
-    float distanceToTravel = m_owner->GetExactDist2d(target) - distance;
+    float distanceToTravel = _owner->GetExactDist2d(target) - distance;
     if (distanceToTravel > 0.0f)
     {
-        float angle = m_owner->GetAngle(target);
-        float destx = m_owner->GetPositionX() + distanceToTravel * std::cos(angle);
-        float desty = m_owner->GetPositionY() + distanceToTravel * std::sin(angle);
+        float angle = _owner->GetAngle(target);
+        float destx = _owner->GetPositionX() + distanceToTravel * std::cos(angle);
+        float desty = _owner->GetPositionY() + distanceToTravel * std::sin(angle);
         MovePoint(id, destx, desty, target->GetPositionZ());
     }
     else
     {
         // we are already close enough. We just need to turn toward the target without changing position.
-        Movement::MoveSplineInit init(m_owner);
-        init.MoveTo(m_owner->GetPositionX(), m_owner->GetPositionY(), m_owner->GetPositionZMinusOffset());
+        Movement::MoveSplineInit init(_owner);
+        init.MoveTo(_owner->GetPositionX(), _owner->GetPositionY(), _owner->GetPositionZMinusOffset());
         init.SetFacing(target);
         init.Launch();
         Mutate(new EffectMovementGenerator(id), MOTION_SLOT_ACTIVE);
@@ -361,9 +361,9 @@ void MotionMaster::MoveLand(uint32 id, Position const& pos)
     float x, y, z;
     pos.GetPosition(x, y, z);
 
-    TC_LOG_DEBUG("misc", "Creature (Entry: %u) landing point (ID: %u X: %f Y: %f Z: %f).", m_owner->GetEntry(), id, x, y, z);
+    TC_LOG_DEBUG("misc", "Creature (Entry: %u) landing point (ID: %u X: %f Y: %f Z: %f).", _owner->GetEntry(), id, x, y, z);
 
-    Movement::MoveSplineInit init(m_owner);
+    Movement::MoveSplineInit init(_owner);
     init.MoveTo(x, y, z);
     init.SetAnimation(Movement::ToGround);
     init.Launch();
@@ -375,9 +375,9 @@ void MotionMaster::MoveTakeoff(uint32 id, Position const& pos)
     float x, y, z;
     pos.GetPosition(x, y, z);
 
-    TC_LOG_DEBUG("misc", "Creature (Entry: %u) landing point (ID: %u X: %f Y: %f Z: %f).", m_owner->GetEntry(), id, x, y, z);
+    TC_LOG_DEBUG("misc", "Creature (Entry: %u) landing point (ID: %u X: %f Y: %f Z: %f).", _owner->GetEntry(), id, x, y, z);
 
-    Movement::MoveSplineInit init(m_owner);
+    Movement::MoveSplineInit init(_owner);
     init.MoveTo(x, y, z);
     init.SetAnimation(Movement::ToFly);
     init.Launch();
@@ -386,18 +386,18 @@ void MotionMaster::MoveTakeoff(uint32 id, Position const& pos)
 
 void MotionMaster::MoveCharge(float x, float y, float z, float speed /*= SPEED_CHARGE*/, uint32 id /*= EVENT_CHARGE*/, bool generatePath /*= false*/)
 {
-    if (m_slot[MOTION_SLOT_CONTROLLED] && m_slot[MOTION_SLOT_CONTROLLED]->GetMovementGeneratorType() != DISTRACT_MOTION_TYPE)
+    if (_slot[MOTION_SLOT_CONTROLLED] && _slot[MOTION_SLOT_CONTROLLED]->GetMovementGeneratorType() != DISTRACT_MOTION_TYPE)
         return;
 
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
-        TC_LOG_DEBUG("misc", "Player (GUID: %u) charged point (X: %f Y: %f Z: %f).", m_owner->GetGUID().GetCounter(), x, y, z);
+        TC_LOG_DEBUG("misc", "Player (GUID: %u) charged point (X: %f Y: %f Z: %f).", _owner->GetGUID().GetCounter(), x, y, z);
         Mutate(new PointMovementGenerator<Player>(id, x, y, z, generatePath, speed), MOTION_SLOT_CONTROLLED);
     }
     else
     {
         TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) charged point (X: %f Y: %f Z: %f).",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter(), x, y, z);
+            _owner->GetEntry(), _owner->GetGUID().GetCounter(), x, y, z);
         Mutate(new PointMovementGenerator<Creature>(id, x, y, z, generatePath, speed), MOTION_SLOT_CONTROLLED);
     }
 }
@@ -409,7 +409,7 @@ void MotionMaster::MoveCharge(PathGenerator const& path, float speed /*= SPEED_C
     MoveCharge(dest.x, dest.y, dest.z, speed, EVENT_CHARGE_PREPATH);
 
     // Charge movement is not started when using EVENT_CHARGE_PREPATH
-    Movement::MoveSplineInit init(m_owner);
+    Movement::MoveSplineInit init(_owner);
     init.MovebyPath(path.GetPath());
     init.SetVelocity(speed);
     init.Launch();
@@ -418,7 +418,7 @@ void MotionMaster::MoveCharge(PathGenerator const& path, float speed /*= SPEED_C
 void MotionMaster::MoveKnockbackFrom(float srcX, float srcY, float speedXY, float speedZ)
 {
     //this function may make players fall below map
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
         return;
 
     if (speedXY <= 0.1f)
@@ -429,9 +429,9 @@ void MotionMaster::MoveKnockbackFrom(float srcX, float srcY, float speedXY, floa
     float dist = 2 * moveTimeHalf * speedXY;
     float max_height = -Movement::computeFallElevation(moveTimeHalf, false, -speedZ);
 
-    m_owner->GetNearPoint(m_owner, x, y, z, m_owner->GetObjectSize(), dist, m_owner->GetAngle(srcX, srcY) + float(M_PI));
+    _owner->GetNearPoint(_owner, x, y, z, _owner->GetObjectSize(), dist, _owner->GetAngle(srcX, srcY) + float(M_PI));
 
-    Movement::MoveSplineInit init(m_owner);
+    Movement::MoveSplineInit init(_owner);
     init.MoveTo(x, y, z);
     init.SetParabolic(max_height, 0);
     init.SetOrientationFixed(true);
@@ -443,27 +443,27 @@ void MotionMaster::MoveKnockbackFrom(float srcX, float srcY, float speedXY, floa
 void MotionMaster::MoveJumpTo(float angle, float speedXY, float speedZ)
 {
     //this function may make players fall below map
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
         return;
 
     float x, y, z;
 
     float moveTimeHalf = speedZ / Movement::gravity;
     float dist = 2 * moveTimeHalf * speedXY;
-    m_owner->GetClosePoint(x, y, z, m_owner->GetObjectSize(), dist, angle);
+    _owner->GetClosePoint(x, y, z, _owner->GetObjectSize(), dist, angle);
     MoveJump(x, y, z, 0.0f, speedXY, speedZ);
 }
 
 void MotionMaster::MoveJump(float x, float y, float z, float o, float speedXY, float speedZ, uint32 id, bool hasOrientation /* = false*/)
 {
-    TC_LOG_DEBUG("misc", "Unit (GUID: %u) jumps to point (X: %f Y: %f Z: %f).", m_owner->GetGUID().GetCounter(), x, y, z);
+    TC_LOG_DEBUG("misc", "Unit (GUID: %u) jumps to point (X: %f Y: %f Z: %f).", _owner->GetGUID().GetCounter(), x, y, z);
     if (speedXY <= 0.1f)
         return;
 
     float moveTimeHalf = speedZ / Movement::gravity;
     float max_height = -Movement::computeFallElevation(moveTimeHalf, false, -speedZ);
 
-    Movement::MoveSplineInit init(m_owner);
+    Movement::MoveSplineInit init(_owner);
     init.MoveTo(x, y, z, false);
     init.SetParabolic(max_height, 0);
     init.SetVelocity(speedXY);
@@ -477,9 +477,9 @@ void MotionMaster::MoveCirclePath(float x, float y, float z, float radius, bool
 {
     float step = 2 * float(M_PI) / stepCount * (clockwise ? -1.0f : 1.0f);
     Position const& pos = { x, y, z, 0.0f };
-    float angle = pos.GetAngle(m_owner->GetPositionX(), m_owner->GetPositionY());
+    float angle = pos.GetAngle(_owner->GetPositionX(), _owner->GetPositionY());
 
-    Movement::MoveSplineInit init(m_owner);
+    Movement::MoveSplineInit init(_owner);
 
     for (uint8 i = 0; i < stepCount; angle += step, ++i)
     {
@@ -487,15 +487,15 @@ void MotionMaster::MoveCirclePath(float x, float y, float z, float radius, bool
         point.x = x + radius * cosf(angle);
         point.y = y + radius * sinf(angle);
 
-        if (m_owner->IsFlying())
+        if (_owner->IsFlying())
             point.z = z;
         else
-            point.z = m_owner->GetMap()->GetHeight(m_owner->GetPhaseMask(), point.x, point.y, z);
+            point.z = _owner->GetMap()->GetHeight(_owner->GetPhaseMask(), point.x, point.y, z);
 
         init.Path().push_back(point);
     }
 
-    if (m_owner->IsFlying())
+    if (_owner->IsFlying())
     {
         init.SetFly();
         init.SetCyclic();
@@ -518,7 +518,7 @@ void MotionMaster::MoveSmoothPath(uint32 pointId, G3D::Vector3 const* pathPoints
 
 void MotionMaster::MoveSmoothPath(uint32 pointId, Movement::PointsArray const& path, bool walk)
 {
-    Movement::MoveSplineInit init(m_owner);
+    Movement::MoveSplineInit init(_owner);
     init.MovebyPath(path);
     init.SetSmooth();
     init.SetWalk(walk);
@@ -534,10 +534,10 @@ void MotionMaster::MoveSmoothPath(uint32 pointId, Movement::PointsArray const& p
 
 void MotionMaster::MoveAlongSplineChain(uint32 pointId, uint16 dbChainId, bool walk)
 {
-    Creature* owner = m_owner->ToCreature();
+    Creature* owner = _owner->ToCreature();
     if (!owner)
     {
-        TC_LOG_ERROR("misc", "MotionMaster::MoveAlongSplineChain: non-creature %s tried to walk along DB spline chain. Ignoring.", m_owner->GetGUID().ToString().c_str());
+        TC_LOG_ERROR("misc", "MotionMaster::MoveAlongSplineChain: non-creature %s tried to walk along DB spline chain. Ignoring.", _owner->GetGUID().ToString().c_str());
         return;
     }
     SplineChain const* chain = sScriptSystemMgr->GetSplineChain(owner, dbChainId);
@@ -558,7 +558,7 @@ void MotionMaster::ResumeSplineChain(SplineChainResumeInfo const& info)
 {
     if (info.Empty())
     {
-        TC_LOG_ERROR("misc", "MotionMaster::ResumeSplineChain: unit with entry %u tried to resume a spline chain from empty info.", m_owner->GetEntry());
+        TC_LOG_ERROR("misc", "MotionMaster::ResumeSplineChain: unit with entry %u tried to resume a spline chain from empty info.", _owner->GetEntry());
         return;
     }
     Mutate(new SplineChainMovementGenerator(info), MOTION_SLOT_ACTIVE);
@@ -567,27 +567,27 @@ void MotionMaster::ResumeSplineChain(SplineChainResumeInfo const& info)
 void MotionMaster::MoveFall(uint32 id /*=0*/)
 {
     // use larger distance for vmap height search than in most other cases
-    float tz = m_owner->GetMap()->GetHeight(m_owner->GetPhaseMask(), m_owner->GetPositionX(), m_owner->GetPositionY(), m_owner->GetPositionZ(), true, MAX_FALL_DISTANCE);
+    float tz = _owner->GetMap()->GetHeight(_owner->GetPhaseMask(), _owner->GetPositionX(), _owner->GetPositionY(), _owner->GetPositionZ(), true, MAX_FALL_DISTANCE);
     if (tz <= INVALID_HEIGHT)
     {
         TC_LOG_DEBUG("misc", "MotionMaster::MoveFall: unable to retrieve a proper height at map %u (x: %f, y: %f, z: %f).",
-            m_owner->GetMap()->GetId(), m_owner->GetPositionX(), m_owner->GetPositionY(), m_owner->GetPositionZ());
+            _owner->GetMap()->GetId(), _owner->GetPositionX(), _owner->GetPositionY(), _owner->GetPositionZ());
         return;
     }
 
     // Abort too if the ground is very near
-    if (std::fabs(m_owner->GetPositionZ() - tz) < 0.1f)
+    if (std::fabs(_owner->GetPositionZ() - tz) < 0.1f)
         return;
 
-    m_owner->AddUnitMovementFlag(MOVEMENTFLAG_FALLING);
-    m_owner->m_movementInfo.SetFallTime(0);
+    _owner->AddUnitMovementFlag(MOVEMENTFLAG_FALLING);
+    _owner->m_movementInfo.SetFallTime(0);
 
     // don't run spline movement for players
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
         return;
 
-    Movement::MoveSplineInit init(m_owner);
-    init.MoveTo(m_owner->GetPositionX(), m_owner->GetPositionY(), tz, false);
+    Movement::MoveSplineInit init(_owner);
+    init.MoveTo(_owner->GetPositionX(), _owner->GetPositionY(), tz, false);
     init.SetFall();
     init.Launch();
     Mutate(new EffectMovementGenerator(id), MOTION_SLOT_CONTROLLED);
@@ -595,72 +595,72 @@ void MotionMaster::MoveFall(uint32 id /*=0*/)
 
 void MotionMaster::MoveSeekAssistance(float x, float y, float z)
 {
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
-        TC_LOG_ERROR("misc", "Player (GUID: %u) attempted to seek assistance.", m_owner->GetGUID().GetCounter());
+        TC_LOG_ERROR("misc", "Player (GUID: %u) attempted to seek assistance.", _owner->GetGUID().GetCounter());
     }
     else
     {
         TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) seek assistance (X: %f Y: %f Z: %f)",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter(), x, y, z);
-        m_owner->AttackStop();
-        m_owner->CastStop();
-        m_owner->ToCreature()->SetReactState(REACT_PASSIVE);
+            _owner->GetEntry(), _owner->GetGUID().GetCounter(), x, y, z);
+        _owner->AttackStop();
+        _owner->CastStop();
+        _owner->ToCreature()->SetReactState(REACT_PASSIVE);
         Mutate(new AssistanceMovementGenerator(x, y, z), MOTION_SLOT_ACTIVE);
     }
 }
 
 void MotionMaster::MoveSeekAssistanceDistract(uint32 time)
 {
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
-        TC_LOG_ERROR("misc", "Player (GUID: %u) attempted to call distract assistance.", m_owner->GetGUID().GetCounter());
+        TC_LOG_ERROR("misc", "Player (GUID: %u) attempted to call distract assistance.", _owner->GetGUID().GetCounter());
     }
     else
     {
         TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) is distracted after assistance call (Time: %u).",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter(), time);
+            _owner->GetEntry(), _owner->GetGUID().GetCounter(), time);
         Mutate(new AssistanceDistractMovementGenerator(time), MOTION_SLOT_ACTIVE);
     }
 }
 
 void MotionMaster::MoveTaxiFlight(uint32 path, uint32 pathnode)
 {
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
         if (path < sTaxiPathNodesByPath.size())
         {
-            TC_LOG_DEBUG("misc", "%s taxi to (Path %u node %u).", m_owner->GetName().c_str(), path, pathnode);
+            TC_LOG_DEBUG("misc", "%s taxi to (Path %u node %u).", _owner->GetName().c_str(), path, pathnode);
             FlightPathMovementGenerator* mgen = new FlightPathMovementGenerator(pathnode);
-            mgen->LoadPath(m_owner->ToPlayer());
+            mgen->LoadPath(_owner->ToPlayer());
             Mutate(mgen, MOTION_SLOT_CONTROLLED);
         }
         else
         {
             TC_LOG_ERROR("misc", "%s attempted taxi to (non-existing Path %u node %u).",
-            m_owner->GetName().c_str(), path, pathnode);
+            _owner->GetName().c_str(), path, pathnode);
         }
     }
     else
     {
         TC_LOG_ERROR("misc", "Creature (Entry: %u GUID: %u) attempted taxi to (Path %u node %u).",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter(), path, pathnode);
+            _owner->GetEntry(), _owner->GetGUID().GetCounter(), path, pathnode);
     }
 }
 
 void MotionMaster::MoveDistract(uint32 timer)
 {
-    if (m_slot[MOTION_SLOT_CONTROLLED])
+    if (_slot[MOTION_SLOT_CONTROLLED])
         return;
 
-    if (m_owner->GetTypeId() == TYPEID_PLAYER)
+    if (_owner->GetTypeId() == TYPEID_PLAYER)
     {
-        TC_LOG_DEBUG("misc", "Player (GUID: %u) distracted (timer: %u).", m_owner->GetGUID().GetCounter(), timer);
+        TC_LOG_DEBUG("misc", "Player (GUID: %u) distracted (timer: %u).", _owner->GetGUID().GetCounter(), timer);
     }
     else
     {
         TC_LOG_DEBUG("misc", "Creature (Entry: %u GUID: %u) distracted (timer: %u)",
-            m_owner->GetEntry(), m_owner->GetGUID().GetCounter(), timer);
+            _owner->GetEntry(), _owner->GetGUID().GetCounter(), timer);
     }
 
     DistractMovementGenerator* mgen = new DistractMovementGenerator(timer);
@@ -675,8 +675,8 @@ void MotionMaster::MovePath(uint32 path_id, bool repeatable)
     Mutate(new WaypointMovementGenerator<Creature>(path_id, repeatable), MOTION_SLOT_IDLE);
 
     TC_LOG_DEBUG("misc", "%s (GUID: %u) starts moving over path(Id:%u, repeatable: %s).",
-        m_owner->GetTypeId() == TYPEID_PLAYER ? "Player" : "Creature",
-        m_owner->GetGUID().GetCounter(), path_id, repeatable ? "YES" : "NO");
+        _owner->GetTypeId() == TYPEID_PLAYER ? "Player" : "Creature",
+        _owner->GetGUID().GetCounter(), path_id, repeatable ? "YES" : "NO");
 }
 
 void MotionMaster::MoveRotate(uint32 time, RotateDirection direction)
@@ -693,13 +693,13 @@ bool MotionMaster::NeedInitTop() const
 {
     if (empty())
         return false;
-    return m_initialize[m_top];
+    return _initialize[_top];
 }
 
 void MotionMaster::InitTop()
 {
-    top()->Initialize(m_owner);
-    m_initialize[m_top] = false;
+    top()->Initialize(_owner);
+    _initialize[_top] = false;
 }
 
 void MotionMaster::Pop()
@@ -707,33 +707,33 @@ void MotionMaster::Pop()
     if (empty())
         return;
 
-    m_slot[m_top] = NULL;
+    _slot[_top] = NULL;
     while (!empty() && !top())
-        --m_top;
+        --_top;
 }
 
 void MotionMaster::Mutate(MovementGenerator *m, MovementSlot slot)
 {
-    if (MovementGenerator *curr = m_slot[slot])
+    if (MovementGenerator *curr = _slot[slot])
     {
-        m_slot[slot] = NULL; // in case a new one is generated in this slot during directdelete
-        if (m_top == slot && (m_cleanFlag & MMCF_UPDATE))
+        _slot[slot] = NULL; // in case a new one is generated in this slot during directdelete
+        if (_top == slot && (_cleanFlag & MMCF_UPDATE))
             DelayedDelete(curr);
         else
             DirectDelete(curr);
     }
-    else if (m_top < slot)
+    else if (_top < slot)
     {
-        m_top = slot;
+        _top = slot;
     }
 
-    m_slot[slot] = m;
-    if (m_top > slot)
-        m_initialize[slot] = true;
+    _slot[slot] = m;
+    if (_top > slot)
+        _initialize[slot] = true;
     else
     {
-        m_initialize[slot] = false;
-        m->Initialize(m_owner);
+        _initialize[slot] = false;
+        m->Initialize(_owner);
     }
 }
 
@@ -752,7 +752,7 @@ void MotionMaster::DirectClean(bool reset)
     if (NeedInitTop())
         InitTop();
     else if (reset)
-        top()->Reset(m_owner);
+        top()->Reset(_owner);
 }
 
 void MotionMaster::DelayedClean()
@@ -776,14 +776,14 @@ void MotionMaster::DirectExpire(bool reset)
     }
 
     while (!empty() && !top())
-        --m_top;
+        --_top;
 
     if (empty())
         Initialize();
     else if (NeedInitTop())
         InitTop();
     else if (reset)
-        top()->Reset(m_owner);
+        top()->Reset(_owner);
 }
 
 void MotionMaster::DelayedExpire()
@@ -796,23 +796,23 @@ void MotionMaster::DelayedExpire()
     }
 
     while (!empty() && !top())
-        --m_top;
+        --_top;
 }
 
 void MotionMaster::DirectDelete(MovementGenerator* curr)
 {
     if (IsStatic(curr))
         return;
-    curr->Finalize(m_owner);
+    curr->Finalize(_owner);
     delete curr;
 }
 
 void MotionMaster::DelayedDelete(MovementGenerator* curr)
 {
-    TC_LOG_FATAL("misc", "Unit (Entry %u) is trying to delete its updating Movement Generator (Type %u)!", m_owner->GetEntry(), curr->GetMovementGeneratorType());
+    TC_LOG_FATAL("misc", "Unit (Entry %u) is trying to delete its updating Movement Generator (Type %u)!", _owner->GetEntry(), curr->GetMovementGeneratorType());
     if (IsStatic(curr))
         return;
-    if (!m_expireList)
-        m_expireList = new ExpireList();
-    m_expireList->push_back(curr);
+    if (!_expireList)
+        _expireList = new ExpireList();
+    _expireList->push_back(curr);
 }

src/server/game/Movement/MotionMaster.h

@@ -87,19 +87,19 @@ class TC_GAME_API MotionMaster
         typedef std::vector<MovementGenerator*> ExpireList;
 
     public:
-        explicit MotionMaster(Unit* unit) : m_expireList(nullptr), m_top(-1), m_owner(unit), m_cleanFlag(MMCF_NONE)
+        explicit MotionMaster(Unit* unit) : _expireList(nullptr), _top(-1), _owner(unit), _cleanFlag(MMCF_NONE)
         {
             for (uint8 i = 0; i < MAX_MOTION_SLOT; ++i)
             {
-                m_slot[i] = NULL;
-                m_initialize[i] = true;
+                _slot[i] = nullptr;
+                _initialize[i] = true;
             }
         }
         ~MotionMaster();
 
-        bool empty() const { return (m_top < 0); }
-        int size() const { return m_top + 1; }
-        MovementGenerator* top() const { ASSERT(!empty()); return m_slot[m_top]; }
+        bool empty() const { return (_top < 0); }
+        int size() const { return _top + 1; }
+        MovementGenerator* top() const { ASSERT(!empty()); return _slot[_top]; }
 
         void Initialize();
         void InitDefault();
@@ -179,12 +179,12 @@ class TC_GAME_API MotionMaster
         void DirectDelete(MovementGenerator* curr);
         void DelayedDelete(MovementGenerator* curr);
 
-        ExpireList* m_expireList;
-        MovementGenerator* m_slot[MAX_MOTION_SLOT];
-        int m_top;
-        Unit* m_owner;
-        bool m_initialize[MAX_MOTION_SLOT];
-        uint8 m_cleanFlag;
+        ExpireList* _expireList;
+        MovementGenerator* _slot[MAX_MOTION_SLOT];
+        int _top;
+        Unit* _owner;
+        bool _initialize[MAX_MOTION_SLOT];
+        uint8 _cleanFlag;
 };
 
 #endif // MOTIONMASTER_H