HolidayDateCalculator Class Reference

#include "HolidayDateCalculator.h"

Static Public Member Functions
static std::tm	CalculateEasterSunday (int year)
static std::tm	CalculateNthWeekday (int year, int month, Weekday weekday, int n)
static std::tm	CalculateWeekdayOnOrAfter (int year, int month, int day, Weekday weekday)
static std::tm	CalculateLunarNewYear (int year)
static std::tm	CalculateAutumnEquinox (int year)
static std::tm	CalculateWinterSolstice (int year)
static std::tm	CalculateHolidayDate (const HolidayRule &rule, int year)
static uint32_t	PackDate (const std::tm &date)
static std::tm	UnpackDate (uint32_t packed)
static const std::vector< HolidayRule > &	GetHolidayRules ()
static uint32_t	GetPackedHolidayDate (uint32_t holidayId, int year)
static std::vector< uint32_t >	GetDarkmoonFaireDates (int locationOffset, int startYear, int numYears, int dayOffset=0)

Static Private Member Functions
static double	DateToJulianDay (int year, int month, double day)
static void	JulianDayToDate (double jd, int &year, int &month, int &day)
static double	CalculateNewMoon (double k)

Detailed Description

Member Function Documentation

CalculateAutumnEquinox()

std::tm HolidayDateCalculator::CalculateAutumnEquinox ( int  year )

static

{
    // Meeus algorithm for mean September equinox (Table 27.C)
    // Valid for years 2000-3000
    double const Y = (year - 2000.0) / 1000.0;
    double const Y2 = Y * Y;
    double const Y3 = Y2 * Y;
    double const Y4 = Y3 * Y;
 
    // Mean equinox JDE0 (Eq 27.1 for September equinox after 2000)
    double const JDE0 = 2451810.21715 + 365242.01767 * Y - 0.11575 * Y2
                      + 0.00337 * Y3 + 0.00078 * Y4;
 
    // Periodic terms for correction (Table 27.B)
    double const T = (JDE0 - 2451545.0) / 36525.0;
    double const W = 35999.373 * T - 2.47;
    double const deltaLambda = 1.0 + 0.0334 * std::cos(W * DEG_TO_RAD)
                             + 0.0007 * std::cos(2.0 * W * DEG_TO_RAD);
 
    // Simplified correction (sum of periodic terms from Table 27.C)
    // Using first few significant terms
    double const S = 485 * std::cos((324.96 + 1934.136 * T) * DEG_TO_RAD)
                   + 203 * std::cos((337.23 + 32964.467 * T) * DEG_TO_RAD)
                   + 199 * std::cos((342.08 + 20.186 * T) * DEG_TO_RAD)
                   + 182 * std::cos((27.85 + 445267.112 * T) * DEG_TO_RAD)
                   + 156 * std::cos((73.14 + 45036.886 * T) * DEG_TO_RAD)
                   + 136 * std::cos((171.52 + 22518.443 * T) * DEG_TO_RAD)
                   + 77 * std::cos((222.54 + 65928.934 * T) * DEG_TO_RAD)
                   + 74 * std::cos((296.72 + 3034.906 * T) * DEG_TO_RAD)
                   + 70 * std::cos((243.58 + 9037.513 * T) * DEG_TO_RAD)
                   + 58 * std::cos((119.81 + 33718.147 * T) * DEG_TO_RAD)
                   + 52 * std::cos((297.17 + 150.678 * T) * DEG_TO_RAD)
                   + 50 * std::cos((21.02 + 2281.226 * T) * DEG_TO_RAD);
 
    double const JDE = JDE0 + (0.00001 * S) / deltaLambda;
 
    // Convert JDE to calendar date
    int eqYear;
    int eqMonth;
    int eqDay;
    JulianDayToDate(JDE, eqYear, eqMonth, eqDay);
 
    std::tm result = {};
    result.tm_year = eqYear - 1900;
    result.tm_mon = eqMonth - 1;
    result.tm_mday = eqDay;
    mktime(&result);
    return result;
}

References DEG_TO_RAD, and JulianDayToDate().

Referenced by CalculateHolidayDate(), and TEST_F().

CalculateEasterSunday()

std::tm HolidayDateCalculator::CalculateEasterSunday ( int  year )

static

{
    // Anonymous Gregorian algorithm (Computus)
    // Reference: https://en.wikipedia.org/wiki/Date_of_Easter#Anonymous_Gregorian_algorithm
    int const a = year % 19;
    int const b = year / 100;
    int const c = year % 100;
    int const d = b / 4;
    int const e = b % 4;
    int const f = (b + 8) / 25;
    int const g = (b - f + 1) / 3;
    int const h = (19 * a + b - d - g + 15) % 30;
    int const i = c / 4;
    int const k = c % 4;
    int const l = (32 + 2 * e + 2 * i - h - k) % 7;
    int const m = (a + 11 * h + 22 * l) / 451;
    int const month = (h + l - 7 * m + 114) / 31;
    int const 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;
}

Referenced by CalculateHolidayDate(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

CalculateHolidayDate()

std::tm HolidayDateCalculator::CalculateHolidayDate ( const HolidayRule &  rule, int  year  )

static

{
    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);
            if (rule.offset != 0)
            {
                result.tm_mday += rule.offset;
                mktime(&result); // Normalize
            }
            break;
        }
        case HolidayCalculationType::EASTER_OFFSET:
        {
            result = CalculateEasterSunday(year);
            result.tm_mday += rule.offset;
            mktime(&result); // Normalize
            break;
        }
        case HolidayCalculationType::LUNAR_NEW_YEAR:
        {
            result = CalculateLunarNewYear(year);
            if (rule.offset != 0)
            {
                result.tm_mday += rule.offset;
                mktime(&result); // Normalize
            }
            break;
        }
        case HolidayCalculationType::WEEKDAY_ON_OR_AFTER:
        {
            result = CalculateWeekdayOnOrAfter(year, rule.month, rule.day, static_cast<Weekday>(rule.weekday));
            if (rule.offset != 0)
            {
                result.tm_mday += rule.offset;
                mktime(&result); // Normalize
            }
            break;
        }
        case HolidayCalculationType::AUTUMN_EQUINOX:
        {
            result = CalculateAutumnEquinox(year);
            if (rule.offset != 0)
            {
                result.tm_mday += rule.offset;
                mktime(&result); // Normalize
            }
            break;
        }
        case HolidayCalculationType::WINTER_SOLSTICE:
        {
            result = CalculateWinterSolstice(year);
            if (rule.offset != 0)
            {
                result.tm_mday += rule.offset;
                mktime(&result); // Normalize
            }
            break;
        }
        case HolidayCalculationType::DARKMOON_FAIRE:
        {
            // Return first occurrence for the year
            // rule.month contains the location offset (0, 1, or 2)
            int const locationOffset = rule.month;
 
            // Find first month in the year where month % 3 == locationOffset
            for (int month = 1; month <= 12; ++month)
            {
                if (month % 3 == locationOffset)
                {
                    result = CalculateNthWeekday(year, month, Weekday::SUNDAY, 1);
                    break;
                }
            }
            break;
        }
    }
 
    return result;
}

References AUTUMN_EQUINOX, CalculateAutumnEquinox(), CalculateEasterSunday(), CalculateLunarNewYear(), CalculateNthWeekday(), CalculateWeekdayOnOrAfter(), CalculateWinterSolstice(), DARKMOON_FAIRE, HolidayRule::day, EASTER_OFFSET, FIXED_DATE, LUNAR_NEW_YEAR, HolidayRule::month, NTH_WEEKDAY, HolidayRule::offset, SUNDAY, HolidayRule::type, HolidayRule::weekday, WEEKDAY_ON_OR_AFTER, and WINTER_SOLSTICE.

Referenced by GetPackedHolidayDate(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

CalculateLunarNewYear()

std::tm HolidayDateCalculator::CalculateLunarNewYear ( int  year )

static

{
    // Chinese New Year always falls on the new moon between Jan 21 and Feb 20
    double const jan21JD = DateToJulianDay(year, 1, 21.0);
    double const feb21JD = DateToJulianDay(year, 2, 21.0);
 
    // Approximate lunation number k for January of target year
    double const approxK = (year - 2000.0) * 12.3685;
    double const k = std::floor(approxK);
 
    // Search for the new moon in the valid range
    for (int i = -2; i <= 2; ++i)
    {
        double const nmJDE = CalculateNewMoon(k + i);
 
        // Convert TT (Terrestrial Time) to UT (approximate DeltaT ~70s for 2020s)
        double nmJD = nmJDE - 70.0 / 86400.0;
 
        // Add 8 hours for China Standard Time (UTC+8)
        nmJD += 8.0 / 24.0;
 
        if (nmJD >= jan21JD && nmJD < feb21JD)
        {
            int cnyYear, cnyMonth, cnyDay;
            JulianDayToDate(nmJD, cnyYear, cnyMonth, cnyDay);
 
            std::tm result = {};
            result.tm_year = cnyYear - 1900;
            result.tm_mon = cnyMonth - 1;
            result.tm_mday = cnyDay;
            mktime(&result);
            return result;
        }
    }
 
    // Fallback (should never happen for years 2000-2031)
    std::tm fallback = {};
    fallback.tm_year = year - 1900;
    fallback.tm_mon = 0;  // January
    fallback.tm_mday = 25;
    mktime(&fallback);
    return fallback;
}

References CalculateNewMoon(), DateToJulianDay(), and JulianDayToDate().

Referenced by CalculateHolidayDate(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

CalculateNewMoon()

double HolidayDateCalculator::CalculateNewMoon ( double  k )

staticprivate

{
    // Meeus "Astronomical Algorithms" Chapter 49
    double const T = k / 1236.85;
    double const T2 = T * T;
    double const T3 = T2 * T;
    double const T4 = T3 * T;
 
    // Mean phase (Eq 49.1)
    double const JDE = 2451550.09766 + 29.530588861 * k + 0.00015437 * T2
                     - 0.000000150 * T3 + 0.00000000073 * T4;
 
    // Eccentricity correction
    double const E = 1.0 - 0.002516 * T - 0.0000074 * T2;
    double const E2 = E * E;
 
    // Sun's mean anomaly (Eq 49.4)
    double const M = 2.5534 + 29.10535670 * k - 0.0000014 * T2 - 0.00000011 * T3;
 
    // Moon's mean anomaly (Eq 49.5)
    double const MPrime = 201.5643 + 385.81693528 * k + 0.0107582 * T2
                        + 0.00001238 * T3 - 0.000000058 * T4;
 
    // Moon's argument of latitude (Eq 49.6)
    double const F = 160.7108 + 390.67050284 * k - 0.0016118 * T2
                   - 0.00000227 * T3 + 0.000000011 * T4;
 
    // Longitude of ascending node (Eq 49.7)
    double const Omega = 124.7746 - 1.56375588 * k + 0.0020672 * T2 + 0.00000215 * T3;
 
    // New Moon corrections (Table 49.A)
    double correction =
        - 0.40720 * sind(MPrime)
        + 0.17241 * E * sind(M)
        + 0.01608 * sind(2 * MPrime)
        + 0.01039 * sind(2 * F)
        + 0.00739 * E * sind(MPrime - M)
        - 0.00514 * E * sind(MPrime + M)
        + 0.00208 * E2 * sind(2 * M)
        - 0.00111 * sind(MPrime - 2 * F)
        - 0.00057 * sind(MPrime + 2 * F)
        + 0.00056 * E * sind(2 * MPrime + M)
        - 0.00042 * sind(3 * MPrime)
        + 0.00042 * E * sind(M + 2 * F)
        + 0.00038 * E * sind(M - 2 * F)
        - 0.00024 * E * sind(2 * MPrime - M)
        - 0.00017 * sind(Omega);
 
    // Additional planetary corrections (Table 49.B)
    double const A1  = 299.77 +  0.107408 * k - 0.009173 * T2;
    double const A2  = 251.88 +  0.016321 * k;
    double const A3  = 251.83 + 26.651886 * k;
    double const A4  = 349.42 + 36.412478 * k;
    double const A5  =  84.66 + 18.206239 * k;
    double const A6  = 141.74 + 53.303771 * k;
    double const A7  = 207.14 +  2.453732 * k;
    double const A8  = 154.84 +  7.306860 * k;
    double const A9  =  34.52 + 27.261239 * k;
    double const A10 = 207.19 +  0.121824 * k;
    double const A11 = 291.34 +  1.844379 * k;
    double const A12 = 161.72 + 24.198154 * k;
    double const A13 = 239.56 + 25.513099 * k;
    double const A14 = 331.55 +  3.592518 * k;
 
    correction += 0.000325 * sind(A1) + 0.000165 * sind(A2) + 0.000164 * sind(A3)
                + 0.000126 * sind(A4) + 0.000110 * sind(A5) + 0.000062 * sind(A6)
                + 0.000060 * sind(A7) + 0.000056 * sind(A8) + 0.000047 * sind(A9)
                + 0.000042 * sind(A10) + 0.000040 * sind(A11) + 0.000037 * sind(A12)
                + 0.000035 * sind(A13) + 0.000023 * sind(A14);
 
    return JDE + correction;
}

References sind().

Referenced by CalculateLunarNewYear().

CalculateNthWeekday()

std::tm HolidayDateCalculator::CalculateNthWeekday ( int  year, int  month, Weekday  weekday, int  n  )

static

{
    // 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 const daysUntilWeekday = (static_cast<int>(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;
}

Referenced by CalculateHolidayDate(), GetDarkmoonFaireDates(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

CalculateWeekdayOnOrAfter()

std::tm HolidayDateCalculator::CalculateWeekdayOnOrAfter ( int  year, int  month, int  day, Weekday  weekday  )

static

{
    // Start with the specified date
    std::tm date = {};
    date.tm_year = year - 1900;
    date.tm_mon = month - 1;
    date.tm_mday = day;
    mktime(&date);
 
    // Find days until the target weekday (0 if already on that day)
    int const daysUntilWeekday = (static_cast<int>(weekday) - date.tm_wday + 7) % 7;
    date.tm_mday += daysUntilWeekday;
 
    mktime(&date); // Normalize
    return date;
}

Referenced by CalculateHolidayDate(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

CalculateWinterSolstice()

std::tm HolidayDateCalculator::CalculateWinterSolstice ( int  year )

static

{
    // Meeus algorithm for mean December solstice (Table 27.C)
    // Valid for years 2000-3000
    double const Y = (year - 2000.0) / 1000.0;
    double const Y2 = Y * Y;
    double const Y3 = Y2 * Y;
    double const Y4 = Y3 * Y;
 
    // Mean solstice JDE0 (Eq 27.1 for December solstice after 2000)
    double const JDE0 = 2451900.05952 + 365242.74049 * Y - 0.06223 * Y2
                      - 0.00823 * Y3 + 0.00032 * Y4;
 
    // Periodic terms for correction (Table 27.B)
    double const T = (JDE0 - 2451545.0) / 36525.0;
    double const W = 35999.373 * T - 2.47;
    double const deltaLambda = 1.0 + 0.0334 * std::cos(W * DEG_TO_RAD)
                             + 0.0007 * std::cos(2.0 * W * DEG_TO_RAD);
 
    // Simplified correction (sum of periodic terms from Table 27.C)
    double const S = 485 * std::cos((324.96 + 1934.136 * T) * DEG_TO_RAD)
                   + 203 * std::cos((337.23 + 32964.467 * T) * DEG_TO_RAD)
                   + 199 * std::cos((342.08 + 20.186 * T) * DEG_TO_RAD)
                   + 182 * std::cos((27.85 + 445267.112 * T) * DEG_TO_RAD)
                   + 156 * std::cos((73.14 + 45036.886 * T) * DEG_TO_RAD)
                   + 136 * std::cos((171.52 + 22518.443 * T) * DEG_TO_RAD)
                   + 77 * std::cos((222.54 + 65928.934 * T) * DEG_TO_RAD)
                   + 74 * std::cos((296.72 + 3034.906 * T) * DEG_TO_RAD)
                   + 70 * std::cos((243.58 + 9037.513 * T) * DEG_TO_RAD)
                   + 58 * std::cos((119.81 + 33718.147 * T) * DEG_TO_RAD)
                   + 52 * std::cos((297.17 + 150.678 * T) * DEG_TO_RAD)
                   + 50 * std::cos((21.02 + 2281.226 * T) * DEG_TO_RAD);
 
    double const JDE = JDE0 + (0.00001 * S) / deltaLambda;
 
    // Convert JDE to calendar date
    int solYear;
    int solMonth;
    int solDay;
    JulianDayToDate(JDE, solYear, solMonth, solDay);
 
    std::tm result = {};
    result.tm_year = solYear - 1900;
    result.tm_mon = solMonth - 1;
    result.tm_mday = solDay;
    mktime(&result);
    return result;
}

References DEG_TO_RAD, and JulianDayToDate().

Referenced by CalculateHolidayDate(), and TEST_F().

DateToJulianDay()

double HolidayDateCalculator::DateToJulianDay ( int  year, int  month, double  day  )

staticprivate

{
    if (month <= 2)
    {
        year -= 1;
        month += 12;
    }
    int const A = year / 100;
    int const B = 2 - A + (A / 4);
    return std::floor(365.25 * (year + 4716)) + std::floor(30.6001 * (month + 1)) + day + B - 1524.5;
}

Referenced by CalculateLunarNewYear().

GetDarkmoonFaireDates()

std::vector< uint32_t > HolidayDateCalculator::GetDarkmoonFaireDates ( int  locationOffset, int  startYear, int  numYears, int  dayOffset = 0  )

static

{
    std::vector<uint32_t> dates;
 
    // Darkmoon Faire is first Sunday of months where (month % 3) == locationOffset
    // locationOffset 0: Mar, Jun, Sep, Dec - Elwynn (Alliance)
    // locationOffset 1: Jan, Apr, Jul, Oct - Mulgore (Horde)
    // locationOffset 2: Feb, May, Aug, Nov - Terokkar (Outland)
 
    for (int year = startYear; year < startYear + numYears && year <= 2030; ++year)
    {
        for (int month = 1; month <= 12; ++month)
        {
            if (month % 3 == locationOffset)
            {
                // Calculate first Sunday of this month, then apply day offset
                std::tm date = CalculateNthWeekday(year, month, Weekday::SUNDAY, 1);
                if (dayOffset != 0)
                {
                    date.tm_mday += dayOffset;
                    mktime(&date); // Normalize
                }
                dates.push_back(PackDate(date));
            }
        }
    }
 
    return dates;
}

References CalculateNthWeekday(), PackDate(), and SUNDAY.

Referenced by GameEventMgr::LoadHolidayDates(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

GetHolidayRules()

const std::vector< HolidayRule > & HolidayDateCalculator::GetHolidayRules ( )

static

{
    return HolidayRules;
}

References HolidayRules.

Referenced by GameEventMgr::LoadHolidayDates(), TEST_F(), TEST_F(), and TEST_F().

GetPackedHolidayDate()

uint32_t HolidayDateCalculator::GetPackedHolidayDate ( uint32_t  holidayId, int  year  )

static

{
    for (auto const& rule : HolidayRules)
    {
        if (rule.holidayId == holidayId)
        {
            std::tm const date = CalculateHolidayDate(rule, year);
            return PackDate(date);
        }
    }
    return 0; // Holiday not found
}

References CalculateHolidayDate(), HolidayRules, and PackDate().

Referenced by GameEventMgr::LoadHolidayDates(), and TEST_F().

JulianDayToDate()

void HolidayDateCalculator::JulianDayToDate ( double  jd, int &  year, int &  month, int &  day  )

staticprivate

{
    jd += 0.5;
    int const Z = static_cast<int>(jd);
    int A = Z;
    if (Z >= 2299161)
    {
        int const alpha = static_cast<int>((Z - 1867216.25) / 36524.25);
        A = Z + 1 + alpha - (alpha / 4);
    }
    int const B = A + 1524;
    int const C = static_cast<int>((B - 122.1) / 365.25);
    int const D = static_cast<int>(365.25 * C);
    int const E = static_cast<int>((B - D) / 30.6001);
 
    day = B - D - static_cast<int>(30.6001 * E);
    month = (E < 14) ? E - 1 : E - 13;
    year = (month > 2) ? C - 4716 : C - 4715;
}

Referenced by CalculateAutumnEquinox(), CalculateLunarNewYear(), and CalculateWinterSolstice().

PackDate()

uint32_t HolidayDateCalculator::PackDate ( const std::tm &  date )

static

{
    // WoW packed date format (same as ByteBuffer::AppendPackedTime):
    // bits 24-28: year offset from 2000 (5 bits = 0-31, valid years 2000-2031)
    // bits 20-23: month (0-indexed)
    // bits 14-19: day (0-indexed)
    // bits 11-13: weekday (0=Sunday, 6=Saturday - POSIX tm_wday)
    // bits 6-10: hour
    // bits 0-5: minute
    int const year = date.tm_year + 1900;
    // Client uses 5-bit year offset from 2000, so years before 2000 clamp to 0.
    // If client is patched to support earlier years, update this logic.
    uint32_t const yearOffset = (year < 2000) ? 0 : static_cast<uint32_t>(year - 2000);
    uint32_t const month = static_cast<uint32_t>(date.tm_mon);         // Already 0-indexed
    uint32_t const day = static_cast<uint32_t>(date.tm_mday - 1);      // Convert to 0-indexed
    uint32_t const weekday = static_cast<uint32_t>(date.tm_wday);      // 0=Sunday, 6=Saturday
 
    return (yearOffset << 24) | (month << 20) | (day << 14) | (weekday << 11);
}

Referenced by GetDarkmoonFaireDates(), GetPackedHolidayDate(), TEST_F(), TEST_F(), and TEST_F().

UnpackDate()

std::tm HolidayDateCalculator::UnpackDate ( uint32_t  packed )

static

{
    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);
    result.tm_wday = static_cast<int>((packed >> 11) & 0x7);
    result.tm_hour = static_cast<int>((packed >> 6) & 0x1F);
    result.tm_min = static_cast<int>(packed & 0x3F);
    mktime(&result); // Normalize and fill in tm_yday, tm_isdst
    return result;
}

Referenced by GameEventMgr::LoadHolidayDates(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Events/HolidayDateCalculator.h
• azerothcore-wotlk/src/server/game/Events/HolidayDateCalculator.cpp