feat(Core/Events): Add dynamic holiday date calculator

blinkysc · blinkysc · commit 61eee6f71091 · 2025-12-04T14:43:36.000-06:00
Replaces static SQL-based holiday dates with dynamic C++ calculation.
Holidays are now computed at runtime using:
- Computus algorithm for Easter-based holidays (Noblegarden)
- Nth weekday calculation for floating holidays (Pilgrim's Bounty)
- Fixed dates for standard holidays

Includes unit tests covering years 1900-2200.
DB overrides still supported for custom servers.
diff --git a/src/server/game/Events/GameEventMgr.cpp b/src/server/game/Events/GameEventMgr.cpp
@@ -17,6 +17,7 @@
 
 #include "GameEventMgr.h"
 #include "BattlegroundMgr.h"
+#include "HolidayDateCalculator.h"
 #include "Chat.h"
 #include "DisableMgr.h"
 #include "GameObjectAI.h"
@@ -1071,50 +1072,81 @@ void GameEventMgr::LoadFromDB()
 void GameEventMgr::LoadHolidayDates()
 {
     uint32 oldMSTime = getMSTime();
+    uint32 dynamicCount = 0;
+    uint32 dbCount = 0;
 
-    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_HOLIDAY_DATES);
-    PreparedQueryResult result = WorldDatabase.Query(stmt);
+    // Step 1: Generate dynamic holiday dates based on current year
+    time_t now = time(nullptr);
+    struct tm* timeinfo = localtime(&now);
+    int currentYear = timeinfo->tm_year + 1900;
 
-    if (!result)
+    for (auto const& rule : HolidayDateCalculator::GetHolidayRules())
     {
-        LOG_WARN("server.loading", ">> Loaded 0 holiday dates. DB table `holiday_dates` is empty.");
-        return;
-    }
-
-    uint32 count = 0;
-    do
-    {
-        Field* fields = result->Fetch();
-
-        uint32 holidayId = fields[0].Get<uint32>();
-        HolidaysEntry* entry = const_cast<HolidaysEntry*>(sHolidaysStore.LookupEntry(holidayId));
+        HolidaysEntry* entry = const_cast<HolidaysEntry*>(sHolidaysStore.LookupEntry(rule.holidayId));
         if (!entry)
-        {
-            LOG_ERROR("sql.sql", "holiday_dates entry has invalid holiday id {}.", holidayId);
             continue;
-        }
 
-        uint8 dateId = fields[1].Get<uint8>();
-        if (dateId >= MAX_HOLIDAY_DATES)
+        // Generate dates for current year and next 10 years
+        for (int yearOffset = 0; yearOffset <= 10; ++yearOffset)
         {
-            LOG_ERROR("sql.sql", "holiday_dates entry has out of range date_id {}.", dateId);
-            continue;
-        }
-        entry->Date[dateId] = fields[2].Get<uint32>();
+            int year = currentYear + yearOffset;
+            uint8 dateId = static_cast<uint8>(yearOffset);
 
-        if (uint32 duration = fields[3].Get<uint32>())
-            entry->Duration[0] = duration;
+            if (dateId >= MAX_HOLIDAY_DATES)
+                break;
+
+            entry->Date[dateId] = HolidayDateCalculator::GetPackedHolidayDate(rule.holidayId, year);
+            ++dynamicCount;
+        }
 
         auto itr = std::lower_bound(ModifiedHolidays.begin(), ModifiedHolidays.end(), entry->Id);
         if (itr == ModifiedHolidays.end() || *itr != entry->Id)
         {
             ModifiedHolidays.insert(itr, entry->Id);
         }
+    }
 
-        ++count;
-    } while (result->NextRow());
+    // Step 2: Load DB overrides (allows custom servers to override calculated dates)
+    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_HOLIDAY_DATES);
+    PreparedQueryResult result = WorldDatabase.Query(stmt);
+
+    if (result)
+    {
+        do
+        {
+            Field* fields = result->Fetch();
+
+            uint32 holidayId = fields[0].Get<uint32>();
+            HolidaysEntry* entry = const_cast<HolidaysEntry*>(sHolidaysStore.LookupEntry(holidayId));
+            if (!entry)
+            {
+                LOG_ERROR("sql.sql", "holiday_dates entry has invalid holiday id {}.", holidayId);
+                continue;
+            }
+
+            uint8 dateId = fields[1].Get<uint8>();
+            if (dateId >= MAX_HOLIDAY_DATES)
+            {
+                LOG_ERROR("sql.sql", "holiday_dates entry has out of range date_id {}.", dateId);
+                continue;
+            }
+            entry->Date[dateId] = fields[2].Get<uint32>();
+
+            if (uint32 duration = fields[3].Get<uint32>())
+                entry->Duration[0] = duration;
+
+            auto itr = std::lower_bound(ModifiedHolidays.begin(), ModifiedHolidays.end(), entry->Id);
+            if (itr == ModifiedHolidays.end() || *itr != entry->Id)
+            {
+                ModifiedHolidays.insert(itr, entry->Id);
+            }
+
+            ++dbCount;
+        } while (result->NextRow());
+    }
 
-    LOG_INFO("server.loading", ">> Loaded {} Holiday Dates in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
+    LOG_INFO("server.loading", ">> Loaded {} Holiday Dates ({} dynamic, {} DB overrides) in {} ms",
+        dynamicCount + dbCount, dynamicCount, dbCount, GetMSTimeDiffToNow(oldMSTime));
 }
 
 uint32 GameEventMgr::GetNPCFlag(Creature* cr)
diff --git a/src/server/game/Events/HolidayDateCalculator.cpp b/src/server/game/Events/HolidayDateCalculator.cpp
@@ -0,0 +1,160 @@
+/*
+ * This file is part of the AzerothCore Project. See AUTHORS file for Copyright information
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "HolidayDateCalculator.h"
+#include "SharedDefines.h"
+
+// Static holiday rules configuration
+static const std::vector<HolidayRule> s_HolidayRules = {
+    // Lunar Festival: Fixed Jan 22 (simplification; Blizzard varied slightly)
+    { HOLIDAY_LUNAR_FESTIVAL, HolidayCalculationType::FIXED_DATE, 1, 22, 0, 0 },
+
+    // Love is in the Air: Fixed Feb 6
+    { HOLIDAY_LOVE_IS_IN_THE_AIR, HolidayCalculationType::FIXED_DATE, 2, 6, 0, 0 },
+
+    // Noblegarden: Week after Easter (Easter + 7 days)
+    { HOLIDAY_NOBLEGARDEN, HolidayCalculationType::EASTER_OFFSET, 0, 0, 0, 7 },
+
+    // Children's Week: Fixed Apr 30
+    { HOLIDAY_CHILDRENS_WEEK, HolidayCalculationType::FIXED_DATE, 4, 30, 0, 0 },
+
+    // Harvest Festival: Fixed Sep 28
+    { HOLIDAY_HARVEST_FESTIVAL, HolidayCalculationType::FIXED_DATE, 9, 28, 0, 0 },
+
+    // Pilgrim's Bounty: 4th Thursday of November (Thanksgiving)
+    { HOLIDAY_PILGRIMS_BOUNTY, HolidayCalculationType::NTH_WEEKDAY, 11, 4, WEEKDAY_THURSDAY, 0 }
+};
+
+const std::vector<HolidayRule>& HolidayDateCalculator::GetHolidayRules()
+{
+    return s_HolidayRules;
+}
+
+std::tm HolidayDateCalculator::CalculateEasterSunday(int year)
+{
+    // Anonymous Gregorian algorithm (Computus)
+    // This algorithm calculates the date of Easter Sunday for any year
+    int a = year % 19;
+    int b = year / 100;
+    int c = year % 100;
+    int d = b / 4;
+    int e = b % 4;
+    int f = (b + 8) / 25;
+    int g = (b - f + 1) / 3;
+    int h = (19 * a + b - d - g + 15) % 30;
+    int i = c / 4;
+    int k = c % 4;
+    int l = (32 + 2 * e + 2 * i - h - k) % 7;
+    int m = (a + 11 * h + 22 * l) / 451;
+    int month = (h + l - 7 * m + 114) / 31;
+    int day = ((h + l - 7 * m + 114) % 31) + 1;
+
+    std::tm result = {};
+    result.tm_year = year - 1900;
+    result.tm_mon = month - 1;
+    result.tm_mday = day;
+    mktime(&result); // Normalize and fill in other fields
+
+    return result;
+}
+
+std::tm HolidayDateCalculator::CalculateNthWeekday(int year, int month, Weekday weekday, int n)
+{
+    // Start with first day of the month
+    std::tm date = {};
+    date.tm_year = year - 1900;
+    date.tm_mon = month - 1;
+    date.tm_mday = 1;
+    mktime(&date);
+
+    // Find first occurrence of the target weekday
+    int daysUntilWeekday = (weekday - date.tm_wday + 7) % 7;
+    date.tm_mday = 1 + daysUntilWeekday;
+
+    // Move to nth occurrence
+    date.tm_mday += (n - 1) * 7;
+
+    mktime(&date); // Normalize (handles month overflow)
+    return date;
+}
+
+std::tm HolidayDateCalculator::CalculateHolidayDate(const HolidayRule& rule, int year)
+{
+    std::tm result = {};
+
+    switch (rule.type)
+    {
+        case HolidayCalculationType::FIXED_DATE:
+        {
+            result.tm_year = year - 1900;
+            result.tm_mon = rule.month - 1;
+            result.tm_mday = rule.day;
+            mktime(&result);
+            break;
+        }
+        case HolidayCalculationType::NTH_WEEKDAY:
+        {
+            result = CalculateNthWeekday(year, rule.month, static_cast<Weekday>(rule.weekday), rule.day);
+            break;
+        }
+        case HolidayCalculationType::EASTER_OFFSET:
+        {
+            result = CalculateEasterSunday(year);
+            result.tm_mday += rule.offset;
+            mktime(&result); // Normalize
+            break;
+        }
+    }
+
+    return result;
+}
+
+uint32_t HolidayDateCalculator::PackDate(const std::tm& date)
+{
+    // WoW packed date format:
+    // bits 14-19: day (0-indexed)
+    // bits 20-23: month (0-indexed)
+    // bits 24-28: year offset from 2000
+    uint32_t yearOffset = static_cast<uint32_t>((date.tm_year + 1900) - 2000);
+    uint32_t month = static_cast<uint32_t>(date.tm_mon);         // Already 0-indexed
+    uint32_t day = static_cast<uint32_t>(date.tm_mday - 1);      // Convert to 0-indexed
+
+    return (yearOffset << 24) | (month << 20) | (day << 14);
+}
+
+std::tm HolidayDateCalculator::UnpackDate(uint32_t packed)
+{
+    std::tm result = {};
+    result.tm_year = static_cast<int>(((packed >> 24) & 0x1F) + 2000 - 1900);
+    result.tm_mon = static_cast<int>((packed >> 20) & 0xF);
+    result.tm_mday = static_cast<int>(((packed >> 14) & 0x3F) + 1);
+    mktime(&result);
+    return result;
+}
+
+uint32_t HolidayDateCalculator::GetPackedHolidayDate(uint32_t holidayId, int year)
+{
+    for (auto const& rule : s_HolidayRules)
+    {
+        if (rule.holidayId == holidayId)
+        {
+            std::tm date = CalculateHolidayDate(rule, year);
+            return PackDate(date);
+        }
+    }
+    return 0; // Holiday not found
+}
diff --git a/src/server/game/Events/HolidayDateCalculator.h b/src/server/game/Events/HolidayDateCalculator.h
@@ -0,0 +1,78 @@
+/*
+ * This file is part of the AzerothCore Project. See AUTHORS file for Copyright information
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef AZEROTHCORE_HOLIDAY_DATE_CALCULATOR_H
+#define AZEROTHCORE_HOLIDAY_DATE_CALCULATOR_H
+
+#include <cstdint>
+#include <ctime>
+#include <vector>
+
+enum class HolidayCalculationType
+{
+    FIXED_DATE,        // Same month/day every year (e.g., Dec 25)
+    NTH_WEEKDAY,       // Nth weekday of month (e.g., 4th Thursday of Nov)
+    EASTER_OFFSET      // Days relative to Easter Sunday
+};
+
+enum Weekday
+{
+    WEEKDAY_SUNDAY = 0,
+    WEEKDAY_MONDAY,
+    WEEKDAY_TUESDAY,
+    WEEKDAY_WEDNESDAY,
+    WEEKDAY_THURSDAY,
+    WEEKDAY_FRIDAY,
+    WEEKDAY_SATURDAY
+};
+
+struct HolidayRule
+{
+    uint32_t holidayId;
+    HolidayCalculationType type;
+    int month;      // 1-12
+    int day;        // For FIXED_DATE: day of month. For NTH_WEEKDAY: which occurrence (1-5)
+    int weekday;    // For NTH_WEEKDAY: 0=Sunday through 6=Saturday
+    int offset;     // For EASTER_OFFSET: days after Easter (can be negative)
+};
+
+class HolidayDateCalculator
+{
+public:
+    // Calculate Easter Sunday for a given year (Computus algorithm)
+    static std::tm CalculateEasterSunday(int year);
+
+    // Calculate Nth weekday of a month (e.g., 4th Thursday of November)
+    static std::tm CalculateNthWeekday(int year, int month, Weekday weekday, int n);
+
+    // Calculate holiday start date for a given year
+    static std::tm CalculateHolidayDate(const HolidayRule& rule, int year);
+
+    // Convert std::tm to WoW's packed date format
+    static uint32_t PackDate(const std::tm& date);
+
+    // Convert WoW's packed date format to std::tm
+    static std::tm UnpackDate(uint32_t packed);
+
+    // Get all holiday rules
+    static const std::vector<HolidayRule>& GetHolidayRules();
+
+    // Calculate date for a specific holiday ID and year
+    static uint32_t GetPackedHolidayDate(uint32_t holidayId, int year);
+};
+
+#endif // AZEROTHCORE_HOLIDAY_DATE_CALCULATOR_H
diff --git a/src/test/server/game/Events/HolidayDateCalculatorTest.cpp b/src/test/server/game/Events/HolidayDateCalculatorTest.cpp
