// This file is part of ClassicAPI.
//
// ClassicAPI 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 3 of the License, or (at your option) any later version.
//
// ClassicAPI 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
// ClassicAPI. If not, see .
// Turtle WoW Carnage (druid) — refresh Rip/Rake off Ferocious Bite.
//
// Carnage gives Ferocious Bite a chance to refresh the caster's Rip and Rake
// and to grant one combo point back. The chance scales with the combo points
// the Bite spent (verified in tortoise-wow spell_druid_carnage: chance =
// base * 2 * comboPoints), so only max rank at five points is near-certain.
// The refresh emits no packet and the proc applies no aura, so no trigger rule
// (`C_UnitAuras.RegisterAuraDurationModifier*`) can express it. But the granted
// point is observable: Ferocious Bite spends every point, so the first
// combo-point rise after a Bite is the proc landing. Server-side the refresh is
// caster-scoped and matched by family flags + SpellIconID (108 Rip / 494 Rake),
// and applies RefreshHolder (restore the aura's own applied duration) -- which
// is exactly what Aura::Source::RefreshDurationByFamily mirrors.
//
// The idea and the confirm-on-the-returned-point approach come from fuffc's
// PR #15; this is the C++ form. The refresh itself is
// `Aura::Source::RefreshDurationByFamily`, which restores each aura's own
// applied duration (a Rip cast at 3 combo points keeps its 3-point length) and
// re-broadcasts UNIT_AURA so aura-bar addons re-read.
//
// Gated on `Turtle::Detected()`: Carnage is Turtle-only, and the gate also
// keeps the heuristic off servers without it. Residual: if Turtle grants combo
// points off-GCD by another path (e.g. a Primal-Fury-style melee-crit talent),
// such a point inside the window can false-fire. The GCD the Bite starts
// excludes ability-based generation; an off-GCD proc is the one uncovered case.
#include "aura/Source.h"
#include "turtle/Detect.h"
#include "Offsets.h"
#include "net/PacketReader.h"
#include "net/SendObserver.h"
#include "spell/Lookup.h"
#include "tick/WorldTick.h"
#include "time/Clock.h"
#include "unit/Identity.h"
#include
namespace Turtle::Carnage {
namespace {
constexpr uint32_t kDruidFamily = 7;
constexpr uint64_t kRipFlag = 0x800000;
constexpr uint32_t kRipIcon = 108;
constexpr uint64_t kRakeFlag = 0x1000;
constexpr uint32_t kRakeIcon = 494;
// Ferocious Bite, identified structurally the way the server's
// IsDruidFerociousBite (spell_druid.cpp) does: druid family + the Rip/Bite
// family flag + a direct-damage effect. The damage effect is what separates
// Bite from Rip, its DoT sibling that shares the flag (Rip's effect is
// APPLY_AURA, not SCHOOL_DAMAGE). Rank-proof -- covers every rank and any
// Turtle-added one with no ID list. Verified against the client Spell.dbc:
// all five FB ranks are {family 7, flag 0x800000, Effect[0] 2}; Rip shares the
// flag but has no damage effect, and Rake carries a different flag.
bool IsFerociousBite(uint32_t spellId) {
const uint8_t *rec = Spell::Lookup::RecordForID(static_cast(spellId));
if (!Spell::Lookup::IsFitToFamily(rec, kDruidFamily, kRipFlag))
return false;
// The direct-damage effect separates Bite from Rip, its DoT sibling that
// shares the flag (Rip's effect is APPLY_AURA, not SCHOOL_DAMAGE).
const auto *effects = reinterpret_cast(
rec + Offsets::OFF_SPELL_RECORD_EFFECT);
for (int i = 0; i < Offsets::SPELL_RECORD_EFFECT_COUNT; ++i)
if (effects[i] == Offsets::SPELL_EFFECT_SCHOOL_DAMAGE)
return true;
return false;
}
// Long enough to absorb latency, short enough that the GCD the Bite just
// started rules out an ability as the source of the combo point.
constexpr uint32_t kWindowMs = 500;
uint64_t g_target = 0; // unit the armed Bite's combo points / DoTs belong to
uint32_t g_untilMs = 0; // window expiry
uint8_t g_lastCp = 0; // last combo-point value seen since arming
using Time::Clock::NowMs;
// The CGPlayer +0xE68 sub-struct that holds combo points + combo target
// (Script_GetComboPoints, 0x0051A190). Null pre-world.
const uint8_t *ComboInfo() {
const uint8_t *player = Unit::Identity::PlayerObject();
if (player == nullptr)
return nullptr;
return *reinterpret_cast(
player + Offsets::OFF_CGPLAYER_INFO);
}
// Arm on a Ferocious Bite send. The combo-target GUID is where the points live
// and where Rip/Rake sit — the authoritative unit this finisher applies to, so
// it survives a target swap in the window.
void OnSend(uint32_t opcode, Net::CDataStore *packet) {
if (opcode != Offsets::OP_CMSG_CAST_SPELL || !Turtle::Detected())
return;
if (!IsFerociousBite(Net::Read(packet)))
return;
const uint8_t *info = ComboInfo();
if (info == nullptr)
return;
g_target = *reinterpret_cast(
info + Offsets::OFF_CGPLAYER_COMBO_TARGET);
g_lastCp = *(info + Offsets::OFF_CGPLAYER_COMBO_POINTS); // pre-spend
g_untilMs = NowMs() + kWindowMs;
}
// Confirm on the first combo-point CHANGE after the Bite (the tick poll stands
// in for PLAYER_COMBO_POINTS). The Bite spent every point, so a change to >0 is
// the Carnage refund; a change to 0 is the spend — stay armed for the refund
// (covers a split 5->0->1; the coalesced 5->1 fires on the single change).
void OnTick() {
if (g_target == 0)
return;
if (Time::Clock::Reached(g_untilMs)) {
g_target = 0;
return;
}
const uint8_t *info = ComboInfo();
if (info == nullptr)
return;
const uint8_t cp = *(info + Offsets::OFF_CGPLAYER_COMBO_POINTS);
if (cp == g_lastCp)
return; // no change yet
g_lastCp = cp;
if (cp > 0) {
const uint64_t self = Unit::Identity::PlayerGuid();
Aura::Source::RefreshDurationByFamily(g_target, kDruidFamily, kRipFlag,
kRipIcon, self);
Aura::Source::RefreshDurationByFamily(g_target, kDruidFamily, kRakeFlag,
kRakeIcon, self);
g_target = 0;
}
}
const Net::SendObserver::AutoSubscribe _sendSub{&OnSend};
const Tick::WorldTick::AutoSubscribe _tickSub{&OnTick};
} // namespace
} // namespace Turtle::Carnage