Core/Auras: Implement gravity opcodes and SPELL_AURA_MOD_GRAVITY (#31997)

src/server/game/Entities/Object/BaseEntity.cpp

@@ -290,7 +290,7 @@ void BaseEntity::BuildMovementUpdate(ByteBuffer& data, CreateObjectBits flags, P
         data << uint32(0);                                             // RemoveForcesIDs.size()
         data << uint32(0);                                             // MoveIndex
 
-        data << float(unit->m_movementInfo.gravityModifier);
+        data << float(unit->m_movementInfo.gravityModifier);           // GravityModifier
 
         //for (std::size_t i = 0; i < RemoveForcesIDs.size(); ++i)
         //    data << ObjectGuid(RemoveForcesIDs);

src/server/game/Entities/Unit/Unit.cpp

@@ -15038,6 +15038,25 @@ void Unit::UpdateMovementForcesModMagnitude()
     }
 }
 
+void Unit::SetGravityModifier(float gravityModifier)
+{
+    if (Player const* movingPlayer = GetPlayerMovingMe())
+    {
+        WorldPackets::Movement::MoveSetGravityModifier setGravityModifier;
+        setGravityModifier.MoverGUID = GetGUID();
+        setGravityModifier.SequenceIndex = m_movementCounter++;
+        setGravityModifier.GravityModifier = gravityModifier;
+        movingPlayer->SendDirectMessage(setGravityModifier.Write());
+    }
+    else
+    {
+        WorldPackets::Movement::MoveUpdateSetGravityModifier updateSetGravityModifier;
+        updateSetGravityModifier.Status = &m_movementInfo;
+        updateSetGravityModifier.GravityModifier = gravityModifier;
+        SendMessageToSet(updateSetGravityModifier.Write(), true);
+    }
+}
+
 void Unit::SetPlayHoverAnim(bool enable, bool sendUpdate /*= true*/)
 {
     if (IsPlayingHoverAnim() == enable)

src/server/game/Entities/Unit/Unit.h

@@ -1206,6 +1206,8 @@ class TC_GAME_API Unit : public WorldObject
         void ApplyInertia(int32 id, Milliseconds duration);
         void RemoveInertia(int32 id);
 
+        void SetGravityModifier(float gravityModifier);
+
         void SetInFront(WorldObject const* target);
         void SetFacingTo(float ori, bool force = true, uint32 movementId = EVENT_FACE);
         void SetFacingToObject(WorldObject const* object, bool force = true, uint32 movementId = EVENT_FACE);

src/server/game/Handlers/MovementHandler.cpp

@@ -1066,3 +1066,22 @@ void WorldSession::HandleDiscardedTimeSyncAcks(WorldPackets::Movement::Discarded
 
     player->m_movementCounter = 0;
 }
+
+void WorldSession::HandleMoveForceGravityModifierChangeAck(WorldPackets::Movement::MoveForceGravityModifierChangeAck& moveForceGravityModifierChangeAck)
+{
+    Unit* mover = ValidateAndGetUnitBeingMoved(moveForceGravityModifierChangeAck.Ack.Status.guid, moveForceGravityModifierChangeAck.GetOpcode(), true);
+    if (!mover)
+        return;
+
+    if (!ValidateMovementInfo(mover, &moveForceGravityModifierChangeAck.Ack.Status))
+        return;
+
+    moveForceGravityModifierChangeAck.Ack.Status.time = AdjustClientMovementTime(moveForceGravityModifierChangeAck.Ack.Status.time);
+    mover->m_movementInfo = moveForceGravityModifierChangeAck.Ack.Status;
+    mover->m_movementInfo.gravityModifier = moveForceGravityModifierChangeAck.Ack.Status.gravityModifier;
+
+    WorldPackets::Movement::MoveUpdateSetGravityModifier updateSetGravityModifier;
+    updateSetGravityModifier.Status = &mover->m_movementInfo;
+    updateSetGravityModifier.GravityModifier = moveForceGravityModifierChangeAck.GravityModifier;
+    mover->SendMessageToSet(updateSetGravityModifier.Write(), false);
+}

src/server/game/Server/Packets/MovementPackets.cpp

@@ -1263,4 +1263,27 @@ WorldPacket const* MoveInitialObjectUpdateComplete::Write()
     _worldPacket << uint32(SequenceIndex);
     return &_worldPacket;
 }
+
+void MoveForceGravityModifierChangeAck::Read()
+{
+    _worldPacket >> Ack;
+    _worldPacket >> GravityModifier;
+}
+
+WorldPacket const* MoveSetGravityModifier::Write()
+{
+    _worldPacket << MoverGUID;
+    _worldPacket << uint32(SequenceIndex);
+    _worldPacket << float(GravityModifier);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* MoveUpdateSetGravityModifier::Write()
+{
+    _worldPacket << *Status;
+    _worldPacket << float(GravityModifier);
+
+    return &_worldPacket;
+}
 }

src/server/game/Server/Packets/MovementPackets.h

@@ -862,6 +862,40 @@ namespace WorldPackets
             uint32 SequenceIndex = 0;
         };
 
+        class MoveForceGravityModifierChangeAck final : public ClientPacket
+        {
+        public:
+            explicit MoveForceGravityModifierChangeAck(WorldPacket&& packet) : ClientPacket(CMSG_MOVE_FORCE_GRAVITY_MODIFIER_CHANGE_ACK, std::move(packet)) {}
+
+            void Read() override;
+
+            MovementAck Ack;
+            float GravityModifier = 1.0f;
+        };
+
+        class MoveSetGravityModifier final : public ServerPacket
+        {
+        public:
+            explicit MoveSetGravityModifier() : ServerPacket(SMSG_MOVE_SET_GRAVITY_MODIFIER, 16 + 4 + 4) {}
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid MoverGUID;
+            uint32 SequenceIndex = 0;
+            float GravityModifier = 1.0f;
+        };
+
+        class MoveUpdateSetGravityModifier final : public ServerPacket
+        {
+        public:
+            explicit MoveUpdateSetGravityModifier() : ServerPacket(SMSG_MOVE_UPDATE_SET_GRAVITY_MODIFIER, sizeof(MovementInfo) + 4) {}
+
+            WorldPacket const* Write() override;
+
+            MovementInfo* Status = nullptr;
+            float GravityModifier = 1.0f;
+        };
+
         ByteBuffer& operator>>(ByteBuffer& data, MovementAck& ack);
     }
 }

src/server/game/Server/Protocol/Opcodes.cpp

@@ -729,7 +729,7 @@ void OpcodeTable::InitializeClientOpcodes()
     DEFINE_HANDLER(CMSG_MOVE_FEATHER_FALL_ACK, STATUS_LOGGEDIN, PROCESS_THREADSAFE, &WorldSession::HandleMovementAckMessage);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_FLIGHT_BACK_SPEED_CHANGE_ACK, STATUS_LOGGEDIN, PROCESS_THREADSAFE, &WorldSession::HandleForceSpeedChangeAck);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_FLIGHT_SPEED_CHANGE_ACK, STATUS_LOGGEDIN, PROCESS_THREADSAFE, &WorldSession::HandleForceSpeedChangeAck);
-    DEFINE_HANDLER(CMSG_MOVE_FORCE_GRAVITY_MODIFIER_CHANGE_ACK, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_MOVE_FORCE_GRAVITY_MODIFIER_CHANGE_ACK, STATUS_LOGGEDIN, PROCESS_THREADSAFE, &WorldSession::HandleMoveForceGravityModifierChangeAck);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_PITCH_RATE_CHANGE_ACK, STATUS_LOGGEDIN, PROCESS_THREADSAFE, &WorldSession::HandleForceSpeedChangeAck);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_ROOT_ACK, STATUS_LOGGEDIN, PROCESS_THREADSAFE, &WorldSession::HandleMovementAckMessage);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_RUN_BACK_SPEED_CHANGE_ACK, STATUS_LOGGEDIN, PROCESS_THREADSAFE, &WorldSession::HandleForceSpeedChangeAck);
@@ -2014,7 +2014,7 @@ void OpcodeTable::InitializeServerOpcodes()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_FEATHER_FALL, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_FLIGHT_BACK_SPEED, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_FLIGHT_SPEED, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_GRAVITY_MODIFIER, STATUS_UNHANDLED, CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_GRAVITY_MODIFIER, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_HOVERING, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_IGNORE_MOVEMENT_FORCES, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_LAND_WALK, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
@@ -2081,7 +2081,7 @@ void OpcodeTable::InitializeServerOpcodes()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_REMOVE_MOVEMENT_FORCE, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_RUN_BACK_SPEED, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_RUN_SPEED, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_SET_GRAVITY_MODIFIER, STATUS_UNHANDLED, CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_SET_GRAVITY_MODIFIER, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_SWIM_BACK_SPEED, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_SWIM_SPEED, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_TELEPORT, STATUS_NEVER, CONNECTION_TYPE_INSTANCE);

src/server/game/Server/WorldSession.cpp

@@ -1678,6 +1678,7 @@ uint32 WorldSession::DosProtection::GetMaxPacketCounterAllowed(uint32 opcode) co
     case CMSG_MOVE_FORCE_WALK_SPEED_CHANGE_ACK:     // not profiled
     case CMSG_MOVE_FORCE_TURN_RATE_CHANGE_ACK:      // not profiled
     case CMSG_MOVE_FORCE_PITCH_RATE_CHANGE_ACK:     // not profiled
+    case CMSG_MOVE_FORCE_GRAVITY_MODIFIER_CHANGE_ACK:// not profiled
     {
         // "0" is a magic number meaning there's no limit for the opcode.
         // All the opcodes above must cause little CPU usage and no sync/async database queries at all

src/server/game/Server/WorldSession.h

@@ -902,6 +902,7 @@ namespace WorldPackets
         class MoveInitActiveMoverComplete;
         class MoveApplyInertiaAck;
         class MoveRemoveInertiaAck;
+        class MoveForceGravityModifierChangeAck;
         class DiscardedTimeSyncAcks;
     }
 
@@ -1740,6 +1741,7 @@ public:
         void HandleMoveApplyInertiaAck(WorldPackets::Movement::MoveApplyInertiaAck& moveApplyInertiaAck);
         void HandleMoveRemoveInertiaAck(WorldPackets::Movement::MoveRemoveInertiaAck& moveRemoveInertiaAck);
         void HandleDiscardedTimeSyncAcks(WorldPackets::Movement::DiscardedTimeSyncAcks& packet);
+        void HandleMoveForceGravityModifierChangeAck(WorldPackets::Movement::MoveForceGravityModifierChangeAck& moveForceGravityModifierChangeAck);
 
         void HandleRepopRequest(WorldPackets::Misc::RepopRequest& packet);
         void HandleAutostoreLootItemOpcode(WorldPackets::Loot::LootItem& packet);

src/server/game/Spells/Auras/SpellAuraEffects.cpp

@@ -713,7 +713,7 @@ NonDefaultConstructible<pAuraEffectHandler> AuraEffectHandler[TOTAL_AURAS]=
     &AuraEffect::HandleNULL,                                      //641
     &AuraEffect::HandleNULL,                                      //642
     &AuraEffect::HandleNULL,                                      //643 SPELL_AURA_MOD_RANGED_ATTACK_SPEED_FLAT
-    &AuraEffect::HandleNULL,                                      //644 SPELL_AURA_MOD_GRAVITY
+    &AuraEffect::HandleModGravity,                                //644 SPELL_AURA_MOD_GRAVITY
     &AuraEffect::HandleNULL,                                      //645
     &AuraEffect::HandleNULL,                                      //646 SPELL_AURA_ADD_FLAT_PVP_MODIFIER
     &AuraEffect::HandleNULL,                                      //647 SPELL_AURA_ADD_PCT_PVP_MODIFIER
@@ -6480,6 +6480,19 @@ void AuraEffect::HandleEnablePowerBarTimer(AuraApplication const* aurApp, uint8
         aurApp->GetTarget()->SetMaxPower(POWER_ALTERNATE_POWER, 0);
 }
 
+void AuraEffect::HandleModGravity(AuraApplication const* aurApp, uint8 mode, bool /*apply*/) const
+{
+    if (!(mode & AURA_EFFECT_HANDLE_REAL))
+        return;
+
+    Unit* target = aurApp->GetTarget();
+    Unit::AuraEffectList const& gravityAuras = target->GetAuraEffectsByType(SPELL_AURA_MOD_GRAVITY);
+    float amount = std::transform_reduce(gravityAuras.begin(), gravityAuras.end(), 1.0f, std::multiplies(),
+        [](AuraEffect const* aurEff) { return aurEff->GetAmount(); });
+
+    target->SetGravityModifier(std::max(amount, 0.01f));
+}
+
 void AuraEffect::HandleModSpellCategoryCooldown(AuraApplication const* aurApp, uint8 mode, bool apply) const
 {
     if (!(mode & AURA_EFFECT_HANDLE_REAL))

src/server/game/Spells/Auras/SpellAuraEffects.h

@@ -335,6 +335,7 @@ class TC_GAME_API AuraEffect
         void HandleMastery(AuraApplication const* aurApp, uint8 mode, bool apply) const;
         void HandleAuraForceWeather(AuraApplication const* aurApp, uint8 mode, bool apply) const;
         void HandleEnableAltPower(AuraApplication const* aurApp, uint8 mode, bool apply) const;
+        void HandleModGravity(AuraApplication const* aurApp, uint8 mode, bool apply) const;
         void HandleEnablePowerBarTimer(AuraApplication const* aurApp, uint8 mode, bool apply) const;
         void HandleModSpellCategoryCooldown(AuraApplication const* aurApp, uint8 mode, bool apply) const;
         void HandleModRecoveryRate(AuraApplication const* aurApp, uint8 mode, bool apply) const;