if (this->running_ticks == 0) return;

	this->profit_this_year -= cost.GetCost();

	this->running_ticks = 0;

	 * number of companies. The minimum number of days in a quarter

	 * is 90: 31 in January, 28 in February and 31 in March.

	 * Note that the company going bankrupt can't buy itself. */

	assert(c->bankrupt_asked != 0);

	}

	if (_new_competitor_timeout.HasFired() && _game_mode != GM_MENU && AI::CanStartNew()) {

		/* If the interval is zero, start as many competitors as needed then check every ~10 minutes if a company went bankrupt and needs replacing. */

		if (timeout == 0) {

			/* count number of competitors */

				if (n++ >= _settings_game.difficulty.max_no_competitors) break;

				Command<CMD_COMPANY_CTRL>::Post(CCA_NEW_AI, INVALID_COMPANY, CRR_NONE, INVALID_CLIENT_ID);

			}

		}

		/* Randomize a bit when the AI is actually going to start; ranges from 87.5% .. 112.5% of indicated value. */

		timeout += ScriptObject::GetRandomizer(OWNER_NONE).Next(timeout / 4) - timeout / 8;

#include "timer/timer_game_calendar.h"

static const int DAYS_IN_YEAR      = 365; ///< days per year

static const int DAYS_IN_LEAP_YEAR = 366; ///< sometimes, you need one day more...

static const int MONTHS_IN_YEAR    =  12; ///< months per year

static const int SECONDS_PER_DAY   = 2;   ///< approximate seconds per day, not for precise calculations

/*

 * ORIGINAL_BASE_YEAR, ORIGINAL_MAX_YEAR and DAYS_TILL_ORIGINAL_BASE_YEAR are

 * primarily used for loading newgrf and savegame data and returning some

static constexpr TimerGameCalendar::Year INVALID_YEAR = -1; ///< Representation of an invalid year

static constexpr TimerGameCalendar::Date INVALID_DATE = -1; ///< Representation of an invalid date

#endif /* DATE_TYPE_H */

#include "error.h"

#include "engine_base.h"

#include "timer/timer.h"

#include "timer/timer_game_calendar.h"

#include "table/strings.h"

			default: break; // The aircraft, disasters and especially visual effects have no NewGRF configured visual effects

		}

		/* Set cargo aging period to the default value. */

		/* Not a variant */

		this->info.variant_id = INVALID_ENGINE;

		return;

#include "currency.h"

#include "timer/timer.h"

#include "timer/timer_window.h"

#include "timer/timer_game_calendar.h"

#include "zoom_func.h"

			UpdateCompanyRatingAndValue(c, false);

		}

	}

	uint score_info_left;

	i->counter--;

	/* produce some cargo */

		if (HasBit(indsp->callback_mask, CBM_IND_PRODUCTION_256_TICKS)) IndustryProductionCallback(i, 1);

		IndustryBehaviour indbehav = indsp->behaviour;

			if (cb_res != CALLBACK_FAILED) {

				cut = ConvertBooleanCallback(indsp->grf_prop.grffile, CBID_INDUSTRY_SPECIAL_EFFECT, cb_res);

			} else {

			}

			if (cut) ChopLumberMillTrees(i);

#include "../window_func.h"

#include "../company_base.h"

#include "../company_gui.h"

#include "../timer/timer_game_calendar.h"

#include "../viewport_func.h"

#include "../zoom_func.h"

			ConstEdge &edge = lg[ge.node][to->goods[c].node];

			this->AddStats(c, lg.Monthly(edge.capacity), lg.Monthly(edge.usage),

					ge.flows.GetFlowVia(to->index),

					from->owner == OWNER_NONE || to->owner == OWNER_NONE,

					this->cached_links[from->index][to->index]);

		}

#include "../stdafx.h"

#include "../core/math_func.hpp"

#include "mcf.h"

#include "../safeguards.h"

				IsCargoInClass(this->job.Cargo(), CC_EXPRESS);

			uint distance = DistanceMaxPlusManhattan(this->job[from].base.xy, this->job[to].base.xy) + 1;

			/* Compute a default travel time from the distance and an average speed of 1 tile/day. */

			uint distance_anno = express ? time : distance;

			Tannotation *dest = static_cast<Tannotation *>(paths[to]);

			if (this->is_full_loading && this->vehicle->orders != nullptr &&

					st->index == vehicle->last_station_visited &&

					this->vehicle->orders->GetTotalDuration() >

				uint effective_capacity = cargo_quantity * this->vehicle->load_unload_ticks;

				if (effective_capacity > (uint)this->vehicle->orders->GetTotalDuration()) {

					IncreaseStats(st, c, next_station, effective_capacity /

		msg = STR_INCOME_FLOAT_INCOME;

	}

	SetDParam(0, cost);

}

/**

	SetDParam(0, transfer);

	if (income == 0) {

	} else {

		StringID msg = STR_FEEDER_COST;

		if (income < 0) {

			msg = STR_FEEDER_INCOME;

		}

		SetDParam(1, income);

	}

}

#include "../strings_func.h"

#include "../command_func.h"

#include "../timer/timer_game_calendar.h"

#include "network_admin.h"

#include "network_client.h"

	/* This client has missed their ACK packet after 1 DAY_TICKS..

	 *  so we increase their lag for every frame that passes!

	 * The packet can be out by a max of _net_frame_freq */

	}

	return lag;

}

#include "../company_gui.h"

#include "../company_cmd.h"

#include "../core/random_func.hpp"

#include "../timer/timer_game_calendar.h"

#include "../gfx_func.h"

#include "../error.h"

	/* Let the server know that we received this frame correctly

	 *  We do this only once per day, to save some bandwidth ;) */

	if (!_network_first_time && last_ack_frame < _frame_counter) {

		Debug(net, 7, "Sent ACK at {}", _frame_counter);

		SendAck();

	}

	/* The client is trying to catch up with the server */

	if (this->status == STATUS_PRE_ACTIVE) {

		/* The client is not yet caught up? */

		/* Now it is! Unpause the game */

		this->status = STATUS_ACTIVE;

				 * did not receive a packet, then the client is not just

				 * slow, but the connection is likely severed. Mentioning

				 * frame_freq is not useful in this case. */

					IConsolePrint(CC_WARNING, "[{}] Client #{} is slow, try increasing [network.]frame_freq to a higher value!", _frame_counter, cs->client_id);

					cs->lag_test = 1;

				}

#include "debug.h"

#include "town.h"

#include "newgrf_town.h"

#include "safeguards.h"

		case 0x81: return GB(static_cast<uint32_t>(this->t->xy), 8, 8);

		case 0x82: return ClampTo<uint16_t>(this->t->cache.population);

		case 0x83: return GB(ClampTo<uint16_t>(this->t->cache.population), 8, 8);

		case 0x92: return this->t->flags;  // In original game, 0x92 and 0x93 are really one word. Since flags is a byte, this is to adjust

		case 0x93: return 0;

		case 0x94: return ClampTo<uint16_t>(this->t->cache.squared_town_zone_radius[0]);

		case 0xAE: return this->t->have_ratings;

		case 0xB2: return this->t->statues;

		case 0xB6: return ClampTo<uint16_t>(this->t->cache.num_houses);

		case 0xBA: return ClampTo<uint16_t>(this->t->supplied[CT_PASSENGERS].new_max);

		case 0xBB: return GB(ClampTo<uint16_t>(this->t->supplied[CT_PASSENGERS].new_max), 8, 8);

		case 0xBC: return ClampTo<uint16_t>(this->t->supplied[CT_MAIL].new_max);

#include "depot_type.h"

#include "station_type.h"

#include "vehicle_type.h"

#include "date_type.h"

#include "saveload/saveload.h"

	uint num_vehicles;                ///< NOSAVE: Number of vehicles that share this order list.

	Vehicle *first_shared;            ///< NOSAVE: pointer to the first vehicle in the shared order chain.

public:

	/** Default constructor producing an invalid order list. */

	bool IsCompleteTimetable() const;

	/**

	 */

	/**

	 * Gets the known duration of the vehicles timetable even if the timetable is not complete.

	 * @return known timetable duration

	 */

	/**

	 * Gets the known duration of the vehicles orders, timetabled or not.

	 * @return  known order duration.

	 */

	/**

	 * Must be called if an order's timetable is changed to update internal book keeping.

	 * @param delta By how many ticks has the timetable duration changed

	 */

	/**

	 * Must be called if an order's timetable is changed to update internal book keeping.

	 * @param delta By how many ticks has the total duration changed

	 */

	void FreeChain(bool keep_orderlist = false);

	VehicleOrderID check_num_orders = 0;

	VehicleOrderID check_num_manual_orders = 0;

	uint check_num_vehicles = 0;

	Debug(misc, 6, "Checking OrderList {} for sanity...", this->index);

	if (this->running_ticks == 0) return;

	this->profit_this_year -= cost.GetCost();

	this->running_ticks = 0;

	}

	/* The value of TimerGameCalendar::date_fract got divided, so make sure that old games are converted correctly. */

	/* Update current year

	 * must be done before loading sprites as some newgrfs check it */

				t->growth_rate = TownTicksToGameTicks(t->growth_rate & ~0x8000);

			}

			/* Add t->index % TOWN_GROWTH_TICKS to spread growth across ticks. */

		}

	}

			break;

		default:

			/* Don't use growth_rate 0 as it means GROWTH_NORMAL */

			break;

	}

	if (t->growth_rate == TOWN_GROWTH_RATE_NONE) return TOWN_GROWTH_NONE;

}

/* static */ SQInteger ScriptTown::GetDistanceManhattanToTile(TownID town_id, TileIndex tile)

	if (this->running_ticks == 0) return;

	this->profit_this_year -= cost.GetCost();

	this->running_ticks = 0;

#include "core/bitmath_func.hpp"

#include "core/mem_func.hpp"

#include "date_type.h"

/** Flags of the sort list. */

enum SortListFlags {

	void ResetResortTimer()

	{

		/* Resort every 10 days */

	}

public:

	if ((st->facilities & FACIL_WAYPOINT) != 0 || !st->IsInUse()) return;

	byte b = st->delete_ctr + 1;

	st->delete_ctr = b;

	if (b == 0) UpdateStationRating(Station::From(st));

		StationHandleSmallTick(st);

		/* Clean up the link graph about once a week. */

			DeleteStaleLinks(Station::From(st));

		};

		/* Spread out big-tick over STATION_ACCEPTANCE_TICKS ticks. */

			/* Stop processing this station if it was deleted */

			if (!StationHandleBigTick(st)) continue;

		}

		/* Spread out station animation over STATION_ACCEPTANCE_TICKS ticks. */

			TriggerStationAnimation(st, st->xy, SAT_250_TICKS);

			TriggerRoadStopAnimation(st, st->xy, SAT_250_TICKS);

			if (Station::IsExpected(st)) AirportAnimationTrigger(Station::From(st), AAT_STATION_250_TICKS);

 * @param f Bitmask of the climates

 * @note the 5 between b and f is the load amount

 */

/**

 * Writes the properties of a multiple-unit train into the EngineInfo struct.

 * @param f Bitmask of the climates

 * @note the 5 between b and f is the load amount

 */

/**

 * Writes the properties of a train carriage into the EngineInfo struct.

 * @see MT

 * @note the 5 between b and f is the load amount

 */

/**

 * Writes the properties of a road vehicle into the EngineInfo struct.

 * @param f Bitmask of the climates

 * @note the 5 between b and f is the load amount

 */

/**

 * Writes the properties of a ship into the EngineInfo struct.

 * @param f Bitmask of the climates

 * @note the 10 between b and f is the load amount

 */

/**

 * Writes the properties of an aeroplane into the EngineInfo struct.

 * @param e Bitmask of the climates

 * @note the 20 between b and e is the load amount

 */

/* Climates

 * T = Temperate

 */

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

{

	YearMonthDay ymd;

	if (_game_mode == GM_MENU) return;

	TimerGameCalendar::date_fract++;

	TimerGameCalendar::date_fract = 0;

	/* increase day counter */

#include <chrono>

/**

 * Timer that represents the game-ticks. It will pause when the game is paused.

 *

 */

class TimerGameTick {

public:

	using TPeriod = uint;

	using TElapsed = uint;

	struct TStorage {

	static uint64_t counter; ///< Monotonic counter, in ticks, since start of game.

};

#endif /* TIMER_GAME_TICK_H */

#ifndef TIMETABLE_H

#define TIMETABLE_H

#include "date_type.h"

#include "timer/timer_game_calendar.h"

#include "vehicle_type.h"

void ShowTimetableWindow(const Vehicle *v);

void UpdateVehicleTimetable(Vehicle *v, bool travelling);

#endif /* TIMETABLE_H */

#include "stdafx.h"

#include "command_func.h"

#include "company_func.h"

#include "timer/timer_game_calendar.h"

#include "window_func.h"

#include "vehicle_base.h"

	if (start_date - TimerGameCalendar::date > DateAtStartOfYear(MAX_TIMETABLE_START_YEARS)) return CMD_ERROR;

	if (TimerGameCalendar::date - start_date > DAYS_IN_LEAP_YEAR) return CMD_ERROR;

	if (timetable_all && !v->orders->IsCompleteTimetable()) return CommandCost(STR_ERROR_TIMETABLE_INCOMPLETE);

	if (flags & DC_EXEC) {

		std::vector<Vehicle *> vehs;

			w->lateness_counter = 0;

			ClrBit(w->vehicle_flags, VF_TIMETABLE_STARTED);

			/* Do multiplication, then division to reduce rounding errors. */

			SetWindowDirty(WC_VEHICLE_TIMETABLE, w->index);

			++idx;

		}

		just_started = !HasBit(v->vehicle_flags, VF_TIMETABLE_STARTED);

		if (v->timetable_start != 0) {

			v->timetable_start = 0;

		}

		 * the timetable entry like is done for road vehicles/ships.

		 * Thus always make sure at least one tick is used between the

		 * processing of different orders when filling the timetable. */

		if (travelling && (autofilling || !real_current_order->IsTravelTimetabled())) {

			ChangeTimetable(v, v->cur_real_order_index, time_to_set, MTF_TRAVEL_TIME, autofilling);

	 * check how many ticks the (fully filled) timetable has. If a timetable cycle is

	 * shorter than the amount of ticks we are late we reduce the lateness by the

	 * length of a full cycle till lateness is less than the length of a timetable

	if (v->lateness_counter > (int)timetabled) {

			v->lateness_counter %= cycle;

		}

	}

#include "string_func.h"

#include "gfx_func.h"

#include "company_func.h"

#include "timer/timer_game_calendar.h"

#include "date_gui.h"

#include "vehicle_gui.h"

/** Container for the arrival/departure dates of a vehicle */

struct TimetableArrivalDeparture {

};

/**

 * @param param2 the second DParam to fill

 * @param ticks  the number of ticks to 'draw'

 */

{

	if (_settings_client.gui.timetable_in_ticks) {

		SetDParam(param1, STR_TIMETABLE_TICKS);

		SetDParam(param2, ticks);

	} else {

		SetDParam(param1, STR_TIMETABLE_DAYS);

	}

}

 * @param table Fill in arrival and departures including intermediate orders

 * @param offset Add this value to result and all arrivals and departures

 */

{

	assert(!table.empty());

	assert(v->GetNumOrders() >= 2);

	/* Pre-initialize with unknown time */

	for (int i = 0; i < v->GetNumOrders(); ++i) {

	}

	VehicleOrderID i = start;

	const Order *order = v->GetOrder(i);

		assert(HasBit(v->vehicle_flags, VF_TIMETABLE_STARTED));

		bool travelling = (!v->current_order.IsType(OT_LOADING) || v->current_order.GetNonStopType() == ONSF_STOP_EVERYWHERE);