* @param engine_number the engine of which to draw the info of

 * @return y after drawing all the text

 */

int DrawVehiclePurchaseInfo(int left, int right, int y, EngineID engine_number, TestedEngineDetails &te)

{

	const Engine *e = Engine::Get(engine_number);

	bool refittable = IsArticulatedVehicleRefittable(engine_number);

	bool articulated_cargo = false;

	switch (e->type) {

		default: NOT_REACHED();

		case VEH_TRAIN:

static int32_t ClickChangeDateCheat(int32_t new_value, int32_t)

{

	/* Don't allow changing to an invalid year, or the current year. */

	auto new_year = Clamp(TimerGameCalendar::Year(new_value), CalendarTime::MIN_YEAR, CalendarTime::MAX_YEAR);

	if (new_year == TimerGameCalendar::year) return TimerGameCalendar::year.base();

	TimerGameCalendar::Date new_date = TimerGameCalendar::ConvertYMDToDate(new_year, ymd.month, ymd.day);

	/* Shift cached dates before we change the date. */

	for (auto v : Vehicle::Iterate()) v->ShiftDates(new_date - TimerGameCalendar::date);

	LinkGraphSchedule::instance.ShiftDates(new_date - TimerGameCalendar::date);

{

	if (argc == 0) {

		IConsolePrint(CC_HELP, "Returns the current date (year-month-day) of the game. Usage: 'getdate'.");

		return true;

	}

	IConsolePrint(CC_DEFAULT, "Date: {:04d}-{:02d}-{:02d}", ymd.year, ymd.month + 1, ymd.day);

	return true;

}

DEF_CONSOLE_CMD(ConGetSysDate)

{

static void SurveyRecentNews(nlohmann::json &json)

{

	json = nlohmann::json::array();

	int i = 0;

	for (NewsItem *news = _latest_news; i < 32 && news != nullptr; news = news->prev, i++) {

		json.push_back(fmt::format("({}-{:02}-{:02}) StringID: {}, Type: {}, Ref1: {}, {}, Ref2: {}, {}",

		               ymd.year, ymd.month + 1, ymd.day, news->string_id, news->type,

		               news->reftype1, news->ref1, news->reftype2, news->ref2));

	}

}

	{

		assert(this->min_year <= this->max_year);

		this->parent = parent;

		this->InitNested(window_number);

		if (initial_date == 0) initial_date = TimerGameCalendar::date;

		this->date.year = Clamp(this->date.year, min_year, max_year);

	}

	Point OnInitialPosition([[maybe_unused]] int16_t sm_width, [[maybe_unused]] int16_t sm_height, [[maybe_unused]] int window_number) override

	{

		Point pt = { this->parent->left + this->parent->width / 2 - sm_width / 2, this->parent->top + this->parent->height / 2 - sm_height / 2 };

		/* Exclude certain engines */

		if (!HasBit(ei->climates, _settings_game.game_creation.landscape)) continue;

		if (e->type == VEH_TRAIN && e->u.rail.railveh_type == RAILVEH_WAGON) continue;

		/* Base year ending date on half the model life */

		_year_engine_aging_stops = std::max(_year_engine_aging_stops, ymd.year);

	}

}

/**

 * @ingroup SnowLineGroup

 */

byte GetSnowLine()

{

	if (_snow_line == nullptr) return _settings_game.game_creation.snow_line_height;

	return _snow_line->table[ymd.month][ymd.day];

}

/**

 * Get the highest possible snow line height, either variable or static.

 * @return the highest snow line height.

				DrawString(mapsize.left, mapsize.right, y + text_y_offset, STR_NETWORK_SERVER_LIST_MAP_SIZE_SHORT, TC_FROMSTRING, SA_HOR_CENTER);

			}

			if (const NWidgetBase *nwid = this->GetWidget<NWidgetBase>(WID_NG_DATE); nwid->current_x != 0) {

				/* current date */

				Rect date = nwid->GetCurrentRect();

				SetDParam(0, ymd.year);

				DrawString(date.left, date.right, y + text_y_offset, STR_JUST_INT, TC_BLACK, SA_HOR_CENTER);

			}

			if (const NWidgetBase *nwid = this->GetWidget<NWidgetBase>(WID_NG_YEARS); nwid->current_x != 0) {

				/* number of years the game is running */

				Rect years = nwid->GetCurrentRect();

				SetDParam(0, ymd_cur.year - ymd_start.year);

				DrawString(years.left, years.right, y + text_y_offset, STR_JUST_INT, TC_BLACK, SA_HOR_CENTER);

			}

			/* draw a lock if the server is password protected */

			if (cur_item->info.use_password) DrawSprite(SPR_LOCK, PAL_NONE, info.left + this->lock_offset, y + lock_y_offset);

		case 0x01: // current year

			*value = (Clamp(TimerGameCalendar::year, CalendarTime::ORIGINAL_BASE_YEAR, CalendarTime::ORIGINAL_MAX_YEAR) - CalendarTime::ORIGINAL_BASE_YEAR).base();

			return true;

		case 0x02: { // detailed date information: month of year (bit 0-7), day of month (bit 8-12), leap year (bit 15), day of year (bit 16-24)

			TimerGameCalendar::Date start_of_year = TimerGameCalendar::ConvertYMDToDate(ymd.year, 0, 1);

			*value = ymd.month | (ymd.day - 1) << 8 | (TimerGameCalendar::IsLeapYear(ymd.year) ? 1 << 15 : 0) | (TimerGameCalendar::date - start_of_year).base() << 16;

			return true;

		}

		case 0x03: // current climate, 0=temp, 1=arctic, 2=trop, 3=toyland

		i->town = Town::Get(RemapTownIndex(_old_town_index));

		if (_savegame_type == SGT_TTO) {

			if (i->type > 0x06) i->type++; // Printing Works were added

			if (i->type == 0x0A) i->type = 0x12; // Iron Ore Mine has different ID

			i->last_prod_year = ymd.year;

			i->random_colour = RemapTTOColour(i->random_colour);

		}

		Industry::IncIndustryTypeCount(i->type);

}

/* static */ SQInteger ScriptDate::GetYear(ScriptDate::Date date)

{

	if (date < 0) return DATE_INVALID;

	return ymd.year.base();

}

/* static */ SQInteger ScriptDate::GetMonth(ScriptDate::Date date)

{

	if (date < 0) return DATE_INVALID;

	return ymd.month + 1;

}

/* static */ SQInteger ScriptDate::GetDayOfMonth(ScriptDate::Date date)

{

	if (date < 0) return DATE_INVALID;

	return ymd.day;

}

/* static */ ScriptDate::Date ScriptDate::GetDate(SQInteger year, SQInteger month, SQInteger day_of_month)

{

	if (month < 1 || month > 12) return DATE_INVALID;

	assert(id < lengthof(iec_prefixes));

	fmt::format_to(builder, NBSP "{}B", iec_prefixes[id]);

}

static void FormatYmdString(StringBuilder &builder, TimerGameCalendar::Date date, uint case_index)

{

	auto tmp_params = MakeParameters(ymd.day + STR_DAY_NUMBER_1ST - 1, STR_MONTH_ABBREV_JAN + ymd.month, ymd.year);

	FormatString(builder, GetStringPtr(STR_FORMAT_DATE_LONG), tmp_params, case_index);

}

static void FormatMonthAndYear(StringBuilder &builder, TimerGameCalendar::Date date, uint case_index)

{

	auto tmp_params = MakeParameters(STR_MONTH_JAN + ymd.month, ymd.year);

	FormatString(builder, GetStringPtr(STR_FORMAT_DATE_SHORT), tmp_params, case_index);

}

static void FormatTinyOrISODate(StringBuilder &builder, TimerGameCalendar::Date date, StringID str)

{

	/* Day and month are zero-padded with ZEROFILL_NUM, hence the two 2s. */

	auto tmp_params = MakeParameters(ymd.day, 2, ymd.month + 1, 2, ymd.year);

	FormatString(builder, GetStringPtr(str), tmp_params);

}

	}

	void DrawWidget(const Rect &r, int widget) const override

	{

		if (widget != WID_SUL_PANEL) return;

		Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);

		int pos = -this->vscroll->GetPosition();

		const int cap = this->vscroll->GetCapacity();

 */

void SurveyTimers(nlohmann::json &survey)

{

	survey["ticks"] = TimerGameTick::counter;

	survey["seconds"] = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - _switch_mode_time).count();

	survey["calendar"] = fmt::format("{:04}-{:02}-{:02} ({})", ymd.year, ymd.month + 1, ymd.day, TimerGameCalendar::date_fract);

}

/**

 * Convert GRF information to JSON.

 *

	ACCUM_SEP, ACCUM_OCT, ACCUM_NOV, ACCUM_DEC,

};

/**

 * Converts a Date to a Year, Month & Day.

 * @param date the date to convert from

 */

{

	/* Year determination in multiple steps to account for leap

	 * years. First do the large steps, then the smaller ones.

	 */

	/* There are 97 leap years in 400 years */

	TimerGameCalendar::Year yr = 400 * (date.base() / (CalendarTime::DAYS_IN_YEAR * 400 + 97));

	int rem = date.base() % (CalendarTime::DAYS_IN_YEAR * 400 + 97);

	if (rem >= CalendarTime::DAYS_IN_YEAR * 100 + 25) {

		/* There are 25 leap years in the first 100 years after

		 * every 400th year, as every 400th year is a leap year */

		yr += 100;

		rem -= CalendarTime::DAYS_IN_YEAR * 100 + 25;

		yr++;

	}

	/* Skip the 29th of February in non-leap years */

	if (!TimerGameCalendar::IsLeapYear(yr) && rem >= ACCUM_MAR - 1) rem++;

}

/**

 * Converts a tuple of Year, Month and Day to a Date.

 * @param year  is a number between 0..MAX_YEAR

 * @param month is a number between 0..11

 * @param fract The number of ticks that have passed on this date.

 */

/* static */ void TimerGameCalendar::SetDate(TimerGameCalendar::Date date, TimerGameCalendar::DateFract fract)

{

	assert(fract < Ticks::DAY_TICKS);

	TimerGameCalendar::date = date;

	TimerGameCalendar::date_fract = fract;

	TimerGameCalendar::year = ymd.year;

	TimerGameCalendar::month = ymd.month;

}

template<>

void IntervalTimer<TimerGameCalendar>::Elapsed(TimerGameCalendar::TElapsed trigger)

	if (TimerGameCalendar::date_fract < Ticks::DAY_TICKS) return;

	TimerGameCalendar::date_fract = 0;

	/* increase day counter */

	TimerGameCalendar::date++;

	/* check if we entered a new month? */

	bool new_month = ymd.month != TimerGameCalendar::month;

	/* check if we entered a new year? */

	bool new_year = ymd.year != TimerGameCalendar::year;

	using TElapsed = uint;

	struct TStorage {

	};

	static bool IsLeapYear(Year yr);

	static Date ConvertYMDToDate(Year year, Month month, Day day);

	static void SetDate(Date date, DateFract fract);

	/**

	 * Calculate the year of a given date.

	 * @param date The date to consider.