timer_game_common.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD 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, version 2.
 * OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef TIMER_GAME_COMMON_H
#define TIMER_GAME_COMMON_H
 
#include "../core/strong_typedef_type.hpp"
 
template <class T>
class TimerGame {
public:
  template <class ST> struct DateTag;
  using Date = StrongType::Typedef<int32_t, DateTag<T>, StrongType::Compare, StrongType::Integer>;
 
  using DateFract = uint16_t;
 
  template <class ST> struct YearTag;
  using Year = StrongType::Typedef<int32_t, struct YearTag<T>, StrongType::Compare, StrongType::Integer>;
  using Month = uint8_t;
  using Day = uint8_t;
 
  struct YearMonthDay {
    Year  year;   
    Month month;  
    Day   day;    
  };
 
  static constexpr bool IsLeapYear(Year year)
  {
    int32_t year_as_int = year.base();
    return year_as_int % 4 == 0 && (year_as_int % 100 != 0 || year_as_int % 400 == 0);
  }
 
  static YearMonthDay CalendarConvertDateToYMD(Date date);
  static Date CalendarConvertYMDToDate(Year year, Month month, Day day);
 
  static constexpr Year DateToYear(Date date)
  {
    /* Hardcode the number of days in a year because we can't access CalendarTime from here. */
    return date.base() / 366;
  }
 
  static constexpr Date DateAtStartOfYear(Year year)
  {
    int32_t year_as_int = year.base();
    uint number_of_leap_years = (year == 0) ? 0 : ((year_as_int - 1) / 4 - (year_as_int - 1) / 100 + (year_as_int - 1) / 400 + 1);
 
    /* Hardcode the number of days in a year because we can't access CalendarTime from here. */
    return (365 * year_as_int) + number_of_leap_years;
  }
 
  enum Trigger {
    DAY,
    WEEK,
    MONTH,
    QUARTER,
    YEAR,
  };
 
  enum Priority {
    NONE, 
 
    /* All other may have a Random() call in them, so order is important.
     * For safety, you can only setup a single timer on a single priority. */
    COMPANY,
    DISASTER,
    ENGINE,
    INDUSTRY,
    STATION,
    SUBSIDY,
    TOWN,
    VEHICLE,
  };
 
  struct TPeriod {
    Trigger trigger;
    Priority priority;
 
    TPeriod(Trigger trigger, Priority priority) : trigger(trigger), priority(priority)
    {}
 
    bool operator < (const TPeriod &other) const
    {
      if (this->trigger != other.trigger) return this->trigger < other.trigger;
      return this->priority < other.priority;
    }
 
    bool operator == (const TPeriod &other) const
    {
      return this->trigger == other.trigger && this->priority == other.priority;
    }
  };
 
  using TElapsed = uint;
  struct TStorage {};
};
 
template <class T>
class TimerGameConst {
public:
  static constexpr int DAYS_IN_YEAR = 365; 
  static constexpr int DAYS_IN_LEAP_YEAR = 366; 
  static constexpr int MONTHS_IN_YEAR = 12; 
 
  static constexpr int SECONDS_PER_DAY = 2;   
 
  /*
   * ORIGINAL_BASE_YEAR, ORIGINAL_MAX_YEAR and DAYS_TILL_ORIGINAL_BASE_YEAR are
   * primarily used for loading newgrf and savegame data and returning some
   * newgrf (callback) functions that were in the original (TTD) inherited
   * format, where 'TimerGame<T>::date == 0' meant that it was 1920-01-01.
   */
 
  static constexpr typename TimerGame<T>::Year ORIGINAL_BASE_YEAR = 1920;
  static constexpr typename TimerGame<T>::Year ORIGINAL_END_YEAR = 2051;
  static constexpr typename TimerGame<T>::Year ORIGINAL_MAX_YEAR = 2090;
 
  static constexpr typename TimerGame<T>::Year MAX_YEAR = 5000000;
 
  static constexpr typename TimerGame<T>::Year MIN_YEAR = 0;
 
  static constexpr typename TimerGame<T>::Year DEF_START_YEAR = 1950;
  static constexpr typename TimerGame<T>::Year DEF_END_YEAR = ORIGINAL_END_YEAR - 1;
 
  static constexpr typename TimerGame<T>::Date DAYS_TILL_ORIGINAL_BASE_YEAR = TimerGame<T>::DateAtStartOfYear(ORIGINAL_BASE_YEAR);
 
  static constexpr typename TimerGame<T>::Date MAX_DATE = TimerGame<T>::DateAtStartOfYear(MAX_YEAR + 1) - 1;
 
  static constexpr typename TimerGame<T>::Date MIN_DATE = 0;
 
  static constexpr typename TimerGame<T>::Year INVALID_YEAR = -1; 
  static constexpr typename TimerGame<T>::Date INVALID_DATE = -1; 
};
 
#endif /* TIMER_GAME_COMMON_H */