// This file is part of ClassicAPI. // // ClassicAPI 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 3 of the License, or (at your option) any later version. // // ClassicAPI 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 // ClassicAPI. If not, see . // `C_DateAndTime.*` — backport of modern's date-math API. Four of the // seven functions in this file are pure arithmetic on a `CalendarTime` // table (year/month/monthDay/weekday/hour/minute) — no engine state // touched at all. // // The three that DO read a clock each pick one of the two the client // receives, per `Time::Server`: `GetCurrentCalendarTime` and // `GetServerTimeLocal` display realm time and take `RealmClockEpoch`, while // `GetSecondsUntilDailyReset` counts down to a real moment and takes // `CurrentEpoch`. Reversing either pairing is wrong by the realm's UTC // offset, so keep each call site's reason in view when editing. // // `GetSecondsUntilWeeklyReset` is intentionally omitted — vanilla // has no server-broadcast reset schedule and Turtle WoW realms vary, // so any hardcoded weekday/hour would be wrong somewhere. The few // addons that need it can compute their own from the daily reset. // // CalendarTime field conventions (per Blizzard's // `TimeDocumentation.lua`): // // year full year (e.g. 2026) // month 1..12 (luaIndex) // monthDay 1..31 (luaIndex) // weekday 1..7 (luaIndex; 1 = Sunday) // hour 0..23 // minute 0..59 // // C's `std::tm` uses different bases for some of these: `tm_year` is // years-since-1900, `tm_mon` is 0..11, `tm_wday` is 0..6 with // Sunday=0. The pack/unpack helpers below translate. #include "Game.h" #include "Server.h" #include #include namespace Time::DateAndTime { namespace { constexpr int SECONDS_PER_DAY = 86400; constexpr int SECONDS_PER_MINUTE = 60; // Pushes a fresh CalendarTime table at the top of the stack. Caller // owns the stack — clear it before invoking if you need the new table // at a specific index. void PushCalendarTime(void *L, const std::tm &t) { Game::Lua::NewTable(L); Game::Lua::SetFieldNumber(L, "year", static_cast(t.tm_year + 1900)); Game::Lua::SetFieldNumber(L, "month", static_cast(t.tm_mon + 1)); Game::Lua::SetFieldNumber(L, "monthDay", static_cast(t.tm_mday)); Game::Lua::SetFieldNumber(L, "weekday", static_cast(t.tm_wday + 1)); Game::Lua::SetFieldNumber(L, "hour", static_cast(t.tm_hour)); Game::Lua::SetFieldNumber(L, "minute", static_cast(t.tm_min)); } // Reads a numeric field off the table at `tableIdx`. Returns false // if the field is missing or non-numeric, leaving `*out` untouched. // Always restores the stack to its entry state. bool ReadField(void *L, int tableIdx, const char *key, int *out) { Game::Lua::PushString(L, key); Game::Lua::GetTable(L, tableIdx); const bool ok = Game::Lua::IsNumber(L, -1); if (ok) *out = static_cast(Game::Lua::ToNumber(L, -1)); Game::Lua::SetTop(L, -2); return ok; } // Reads a CalendarTime table at `idx` into a `std::tm`. Doesn't set // `tm_wday`/`tm_yday` — those are output-only for `_mkgmtime`. // Returns false if the required fields are missing. bool ReadCalendarTime(void *L, int idx, std::tm *out) { if (Game::Lua::Type(L, idx) != Game::Lua::TYPE_TABLE) return false; int year = 0, month = 0, monthDay = 0, hour = 0, minute = 0; if (!ReadField(L, idx, "year", &year)) return false; if (!ReadField(L, idx, "month", &month)) return false; if (!ReadField(L, idx, "monthDay", &monthDay)) return false; // hour/minute may legitimately be 0 — only require their presence. ReadField(L, idx, "hour", &hour); ReadField(L, idx, "minute", &minute); *out = std::tm{}; out->tm_year = year - 1900; out->tm_mon = month - 1; out->tm_mday = monthDay; out->tm_hour = hour; out->tm_min = minute; out->tm_sec = 0; out->tm_isdst = -1; return true; } // Round-trip helper: turn an input CalendarTime into an epoch, add // `deltaSec`, decompose back into a fresh CalendarTime, push it. int AdjustAndPush(void *L, int deltaSec) { std::tm in{}; if (!ReadCalendarTime(L, 1, &in)) return 0; std::time_t epoch = _mkgmtime(&in); if (epoch < 0) return 0; epoch += deltaSec; std::tm out{}; if (gmtime_s(&out, &epoch) != 0) return 0; Game::Lua::SetTop(L, 0); PushCalendarTime(L, out); return 1; } int __fastcall Script_AdjustTimeByDays(void *L) { if (!Game::Lua::IsNumber(L, 2)) return 0; const int days = static_cast(Game::Lua::ToNumber(L, 2)); return AdjustAndPush(L, days * SECONDS_PER_DAY); } int __fastcall Script_AdjustTimeByMinutes(void *L) { if (!Game::Lua::IsNumber(L, 2)) return 0; const int minutes = static_cast(Game::Lua::ToNumber(L, 2)); return AdjustAndPush(L, minutes * SECONDS_PER_MINUTE); } // `CompareCalendarTime(lhs, rhs)` — returns -1, 0, or 1. We compare // via epoch conversion rather than field-by-field tuple compare so // out-of-range inputs (e.g. month=13) normalize consistently. int __fastcall Script_CompareCalendarTime(void *L) { std::tm lhs{}, rhs{}; if (!ReadCalendarTime(L, 1, &lhs) || !ReadCalendarTime(L, 2, &rhs)) return 0; const std::time_t e1 = _mkgmtime(&lhs); const std::time_t e2 = _mkgmtime(&rhs); int cmp = 0; if (e1 < e2) cmp = -1; else if (e1 > e2) cmp = 1; Game::Lua::PushNumber(L, static_cast(cmp)); return 1; } int __fastcall Script_GetCalendarTimeFromEpoch(void *L) { if (!Game::Lua::IsNumber(L, 1)) return 0; std::time_t epoch = static_cast(Game::Lua::ToNumber(L, 1)); std::tm t{}; if (gmtime_s(&t, &epoch) != 0) return 0; Game::Lua::SetTop(L, 0); PushCalendarTime(L, t); return 1; } // Returns REALM time, not UTC — the documented contract, and the reason // this reads `RealmClockEpoch` rather than `CurrentEpoch`. Its hour and // minute therefore always agree with `GetGameTime()`. int __fastcall Script_GetCurrentCalendarTime(void *L) { const int64_t epoch = Time::Server::RealmClockEpoch(); if (epoch <= 0) return 0; std::time_t e = static_cast(epoch); std::tm t{}; if (gmtime_s(&t, &e) != 0) return 0; Game::Lua::SetTop(L, 0); PushCalendarTime(L, t); return 1; } // `GetSecondsUntilDailyReset()` — UTC-midnight semantics, which is where // the server's own day boundary sits: it buckets its day as // `(gameTime + configuredOffset) / 86400` over a raw `time(nullptr)`, and // never transmits that offset. So this reads `CurrentEpoch` (the instant), // for which `epoch % 86400` is seconds-into-the-UTC-day, and NOT // `RealmClockEpoch` — the realm's displayed midnight is a different moment // whenever the realm is not on UTC. int __fastcall Script_GetSecondsUntilDailyReset(void *L) { const int64_t epoch = Time::Server::CurrentEpoch(); if (epoch <= 0) return 0; const int secondsIntoDay = static_cast(epoch % SECONDS_PER_DAY); const int remaining = SECONDS_PER_DAY - secondsIntoDay; Game::Lua::PushNumber(L, static_cast(remaining)); return 1; } // `GetServerTimeLocal()` — the epoch offset by the server's timezone, so // that formatting it prints the realm's clock digits rather than the // instant. `RealmClockEpoch` already IS that value: it packs the wall clock // the realm broadcasts into an epoch as though those digits were UTC, which // makes it `GetServerTime() + serverTimezoneOffset` by construction. int __fastcall Script_GetServerTimeLocal(void *L) { const int64_t epoch = Time::Server::RealmClockEpoch(); if (epoch <= 0) return 0; Game::Lua::PushNumber(L, static_cast(epoch)); return 1; } } // namespace static void RegisterLuaFunctions() { Game::Lua::RegisterTableFunction("C_DateAndTime", "AdjustTimeByDays", &Script_AdjustTimeByDays); Game::Lua::RegisterTableFunction("C_DateAndTime", "AdjustTimeByMinutes", &Script_AdjustTimeByMinutes); Game::Lua::RegisterTableFunction("C_DateAndTime", "CompareCalendarTime", &Script_CompareCalendarTime); Game::Lua::RegisterTableFunction("C_DateAndTime", "GetCalendarTimeFromEpoch", &Script_GetCalendarTimeFromEpoch); Game::Lua::RegisterTableFunction("C_DateAndTime", "GetCurrentCalendarTime", &Script_GetCurrentCalendarTime); Game::Lua::RegisterTableFunction("C_DateAndTime", "GetSecondsUntilDailyReset", &Script_GetSecondsUntilDailyReset); Game::Lua::RegisterTableFunction("C_DateAndTime", "GetServerTimeLocal", &Script_GetServerTimeLocal); } static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; } // namespace Time::DateAndTime