Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-29 13:22:48 +01:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
Closes #16966
This commit is contained in:
Ovalord
2016-04-14 22:43:21 +02:00
committed by Shauren
parent bc106abb07
commit 948146f3ee
8 changed files with 287 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
src/server/game/Instances/InstanceScript.cpp
View File

@@ -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;
}
}
instance->SendToPlayers(&data);
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(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;
}