Core/Instances: Updated and enabled encounter packets and implemented combat resurrection limit

Closes #16966

1 files changed, 122 insertions, 18 deletions

diff --git a/src/server/game/Instances/InstanceScript.cpp b/src/server/game/Instances/InstanceScript.cpp
index b4c56c32394..2969d5666ac 100644
--- a/src/server/game/Instances/InstanceScript.cpp
+++ b/src/server/game/Instances/InstanceScript.cpp
@@ -22,6 +22,7 @@
 #include "GameObject.h"
 #include "Group.h"
 #include "InstanceScript.h"
+#include "InstancePackets.h"
 #include "LFGMgr.h"
 #include "Log.h"
 #include "Map.h"
@@ -38,7 +39,8 @@ BossBoundaryData::~BossBoundaryData()
         delete it->Boundary;
 }
 
-InstanceScript::InstanceScript(Map* map) : instance(map), completedEncounters(0)
+InstanceScript::InstanceScript(Map* map) : instance(map), completedEncounters(0),
+_combatResurrectionTimer(0), _combatResurrectionCharges(0), _combatResurrectionTimerStarted(false)
 {
 #ifdef TRINITY_API_USE_DYNAMIC_LINKING
     uint32 scriptId = sObjectMgr->GetInstanceTemplate(map->GetId())->ScriptId;
@@ -306,6 +308,24 @@ bool InstanceScript::SetBossState(uint32 id, EncounterState state)
                         if (minion->isWorldBoss() && minion->IsAlive())
                             return false;
 
+            switch (state)
+            {
+                case IN_PROGRESS:
+                {
+                    uint32 resInterval = GetCombatResurrectionChargeInterval();
+                    InitializeCombatResurrections(1, resInterval);
+                    SendEncounterStart(1, 9, resInterval, resInterval);
+                    break;
+                }
+                case FAIL:
+                case DONE:
+                    ResetCombatResurrections();
+                    SendEncounterEnd();
+                    break;
+                default:
+                    break;
+            }
+
             bossInfo->state = state;
             SaveToDB();
         }
@@ -586,36 +606,62 @@ bool InstanceScript::CheckAchievementCriteriaMeet(uint32 criteria_id, Player con
     return false;
 }
 
-void InstanceScript::SendEncounterUnit(uint32 type, Unit* unit /*= NULL*/, uint8 param1 /*= 0*/, uint8 param2 /*= 0*/)
+void InstanceScript::SendEncounterUnit(uint32 type, Unit* unit /*= NULL*/, uint8 priority)
 {
-    // size of this packet is at most 15 (usually less)
-    WorldPacket data(SMSG_INSTANCE_ENCOUNTER_ENGAGE_UNIT, 15);
-    data << uint32(type);
-
     switch (type)
     {
         case ENCOUNTER_FRAME_ENGAGE:                    // SMSG_INSTANCE_ENCOUNTER_ENGAGE_UNIT
-        case ENCOUNTER_FRAME_DISENGAGE:                 // SMSG_INSTANCE_ENCOUNTER_DISENGAGE_UNIT
-        case ENCOUNTER_FRAME_UPDATE_PRIORITY:           // SMSG_INSTANCE_ENCOUNTER_CHANGE_PRIORITY
+        {
             if (!unit)
                 return;
-            data << unit->GetPackGUID();
-            data << uint8(param1);
+
+            WorldPackets::Instance::InstanceEncounterEngageUnit encounterEngageMessage;
+            encounterEngageMessage.Unit = unit->GetGUID();
+            encounterEngageMessage.TargetFramePriority = priority;
+            instance->SendToPlayers(encounterEngageMessage.Write());
             break;
-        case ENCOUNTER_FRAME_ADD_TIMER:                 // SMSG_INSTANCE_ENCOUNTER_TIMER_START
-        case ENCOUNTER_FRAME_ENABLE_OBJECTIVE:          // SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_START
-        case ENCOUNTER_FRAME_DISABLE_OBJECTIVE:         // SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_COMPLETE
-            data << uint8(param1);
+        }
+        case ENCOUNTER_FRAME_DISENGAGE:                 // SMSG_INSTANCE_ENCOUNTER_DISENGAGE_UNIT
+        {
+            if (!unit)
+                return;
+
+            WorldPackets::Instance::InstanceEncounterDisengageUnit encounterDisengageMessage;
+            encounterDisengageMessage.Unit = unit->GetGUID();
+            instance->SendToPlayers(encounterDisengageMessage.Write());
             break;
-        case ENCOUNTER_FRAME_UPDATE_OBJECTIVE:          // SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_UPDATE
-            data << uint8(param1);
-            data << uint8(param2);
+        }
+        case ENCOUNTER_FRAME_UPDATE_PRIORITY:           // SMSG_INSTANCE_ENCOUNTER_CHANGE_PRIORITY
+        {
+            if (!unit)
+                return;
+
+            WorldPackets::Instance::InstanceEncounterChangePriority encounterChangePriorityMessage;
+            encounterChangePriorityMessage.Unit = unit->GetGUID();
+            encounterChangePriorityMessage.TargetFramePriority = priority;
+            instance->SendToPlayers(encounterChangePriorityMessage.Write());
             break;
+        }
         default:
             break;
     }
+}
+
+void InstanceScript::SendEncounterStart(uint32 inCombatResCount /*= 0*/, uint32 maxInCombatResCount /*= 0*/, uint32 inCombatResChargeRecovery /*= 0*/, uint32 nextCombatResChargeTime /*= 0*/)
+{
+    WorldPackets::Instance::InstanceEncounterStart encounterStartMessage;
+    encounterStartMessage.InCombatResCount = inCombatResCount;
+    encounterStartMessage.MaxInCombatResCount = maxInCombatResCount;
+    encounterStartMessage.CombatResChargeRecovery = inCombatResChargeRecovery;
+    encounterStartMessage.NextCombatResChargeTime = nextCombatResChargeTime;
 
-    instance->SendToPlayers(&data);
+    instance->SendToPlayers(encounterStartMessage.Write());
+}
+
+void InstanceScript::SendEncounterEnd()
+{
+    WorldPackets::Instance::InstanceEncounterEnd encounterEndMessage;
+    instance->SendToPlayers(encounterEndMessage.Write());
 }
 
 void InstanceScript::UpdateEncounterState(EncounterCreditType type, uint32 creditEntry, Unit* /*source*/)
@@ -686,3 +732,61 @@ std::string InstanceScript::GetBossStateName(uint8 state)
             return "INVALID";
     }
 }
+
+void InstanceScript::UpdateCombatResurrection(uint32 diff)
+{
+    if (!_combatResurrectionTimerStarted)
+        return;
+
+    _combatResurrectionTimer -= diff;
+    if (_combatResurrectionTimer <= 0)
+    {
+        AddCombatResurrectionCharge();
+        _combatResurrectionTimerStarted = false;
+    }
+}
+
+void InstanceScript::InitializeCombatResurrections(uint8 charges /*= 1*/, uint32 interval /*= 0*/)
+{
+    _combatResurrectionCharges = charges;
+    if (!interval)
+        return;
+
+    _combatResurrectionTimer = interval;
+    _combatResurrectionTimerStarted = true;
+}
+
+void InstanceScript::AddCombatResurrectionCharge()
+{
+    ++_combatResurrectionCharges;
+    _combatResurrectionTimer = GetCombatResurrectionChargeInterval();
+    _combatResurrectionTimerStarted = true;
+
+    WorldPackets::Instance::InstanceEncounterGainCombatResurrectionCharge gainCombatResurrectionCharge;
+    gainCombatResurrectionCharge.InCombatResCount = _combatResurrectionCharges;
+    gainCombatResurrectionCharge.CombatResChargeRecovery = _combatResurrectionTimer;
+    instance->SendToPlayers(gainCombatResurrectionCharge.Write());
+}
+
+void InstanceScript::UseCombatResurrection()
+{
+    --_combatResurrectionCharges;
+
+    instance->SendToPlayers(WorldPackets::Instance::InstanceEncounterInCombatResurrection().Write());
+}
+
+void InstanceScript::ResetCombatResurrections()
+{
+    _combatResurrectionCharges = 0;
+    _combatResurrectionTimer = 0;
+    _combatResurrectionTimerStarted = 0;
+}
+
+uint32 InstanceScript::GetCombatResurrectionChargeInterval() const
+{
+    uint32 interval = 0;
+    if (uint32 playerCount = instance->GetPlayers().getSize())
+        interval = 90 * MINUTE * IN_MILLISECONDS / playerCount;
+
+    return interval;
+}