From fd2be1816191a372d1f8d8d6e09f17c061b2a58e Mon Sep 17 00:00:00 2001 From: Aaron Kimbrell Date: Tue, 29 Sep 2026 03:28:14 -0500 Subject: [PATCH] feat(skills): save running skill cooldown groups (charxml ) The client reads the cooldowns still running from the charxml on load (LWOSkillComponent::LoadFromSaveData 0x00c2a9c0): split on ';' and ':' (the delimiter string at 0x015b1714 is L";:") into a cooldown group and the seconds left, each put in its cooldown map under {hasCooldownGroup = 1, group}, the key it checks when the player casts a skill of that group (0x00c11400). Live wrote with nothing running and e.g. otherwise (226 live charxmls; groups 8, 17 and 78 seen, the times below the groups' SkillBehavior cooldowns). The claude-client-re-docs page described sc as "id;time" pairs; the live saves and the delimiters show "group:time;". DLU wrote no , so relogging or changing zones cleared every cooldown (e.g. the 90 s imagination and faction skills). - A player's successful cast (CastPlayerSkill) starts its SkillBehavior.cooldowngroup's cooldown (groups 0 and up, cooldown > 0), counted down in Update. - Saved as live wrote it; loaded back when the player's SkillComponent is created, so a cooldown survives several zone changes. Old saves without load with none running. Check in game: use a skill with a long cooldown (e.g. a faction kit's special skill, a consumable with a cooldown), change zones or log out and back in right away: its cooldown is still shown and counts down from where it was (minus the loading time on the server). Co-Authored-By: Claude Opus 5.5 --- dGame/Entity.cpp | 3 +- dGame/dComponents/SkillComponent.cpp | 49 +++++++++++++++++ dGame/dComponents/SkillComponent.h | 24 +++++++++ .../CharacterSaveFieldsTests.cpp | 54 +++++++++++++++++++ 4 files changed, 129 insertions(+), 1 deletion(-) diff --git a/dGame/Entity.cpp b/dGame/Entity.cpp index 594017cc2..4a6fc118b 100644 --- a/dGame/Entity.cpp +++ b/dGame/Entity.cpp @@ -595,7 +595,8 @@ void Entity::Initialize() { const auto skillID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SKILL, -1); if (skillID > -1 || m_Character) { - AddComponent(skillID); + auto* const skillComponent = AddComponent(skillID); + if (m_Character) skillComponent->LoadFromXml(m_Character->GetXMLDoc()); } const auto combatAiID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BASE_COMBAT_AI); diff --git a/dGame/dComponents/SkillComponent.cpp b/dGame/dComponents/SkillComponent.cpp index a39ecc188..8bde4265d 100644 --- a/dGame/dComponents/SkillComponent.cpp +++ b/dGame/dComponents/SkillComponent.cpp @@ -4,6 +4,8 @@ */ #include "SkillComponent.h" +#include "GeneralUtils.h" +#include "tinyxml2.h" #include #include @@ -47,9 +49,51 @@ bool SkillComponent::CastPlayerSkill(const uint32_t behaviorId, const uint32_t s context->ExecuteUpdates(); + if (!context->failed && m_Parent->IsPlayer()) StartCooldown(skillID); + return !context->failed; } +void SkillComponent::StartCooldown(const uint32_t skillID) { + const auto& skill = CDClientManager::GetTable()->GetSkillByID(skillID); + // The client keys cooldown groups 0 and up (a null group is -1); skills without a cooldown have none running + const auto group = static_cast(skill.cooldowngroup); + if (group < 0 || skill.cooldown <= 0.0f) return; + auto& left = m_CooldownGroups[group]; + left = std::max(left, skill.cooldown); +} + +void SkillComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) { + m_CooldownGroups.clear(); + const auto* const obj = doc.FirstChildElement("obj"); + const auto* const skil = obj ? obj->FirstChildElement("skil") : nullptr; + const char* const cooldowns = skil ? skil->Attribute("sc") : nullptr; + if (!cooldowns) return; + + // Alternating group and seconds, split on ';' and ':' as the client does + const auto tokens = GeneralUtils::SplitString(std::string(cooldowns), ';'); + for (const auto& entry : tokens) { + const auto pair = GeneralUtils::SplitString(entry, ':'); + if (pair.size() != 2) continue; + const auto group = GeneralUtils::TryParse(pair[0]); + const auto left = GeneralUtils::TryParse(pair[1]); + if (group && left && *left > 0.0f) m_CooldownGroups[*group] = *left; + } +} + +void SkillComponent::UpdateXml(tinyxml2::XMLDocument& doc) { + auto* const obj = doc.FirstChildElement("obj"); + if (!obj) return; + auto* skil = obj->FirstChildElement("skil"); + if (!skil) skil = obj->InsertNewChildElement("skil"); + + // Live: with nothing running, else e.g. + std::ostringstream cooldowns; + for (const auto& [group, left] : m_CooldownGroups) cooldowns << group << ':' << left << ';'; + if (cooldowns.view().empty()) skil->DeleteAttribute("sc"); + else skil->SetAttribute("sc", cooldowns.str().c_str()); +} + void SkillComponent::SyncPlayerSkill(const uint32_t skillUid, const uint32_t syncId, RakNet::BitStream& bitStream) { const auto index = this->m_managedBehaviors.equal_range(skillUid); @@ -141,6 +185,11 @@ void SkillComponent::RegisterPlayerProjectile(const LWOOBJID projectileId, Behav } void SkillComponent::Update(const float deltaTime) { + for (auto it = m_CooldownGroups.begin(); it != m_CooldownGroups.end();) { + it->second -= deltaTime; + it = it->second <= 0.0f ? m_CooldownGroups.erase(it) : std::next(it); + } + if (!m_Parent->HasComponent(eReplicaComponentType::BASE_COMBAT_AI) && m_Parent->GetLOT() != 1) { CalculateUpdate(deltaTime); } diff --git a/dGame/dComponents/SkillComponent.h b/dGame/dComponents/SkillComponent.h index 2fbf95952..27f836540 100644 --- a/dGame/dComponents/SkillComponent.h +++ b/dGame/dComponents/SkillComponent.h @@ -73,6 +73,27 @@ public: */ void Update(float deltaTime) override; + /** + * Loads the cooldown groups still running at the last save: + */ + void LoadFromXml(const tinyxml2::XMLDocument& doc) override; + + /** + * Saves the running cooldown groups the way live did and the client reads them (LWOSkillComponent::LoadFromSaveData + * 0x00c2a9c0 splits sc on ';' and ':' into a cooldown group and the seconds left) + */ + void UpdateXml(tinyxml2::XMLDocument& doc) override; + + /** + * Starts the cooldown of a skill's cooldown group (SkillBehavior.cooldowngroup, cooldown) when the player casts it + */ + void StartCooldown(uint32_t skillID); + + /** + * The cooldown groups running and the seconds left on each + */ + const std::map& GetCooldownGroups() const { return m_CooldownGroups; } + /** * Computes server-side skill updates. */ @@ -223,6 +244,9 @@ private: */ uint32_t m_skillUid; + // Cooldown group -> seconds left, for the player's save + std::map m_CooldownGroups; + /** * Cache for looking up a behavior id via a skill ID */ diff --git a/tests/dGameTests/dComponentsTests/CharacterSaveFieldsTests.cpp b/tests/dGameTests/dComponentsTests/CharacterSaveFieldsTests.cpp index b62a63b94..9feb23612 100644 --- a/tests/dGameTests/dComponentsTests/CharacterSaveFieldsTests.cpp +++ b/tests/dGameTests/dComponentsTests/CharacterSaveFieldsTests.cpp @@ -8,6 +8,9 @@ #include "Entity.h" #include "GameMessages.h" #include "MissionComponent.h" +#include "SkillComponent.h" +#include "CDSkillBehaviorTable.h" +#include "CDClientManager.h" #include "eMissionLockState.h" #include "tinyxml2.h" @@ -109,3 +112,54 @@ TEST_F(CharacterSaveFieldsTests, TooltipFlagsMissingInOldSave) { characterComponent->UpdateXml(doc); EXPECT_STREQ(doc.FirstChildElement("obj")->FirstChildElement("char")->Attribute("ttip"), "0"); } + +// : the cooldown groups still running and the seconds left, as live wrote them (sc="17:15.6958;") and the +// client reads them (split on ';' and ':'). +TEST_F(CharacterSaveFieldsTests, SkillCooldownsRoundTrip) { + CDSkillBehavior skill{}; + skill.skillID = 394; + skill.cooldowngroup = 17; + skill.cooldown = 30.0f; + CDClientManager::GetEntriesMutable()[394] = skill; + CDSkillBehavior ungrouped{}; + ungrouped.skillID = 395; + ungrouped.cooldowngroup = static_cast(-1); + ungrouped.cooldown = 30.0f; + CDClientManager::GetEntriesMutable()[395] = ungrouped; + + tinyxml2::XMLDocument doc; + Parse(doc, R"()"); + + Entity player(26, info); + auto* const skills = player.AddComponent(-1); + skills->LoadFromXml(doc); + ASSERT_EQ(skills->GetCooldownGroups().size(), 2u); + EXPECT_FLOAT_EQ(skills->GetCooldownGroups().at(8), 26.6559f); + + skills->Update(26.7f); // group 8 runs out + skills->StartCooldown(394); + skills->StartCooldown(395); // no group: not saved + skills->UpdateXml(doc); + EXPECT_EQ(Print(doc), R"()"); + + Entity reloaded(27, info); + auto* const reloadedSkills = reloaded.AddComponent(-1); + reloadedSkills->LoadFromXml(doc); + EXPECT_EQ(reloadedSkills->GetCooldownGroups().size(), 2u); + EXPECT_FLOAT_EQ(reloadedSkills->GetCooldownGroups().at(17), 30.0f); + + CDClientManager::GetEntriesMutable().clear(); +} + +// Saves without load with no cooldowns and gain , as live wrote it with none running. +TEST_F(CharacterSaveFieldsTests, SkillCooldownsMissingInOldSave) { + tinyxml2::XMLDocument doc; + Parse(doc, R"()"); + + Entity player(28, info); + auto* const skills = player.AddComponent(-1); + skills->LoadFromXml(doc); + EXPECT_TRUE(skills->GetCooldownGroups().empty()); + skills->UpdateXml(doc); + EXPECT_EQ(Print(doc), R"()"); +}