Combos: cooldown labels on the skill bar, steps follow the arts' current levels

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

src/game/engine/arts.h

@@ -156,6 +156,59 @@ inline ArtCooldown GetArtCooldown(void* creature, uint16_t art) {
     return {remaining, Float(entry, kCooldownTotal), perSecond > 0.0f ? remaining / perSecond : 0.0f};
 }
 
+// Combos (made at the Kombomeister): a vector of 0x26-byte entries at +0x10e /
+// +0x112 of cCreatureArts, at most 4 (cCreatureArts::FindCombo 0x5819a0):
+//   +0    u16    combo id (0x200..0x204, definitions FindComboDef 0x4d2970)
+//   +2    u32[4] art of each step (0: empty)
+//   +0x12 u16[4] level of each step's art, stored when the combo was made
+//   +0x1a float  total (sum of the arts' regeneration at those levels)
+//   +0x1e float  charge rate, recomputed each update while charging:
+//                1 + average of the arts' regeneration speed % / 100
+//   +0x22 float  charge: counts up to the total (ready at total,
+//                cCreatureArts::IsComboReady 0x581920); using the combo
+//                lowers it (cCreatureArts::AddGroupRegen, combo branch)
+// cCreatureArts::SetCombo (0x581290, (index, arts[4], levels[4], id), ret
+// 0x10) fills an entry and computes the total; the charge starts at 0.
+// A taskbar slot of type 4 holds combo 0x200 + index.
+constexpr size_t kCombosBegin = 0x10e;
+constexpr size_t kCombosEnd = 0x112;
+constexpr size_t kComboSize = 0x26;
+constexpr size_t kComboId = 0x0;
+constexpr size_t kComboArts = 0x2;
+constexpr size_t kComboLevels = 0x12;
+constexpr size_t kComboTotal = 0x1a;
+constexpr size_t kComboRate = 0x1e;
+constexpr size_t kComboCharge = 0x22;
+constexpr unsigned kComboSteps = 4;
+constexpr uint32_t kComboRefBase = 0x200;
+constexpr uint32_t kArtSlotTypeCombo = 4;
+
+// Entry `index` of the combo vector of cCreatureArts `arts`, or null.
+inline uint8_t* ComboEntry(uint8_t* arts, unsigned index) {
+    auto* begin = *reinterpret_cast<uint8_t**>(arts + kCombosBegin);
+    auto* end = *reinterpret_cast<uint8_t**>(arts + kCombosEnd);
+    if (!begin || index >= static_cast<unsigned>(end - begin) / kComboSize) {
+        return nullptr;
+    }
+    return begin + index * kComboSize;
+}
+
+// The cooldown of the combo in a taskbar slot (reference 0x200 + index).
+inline ArtCooldown GetComboCooldown(void* creature, uint32_t slotRef) {
+    auto* arts = static_cast<uint8_t*>(creature) + kCreatureArts;
+    uint8_t* entry = slotRef >= kComboRefBase ? ComboEntry(arts, slotRef - kComboRefBase) : nullptr;
+    if (!entry) {
+        return {};
+    }
+    const float total = Float(entry, kComboTotal);
+    const float remaining = total - Float(entry, kComboCharge);
+    if (remaining <= 0.0f) {
+        return {0.0f, total, 0.0f};
+    }
+    const float rate = Float(entry, kComboRate);
+    return {remaining, total, rate > 0.0f ? remaining / rate : 0.0f};
+}
+
 // cCreature::IsAlly (0x548f20): whether object `id` is an ally of `creature`.
 inline bool IsAlly(void* creature, uint32_t id) {
     using Fn = char(__fastcall*)(void*, void*, uint32_t);

src/mods/combos.cpp

@@ -0,0 +1,95 @@
+// Combos use the current levels of the arts they are made of (request of
+// 2026-10-18).
+//
+// A combo (cCreatureArts +0x10e, layout in game/engine/arts.h) keeps the arts
+// of its steps and a copy of their levels from when it was made at the
+// Kombomeister; its regeneration total and the steps follow those levels, so
+// raising an art later does not change the combo. Every engine tick the
+// hero's combos are compared with the arts' current levels (cooldown entry
+// level + bonus levels); a combo whose levels are out of date is set again
+// with the game's own cCreatureArts::SetCombo (0x581290), which recomputes the
+// total. The charge keeps its fraction of the total.
+
+#include <cstdint>
+#include <cstring>
+
+#include "game/engine/arts.h"
+#include "game/engine/events.h"
+#include "game/engine/objects.h"
+#include "re/log.h"
+
+namespace game {
+
+// cCreatureArts::SetCombo (0x581290, ret 0x10).
+using SetComboFn = void(__fastcall*)(void* arts, void* edx, uint32_t index, const uint32_t* stepArts,
+                                     const uint16_t* levels, uint32_t id);
+
+} // namespace game
+
+namespace mods::combos {
+namespace {
+
+using namespace game;  // combo and cooldown layout (arts.h)
+
+// The art's level now (cooldown entry level + bonus levels), 0 if unknown.
+uint16_t CurrentLevel(uint8_t* arts, uint32_t art) {
+    uint8_t* entry = art ? FindCooldownEntry(arts, static_cast<uint16_t>(art)) : nullptr;
+    return entry ? static_cast<uint16_t>(entry[kCooldownLevel] + entry[kCooldownBonusLevels]) : 0;
+}
+
+void SyncCombos(uint8_t* hero) {
+    uint8_t* arts = hero + kCreatureArts;
+    if (hero[kCreatureComboStep] != 0 || arts[kArtsComboRunning] != 0) {
+        return;  // not while a combo is being executed
+    }
+    for (unsigned index = 0;; ++index) {
+        uint8_t* combo = ComboEntry(arts, index);
+        if (!combo) {
+            return;
+        }
+        const uint16_t id = *reinterpret_cast<uint16_t*>(combo + kComboId);
+        if (id == 0) {
+            continue;
+        }
+        uint32_t stepArts[kComboSteps];
+        uint16_t levels[kComboSteps];
+        std::memcpy(stepArts, combo + kComboArts, sizeof(stepArts));
+        std::memcpy(levels, combo + kComboLevels, sizeof(levels));
+        bool changed = false;
+        for (unsigned step = 0; step < kComboSteps; ++step) {
+            const uint16_t level = CurrentLevel(arts, stepArts[step]);
+            if (level != 0 && level != levels[step]) {  // unknown arts keep their level
+                levels[step] = level;
+                changed = true;
+            }
+        }
+        if (!changed) {
+            continue;
+        }
+        const float oldTotal = Float(combo, kComboTotal);
+        const float fraction = oldTotal > 0.0f ? Float(combo, kComboCharge) / oldTotal : 1.0f;
+        reinterpret_cast<SetComboFn>(0x00581290)(arts, nullptr, index, stepArts, levels, id);
+        combo = ComboEntry(arts, index);  // SetCombo does not reallocate, but stay safe
+        if (combo) {
+            Float(combo, kComboCharge) = fraction * Float(combo, kComboTotal);
+            re::Log("combos: combo %u set to the current levels %u/%u/%u/%u", index, levels[0], levels[1], levels[2],
+                    levels[3]);
+        }
+    }
+}
+
+void OnTick(uint8_t*) {
+    if (auto* hero = static_cast<uint8_t*>(GetPlayerHero())) {
+        SyncCombos(hero);
+    }
+}
+
+struct Registration {
+    Registration() {
+        OnEngineTick(&OnTick);
+    }
+} g_registration;
+
+} // namespace
+
+} // namespace mods::combos

src/mods/skillbar.cpp

@@ -20,6 +20,7 @@
 //
 // Recharging arts show their remaining cooldown (seconds, one decimal) on the
 // slot, drawn with the game's font after RenderArtSlots.
+// Combos too, from their charge (game::GetComboCooldown).
 //
 // Also: 7 entries in the slot-count-by-level table (6 at level 45, 7 at 65),
 // and cCreature::AssignArtToSlot accepts slots up to 6.
@@ -184,7 +185,8 @@ void UpdateLabelRects(uint8_t* const* skills) {
 
 // The remaining cooldown in seconds (at the hero's current regeneration
 // rate, game::GetArtCooldown), to one decimal, centred on each art slot that
-// is recharging (combat moves and spells: slot types 2 / 3).
+// is recharging (combat moves and spells: slot types 2 / 3; combos: 4,
+// game::GetComboCooldown).
 void RenderCooldowns(void* taskbar, void* renderer) {
     auto* p = static_cast<uint8_t*>(taskbar);
     uint8_t* inventory = skillslots::Inventory(*reinterpret_cast<const uint16_t*>(p + kInventoryIndex));
@@ -203,11 +205,12 @@ void RenderCooldowns(void* taskbar, void* renderer) {
     for (unsigned slot = 0; slot < kSlots && slot < shown; ++slot) {
         const uint32_t type = getType(inventory, nullptr, slot);
         const uint32_t ref = getRef(inventory, nullptr, slot);
-        if (!skills[slot] || (type != 2 && type != 3) || !ref) {
+        if (!skills[slot] || (type != 2 && type != 3 && type != game::kArtSlotTypeCombo) || !ref) {
             continue;
         }
-        const uint16_t art = game::ResolveArtId(hero, ref);
-        const game::ArtCooldown cooldown = game::GetArtCooldown(hero, art);
+        const game::ArtCooldown cooldown = type == game::kArtSlotTypeCombo
+                                               ? game::GetComboCooldown(hero, ref)
+                                               : game::GetArtCooldown(hero, game::ResolveArtId(hero, ref));
         if (cooldown.remaining <= game::kArtReadyCooldown) {
             continue;  // ready: no label, the game's icon shows it
         }