{}

	/**

	 * @return The amount of AI ticks to suspend the AI.

	 */

	int GetSuspendTime() { return time; }

	void RegisterAPI();

	/**

	 */

	bool LoadCompatibilityScripts(const char *api_version);

	void Died();

	/**

	 * @param vm The virtual machine to get all the data from.

	 * @param index The index on the squirrel stack of the element to save.

	 * @param max_depth The maximum depth recursive arrays / tables will be stored

	/**

	 * Get a random value.

	 * @return A random value between 0 and MAX(uint32).

	 */

	static uint32 RandItem(int unused_param);

	/**

	 * Get a random value in a range.

	 * @param max The first number this function will never return (the maximum it returns is max - 1).

	 * @return A random value between 0 .. max - 1.

	 */

	static uint RandRangeItem(int unused_param, uint max);

	/**

	 *   After all, it is a random function.

	 * @param out How many times it should return true.

	 * @param max Out of this many times.

	static bool Chance(uint out, uint max);

	/**

	 *   After all, it is a random function.

	 * @param out How many times it should return true.

	 * @param max Out of this many times.

	 * @return True if the chance worked out.

 * @param type Type of vehicle (VEH_*)

 * @param l The left most location of the list

 * @param r The right most location of the list

 * @param eng_list What engines to draw

 * @param min where to start in the list

 * @param max where in the list to end

	GLAND_START_DATE_TEXT,    ///< Start year

	GLAND_START_DATE_UP,      ///< Increase start year

	GLAND_SNOW_LEVEL_TEXT,    ///< Snow level

	GLAND_SNOW_LEVEL_UP,      ///< Increase snow level

	_gws.current = 0;

	_gws.total   = 0;

	_gws.percent = 0;

}

/**

		if (!ind_spc->enabled || chance == 0 || ind_spc->num_table == 0) continue;

		 * and if appearing chance for this landscape is above 0, this industry can be chosen */

		if (CheckIfCallBackAllowsAvailability(j, IACT_RANDOMCREATION)) {

			probability_max += chance;

					}

					d = maxdim(d, GetStringBoundingBox(str));

					GetAllCargoSuffixes(3, CST_FUND, NULL, this->index[i], indsp, indsp->produced_cargo, cargo_suffix);

					str = STR_INDUSTRY_VIEW_PRODUCES_CARGO;

					p = 0;

					y += FONT_HEIGHT_NORMAL;

				}

				char cargo_suffix[3][512];

				GetAllCargoSuffixes(0, CST_FUND, NULL, this->selected_type, indsp, indsp->accepts_cargo, cargo_suffix);

				StringID str = STR_INDUSTRY_VIEW_REQUIRES_CARGO;

				DrawString(left, right, y, str);

				y += FONT_HEIGHT_NORMAL;

				GetAllCargoSuffixes(3, CST_FUND, NULL, this->selected_type, indsp, indsp->produced_cargo, cargo_suffix);

				str = STR_INDUSTRY_VIEW_PRODUCES_CARGO;

				p = 0;

Listing IndustryDirectoryWindow::last_sorting = {false, 0};

const Industry *IndustryDirectoryWindow::last_industry = NULL;

GUIIndustryList::SortFunction * const IndustryDirectoryWindow::sorter_funcs[] = {

	&IndustryNameSorter,

	&IndustryTypeSorter,

	 * Handle the given packet, i.e. pass it to the right

	 * parser receive command.

	 * @param p the packet to handle

	 */

	bool HandlePacket(Packet *p);

public:

		/* Nothing depends on us, mark the whole graph as unselected.

		 * After that's done run over them once again to test their children

		 * we're doing now. */

		for (ConstContentIterator iter = parents.Begin(); iter != parents.End(); iter++) {

			const ContentInfo *c = *iter;

	return sprite;

}

void DrawRoadVehEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal)

{

	SpriteID sprite = GetRoadVehIcon(engine);

		if (already_reversed && prev->tile != tile) {

			/*

			 * The vehicle has reversed, but did not go straight back.

			 * the roadstate of the previous vehicle cannot be used

			 * as the direction we have to go with this vehicle.

			 *

	/* Test for adjacent station or station below selection.

	 * If adjacent-stations is disabled and we are building next to a station, do not show the selection window.

	const T *st = FindStationsNearby<T>(ta, false);

	return st == NULL && (_settings_game.station.adjacent_stations || _stations_nearby_list.Length() == 0);

}

			break;

	}

	 * stop location of the train. */

	return stop - (v->tcache.cached_veh_length + 1) / 2;

}

		CountArticulatedParts(eid, false);

	/* Check if depot and new engine uses the same kind of tracks *

	if (!HasPowerOnRail(rvi->railtype, GetRailType(tile))) return CMD_ERROR;

	/* Allow for the dual-heads and the articulated parts */

bool Train::IsStoppedInDepot() const

{

	if (this->IsFrontEngine() && !(this->vehstatus & VS_STOPPED)) return false;

	return this->IsInDepot();

}

	/* We must be the first in the chain. */

	assert(chain->Previous() == NULL);

	if (chain->IsWagon()) {

		chain->SetFreeWagon();

	} else {

 */

static CommandCost CheckNewTrain(Train *original_dst, Train *dst, Train *original_src, Train *src)

{

	 * If that's less than or equal to 0 we can be sure we did

	 * not add any engines (read: trains) along the way. */

	if ((src          != NULL && src->IsEngine()          ? 1 : 0) +

		if (v == first && v->IsEngine() && !sell_chain && new_head != NULL && new_head->IsFrontEngine()) {

			/* We are selling the front engine. In this case we want to

			new_head->orders.list = first->orders.list;

			new_head->AddToShared(first);

			DeleteVehicleOrders(first);

		if (a->track != TRACK_BIT_WORMHOLE) VehicleEnterTile(a, a->tile, a->x_pos, a->y_pos);

	}

	v->PowerChanged();

}

	Train *last = v->Last(); // last vehicle to move

	uint length = CountVehiclesInChain(v);

	 * they have already correct spacing, so we have to make sure they are moved how they should */

	while (length > 2) {

		/* we reached vehicle (originally) in front of a depot, stop now

		if (base == dep) break;

		/* the last wagon was that one leaving a depot, so do not move it anymore */

		/* No smoke in depots or tunnels */

		if (IsRailDepotTile(v->tile) || IsTunnelTile(v->tile)) continue;

		if (!HasPowerOnRail(v->railtype, GetTileRailType(v->tile))) continue;

		if (effect_type == 0) {

	Vehicle *other_train = NULL;

	PBSTileInfo origin = FollowTrainReservation(v, &other_train);

	 * This can only happen in certain situations when mixing path and

	 * block signals or when changing tracks and/or signals.

	 * Exit here as doing any further reservations will probably just

		return true;

	}

	if (v->track == TRACK_BIT_DEPOT) {

		SetDepotReservation(v->tile, true);

		if (_settings_client.gui.show_track_reservation) MarkTileDirtyByTile(v->tile);

				if (bits == TRACK_BIT_NONE) goto invalid_rail;

				 * with the current train, if not, bail out. */

				if (!CheckCompatibleRail(v, gp.new_tile)) goto invalid_rail;

						 * This case is active if 'prev' is already on the second next tile, when 'v' just enters the next tile.

						 * I.e. when the tile between them has only space for a single vehicle like

						 *  1) horizontal/vertical track tiles and

						 */

						static const TrackBits _connecting_track[DIAGDIR_END][DIAGDIR_END] = {

							{TRACK_BIT_X,     TRACK_BIT_LOWER, TRACK_BIT_NONE,  TRACK_BIT_LEFT },

				if (v->IsFrontEngine()) {

					v->wait_counter = 0;

					TileIndex crossing = TrainApproachingCrossingTile(v);

					if (crossing != INVALID_TILE && HasCrossingReservation(crossing)) SndPlayTileFx(SND_0E_LEVEL_CROSSING, crossing);

	/* Go to the last wagon and delete the link pointing there

	 * *u is then the one-before-last wagon, and *v the last

	Train *u = v;

	for (; v->Next() != NULL; v = v->Next()) u = v;

	u->SetNext(NULL);

		/* Is there anything to refit? */

		if (union_mask != 0) {

			CargoID cargo_type;

			if (IsArticulatedVehicleCarryingDifferentCargos(v, &cargo_type)) continue;

			/* Did the old vehicle carry anything? */

/**

 * List of vehicles that should check for autoreplace this tick.

 */

typedef SmallMap<Vehicle *, bool, 4> AutoreplaceMap;

static AutoreplaceMap _vehicles_to_autoreplace;

			default: NOT_REACHED();

			case VEH_TRAIN: {

				if (v != NULL && parent_engine_type != INVALID_ENGINE && (UsesWagonOverride(v) || (Train::From(v)->IsArticulatedPart() && e->u.rail.railveh_type != RAILVEH_WAGON))) {

					 * Articulated parts use the colour scheme of the first part. (Not supported for articulated wagons) */

					engine_type = parent_engine_type;

					e = Engine::Get(engine_type);