HolidayDateCalculator.cpp File Reference

#include "HolidayDateCalculator.h"
#include "SharedDefines.h"
#include <cmath>

Go to the source code of this file.

Functions
double	sind (double deg)
static bool	IsLeapYear (int year)
static int	DaysInMonth (int year, int month)
static void	NormalizeDate (std::tm &date)

Variables
constexpr double	PI = 3.14159265358979323846
constexpr double	DEG_TO_RAD = PI / 180.0
static const std::vector< HolidayRule >	HolidayRules

Function Documentation

DaysInMonth()

static int DaysInMonth ( int  year, int  month  )

static

{
    static int const table[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    return (month == 2 && IsLeapYear(year)) ? 29 : table[month - 1];
}

References IsLeapYear().

Referenced by NormalizeDate().

IsLeapYear()

static bool IsLeapYear ( int  year )

static

{
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

Referenced by DaysInMonth(), and TEST_F().

NormalizeDate()

static void NormalizeDate ( std::tm &  date )

static

{
    int year = date.tm_year + 1900;
    int month = date.tm_mon + 1;
    int day = date.tm_mday;
 
    while (month > 12)
    {
        month -= 12;
        ++year;
    }
    while (month < 1)
    {
        month += 12;
        --year;
    }
    while (day > DaysInMonth(year, month))
    {
        day -= DaysInMonth(year, month);
        ++month;
        if (month > 12)
        {
            month = 1;
            ++year;
        }
    }
    while (day < 1)
    {
        --month;
        if (month < 1)
        {
            month = 12;
            --year;
        }
        day += DaysInMonth(year, month);
    }
 
    date.tm_year = year - 1900;
    date.tm_mon = month - 1;
    date.tm_mday = day;
 
    // Zeller's congruence; remap 0=Sat to POSIX 0=Sun.
    int zy = year;
    int zm = month;
    if (zm < 3)
    {
        zm += 12;
        --zy;
    }
    int const K = zy % 100;
    int const J = zy / 100;
    int const h = (day + (13 * (zm + 1)) / 5 + K + K / 4 + J / 4 + 5 * J) % 7;
    date.tm_wday = (h + 6) % 7;
}

References DaysInMonth().

Referenced by HolidayDateCalculator::CalculateAutumnEquinox(), HolidayDateCalculator::CalculateEasterSunday(), HolidayDateCalculator::CalculateHolidayDate(), HolidayDateCalculator::CalculateLunarNewYear(), HolidayDateCalculator::CalculateNthWeekday(), HolidayDateCalculator::CalculateWeekdayOnOrAfter(), HolidayDateCalculator::CalculateWinterSolstice(), and HolidayDateCalculator::GetDarkmoonFaireDates().

sind()

double sind ( double  deg )

inline

{ return std::sin(deg * DEG_TO_RAD); }

References DEG_TO_RAD.

Referenced by HolidayDateCalculator::CalculateNewMoon().

Variable Documentation

DEG_TO_RAD

constexpr double DEG_TO_RAD = PI / 180.0

constexpr

Referenced by HolidayDateCalculator::CalculateAutumnEquinox(), HolidayDateCalculator::CalculateWinterSolstice(), and sind().

HolidayRules

const std::vector<HolidayRule> HolidayRules

static

                                                   {
    // Lunar Festival: Chinese New Year - 1 day (event starts day before CNY)
    { HOLIDAY_LUNAR_FESTIVAL, HolidayCalculationType::LUNAR_NEW_YEAR, 0, 0, 0, -1 },
 
    // Love is in the Air: First Monday on or after Feb 3
    { HOLIDAY_LOVE_IS_IN_THE_AIR, HolidayCalculationType::WEEKDAY_ON_OR_AFTER, 2, 3, static_cast<int>(Weekday::MONDAY), 0 },
 
    // Noblegarden: Day after Easter Sunday (Easter + 1 day)
    { HOLIDAY_NOBLEGARDEN, HolidayCalculationType::EASTER_OFFSET, 0, 0, 0, 1 },
 
    // Children's Week: First Monday on or after Apr 25 (Monday closest to May 1)
    { HOLIDAY_CHILDRENS_WEEK, HolidayCalculationType::WEEKDAY_ON_OR_AFTER, 4, 25, static_cast<int>(Weekday::MONDAY), 0 },
 
    // Midsummer Fire Festival: Fixed Jun 21
    { HOLIDAY_FIRE_FESTIVAL, HolidayCalculationType::FIXED_DATE, 6, 21, 0, 0 },
 
    // Fireworks Spectacular: Fixed Jul 4
    { HOLIDAY_FIREWORKS_SPECTACULAR, HolidayCalculationType::FIXED_DATE, 7, 4, 0, 0 },
 
    // Pirates' Day: Fixed Sep 19
    { HOLIDAY_PIRATES_DAY, HolidayCalculationType::FIXED_DATE, 9, 19, 0, 0 },
 
    // Brewfest: Fixed Sept 20 main event, prep starts Sept 13
    { HOLIDAY_BREWFEST, HolidayCalculationType::FIXED_DATE, 9, 13, 0, 0 },
 
    // Harvest Festival: 2 days before autumn equinox (Sept 20-21)
    { HOLIDAY_HARVEST_FESTIVAL, HolidayCalculationType::AUTUMN_EQUINOX, 0, 0, 0, -2 },
 
    // Hallow's End: Fixed Oct 18
    { HOLIDAY_HALLOWS_END, HolidayCalculationType::FIXED_DATE, 10, 18, 0, 0 },
 
    // Day of the Dead: Fixed Nov 1
    { HOLIDAY_DAY_OF_DEAD, HolidayCalculationType::FIXED_DATE, 11, 1, 0, 0 },
 
    // Pilgrim's Bounty: Sunday before Thanksgiving (4th Thursday - 4 days)
    { HOLIDAY_PILGRIMS_BOUNTY, HolidayCalculationType::NTH_WEEKDAY, 11, 4, static_cast<int>(Weekday::THURSDAY), -4 },
 
    // Winter Veil: 6 days before winter solstice (Dec 15-16)
    { HOLIDAY_FEAST_OF_WINTER_VEIL, HolidayCalculationType::WINTER_SOLSTICE, 0, 0, 0, -6 },
 
    // Darkmoon Faire: First Sunday of months matching (month % 3 == locationOffset)
    // Rotates monthly: Mulgore (Jan) -> Terokkar (Feb) -> Elwynn (Mar) -> repeat
    // rule.month stores the location offset
    // rule.offset is -2 (building phase starts Friday, 2 days before faire opens on Sunday)
    { HOLIDAY_DARKMOON_FAIRE_ELWYNN, HolidayCalculationType::DARKMOON_FAIRE, 0, 0, 0, -2 },    // Mar, Jun, Sep, Dec
    { HOLIDAY_DARKMOON_FAIRE_THUNDER, HolidayCalculationType::DARKMOON_FAIRE, 1, 0, 0, -2 },   // Jan, Apr, Jul, Oct
    { HOLIDAY_DARKMOON_FAIRE_SHATTRATH, HolidayCalculationType::DARKMOON_FAIRE, 2, 0, 0, -2 }  // Feb, May, Aug, Nov
};

Referenced by HolidayDateCalculator::GetHolidayRules(), and HolidayDateCalculator::GetPackedHolidayDate().

PI

constexpr double PI = 3.14159265358979323846

constexpr