AIAbstractList <- AIList;

AIList.ChangeItem <- AIList.SetValue;

AIAbstractList <- AIList;

AIList.ChangeItem <- AIList.SetValue;

 * \li HasNext for all lists.

 * \li AIAbstractList, use AIList instead.

 * \li AIList::ChangeItem, use AIList::SetValue instead.

 *

 * Other changes:

 * \li AIEngine::GetMaxTractiveEffort can be used for road vehicles.

		/** Track not suitable for signals */

		ERR_UNSUITABLE_TRACK,              // [STR_ERROR_NO_SUITABLE_RAILROAD_TRACK]

		/** This railtype cannot have crossings */

		ERR_RAILTYPE_DISALLOWS_CROSSING,   // [STR_ERROR_CROSSING_DISALLOWED]

	};

	SQAIRail.DefSQConst(engine, AIRail::ERR_RAIL_BASE,                    "ERR_RAIL_BASE");

	SQAIRail.DefSQConst(engine, AIRail::ERR_CROSSING_ON_ONEWAY_ROAD,      "ERR_CROSSING_ON_ONEWAY_ROAD");

	SQAIRail.DefSQConst(engine, AIRail::ERR_UNSUITABLE_TRACK,             "ERR_UNSUITABLE_TRACK");

	SQAIRail.DefSQConst(engine, AIRail::ERR_RAILTYPE_DISALLOWS_CROSSING,  "ERR_RAILTYPE_DISALLOWS_CROSSING");

	SQAIRail.DefSQConst(engine, AIRail::RAILTYPE_INVALID,                 "RAILTYPE_INVALID");

	SQAIRail.DefSQConst(engine, AIRail::RAILTRACK_NE_SW,                  "RAILTRACK_NE_SW");

	AIError::RegisterErrorMap(STR_ERROR_CROSSING_ON_ONEWAY_ROAD,        AIRail::ERR_CROSSING_ON_ONEWAY_ROAD);

	AIError::RegisterErrorMap(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK,     AIRail::ERR_UNSUITABLE_TRACK);

	AIError::RegisterErrorMap(STR_ERROR_CROSSING_DISALLOWED,            AIRail::ERR_RAILTYPE_DISALLOWS_CROSSING);

	AIError::RegisterErrorMapString(AIRail::ERR_CROSSING_ON_ONEWAY_ROAD,      "ERR_CROSSING_ON_ONEWAY_ROAD");

	AIError::RegisterErrorMapString(AIRail::ERR_UNSUITABLE_TRACK,             "ERR_UNSUITABLE_TRACK");

	AIError::RegisterErrorMapString(AIRail::ERR_RAILTYPE_DISALLOWS_CROSSING,  "ERR_RAILTYPE_DISALLOWS_CROSSING");

	SQAIRail.DefSQStaticMethod(engine, &AIRail::GetName,                         "GetName",                         2, ".i");

STR_CONFIG_SETTING_BRIBE                                        :{LTBLUE}Allow bribing of the local authority: {ORANGE}{STRING1}

STR_CONFIG_SETTING_ALLOW_EXCLUSIVE                              :{LTBLUE}Allow buying exclusive transport rights: {ORANGE}{STRING1}

STR_CONFIG_SETTING_ALLOW_GIVE_MONEY                             :{LTBLUE}Allow sending money to other companies: {ORANGE}{STRING1}

STR_CONFIG_SETTING_FREIGHT_TRAINS                               :{LTBLUE}Weight multiplier for freight to simulate heavy trains: {ORANGE}{STRING}

STR_CONFIG_SETTING_PLANE_SPEED                                  :{LTBLUE}Plane speed factor: {ORANGE}1 / {STRING1}

STR_CONFIG_SETTING_PLANE_CRASHES                                :{LTBLUE}Number of plane crashes: {ORANGE}{STRING1}

STR_ERROR_ADJOINS_MORE_THAN_ONE_EXISTING                        :{WHITE}Adjoins more than one existing station/loading area

STR_ERROR_STATION_TOO_SPREAD_OUT                                :{WHITE}... station too spread out

STR_ERROR_TOO_MANY_STATIONS_LOADING                             :{WHITE}Too many stations/loading areas

STR_ERROR_TOO_MANY_STATION_SPECS                                :{WHITE}Too many railway station parts

STR_ERROR_TOO_MANY_BUS_STOPS                                    :{WHITE}Too many bus stops

	                   |                                                      (1 << 0x0B)  // newcargo

	                   |                                                      (1 << 0x0C)  // enhancemultiplayer

	                   |                                                      (1 << 0x0D)  // onewayroads

	                   |                                                      (1 << 0x0F)  // statistics

	                   |                                                      (1 << 0x10)  // newsounds

	                   |                                                      (1 << 0x11)  // autoreplace

static SettingEntry _settings_stations[] = {

	SettingEntry(&_settings_stations_cargo_page, STR_CONFIG_SETTING_STATIONS_CARGOHANDLING),

	SettingEntry("station.join_stations"),

	SettingEntry("station.adjacent_stations"),

	SettingEntry("station.distant_join_stations"),

	SettingEntry("station.station_spread"),

struct StationSettings {

	bool   modified_catchment;               ///< different-size catchment areas

	bool   join_stations;                    ///< allow joining of train stations

	bool   adjacent_stations;                ///< allow stations to be built directly adjacent to other stations

	bool   distant_join_stations;            ///< allow to join non-adjacent stations

	bool   never_expire_airports;            ///< never expire airports

{

	TileArea cur_ta = st->train_station;

		/* determine new size of train station region.. */

		int x = min(TileX(cur_ta.tile), TileX(new_ta.tile));

		int y = min(TileY(cur_ta.tile), TileY(new_ta.tile));

		new_ta.w = max(TileX(cur_ta.tile) + cur_ta.w, TileX(new_ta.tile) + new_ta.w) - x;

		new_ta.h = max(TileY(cur_ta.tile) + cur_ta.h, TileY(new_ta.tile) + new_ta.h) - y;

		new_ta.tile = TileXY(x, y);

	/* make sure the final size is not too big. */

	if (new_ta.w > _settings_game.station.station_spread || new_ta.h > _settings_game.station.station_spread) {

		return_cmd_error(STR_ERROR_STATION_TOO_SPREAD_OUT);

	StationID est = INVALID_STATION;

	SmallVector<Train *, 4> affected_vehicles;

	/* Clear the land below the station. */

	if (cost.Failed()) return cost;

	/* Add construction expenses. */

	cost.AddCost((numtracks * _price[PR_BUILD_STATION_RAIL] + _price[PR_BUILD_STATION_RAIL_LENGTH]) * plat_len);

			if (ret.Failed()) continue;

		}

		/* If we reached here, the tile is valid so increase the quantity of tiles we will remove */

		quantity++;

	CommandCost cost(EXPENSES_CONSTRUCTION);

	/* clear all areas of the station */

	TILE_AREA_LOOP(tile, ta) {

		if (!st->TileBelongsToRailStation(tile)) continue;

		CommandCost ret = EnsureNoVehicleOnGround(tile);

 */

static CommandCost RemoveRailStation(TileIndex tile, DoCommandFlag flags)

{

		return DoCommand(tile, 0, 0, DC_EXEC, CMD_REMOVE_FROM_RAIL_STATION);

	}

 */

static CommandCost RemoveRailWaypoint(TileIndex tile, DoCommandFlag flags)

{

		return DoCommand(tile, 0, 0, DC_EXEC, CMD_REMOVE_FROM_RAIL_WAYPOINT);

	}

	    SDT_BOOL(GameSettings, order.improved_load,                                                 0,NN,  true,                    STR_CONFIG_SETTING_IMPROVEDLOAD,           NULL),

	    SDT_BOOL(GameSettings, order.selectgoods,                                                   0, 0,  true,                    STR_CONFIG_SETTING_SELECTGOODS,            NULL),

	SDTC_CONDBOOL(             gui.sg_new_nonstop,                              22,             92, 0, 0, false,                    STR_NULL,                                  NULL),

	     SDT_VAR(GameSettings, station.station_spread,               SLE_UINT8,                     0, 0,    12,     4,      64, 0, STR_CONFIG_SETTING_STATION_SPREAD,         InvalidateStationBuildWindow),

	    SDT_BOOL(GameSettings, order.serviceathelipad,                                              0, 0,  true,                    STR_CONFIG_SETTING_SERVICEATHELIPAD,       NULL),

	    SDT_BOOL(GameSettings, station.modified_catchment,                                          0, 0,  true,                    STR_CONFIG_SETTING_CATCHMENT,              StationCatchmentChanged),

		return;

	}

	if (!IsBridgeTile(tile)) {

		FindVehicleOnPos(tile, &z, &FloodVehicleProc);

		return;

	TileIndexDiff offset = TileOffsByDiagDir(AxisToDiagDir(OtherAxis(axis)));

	for (int i = 0; i < count; i++) {

		TileIndex tile = start_tile + i * offset;

		if (ret.Failed()) return ret;

	}