return AIIndustry._IsCargoAccepted(industry_id, cargo_id) != AIIndustry.CAS_NOT_ACCEPTED;

}

AIAbstractList <- AIList;

AIList.ChangeItem <- AIList.SetValue;

	return AIIndustry._IsCargoAccepted(industry_id, cargo_id) != AIIndustry.CAS_NOT_ACCEPTED;

}

AIAbstractList <- AIList;

AIList.ChangeItem <- AIList.SetValue;

 * \li AITown::IsCity

 *

 * API removals:

 * \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.

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

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

 * \li AIIndustry::IsCargoAccepted now returns CargoAcceptState instead of a boolean.

		/** One-way roads cannot have crossings */

		ERR_CROSSING_ON_ONEWAY_ROAD,       // [STR_ERROR_CROSSING_ON_ONEWAY_ROAD]

		/** 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]

	};

	/**

	 * Types of rail known to the game.

void SQAIRail_Register(Squirrel *engine)

{

	DefSQClass <AIRail> SQAIRail("AIRail");

	SQAIRail.PreRegister(engine);

	SQAIRail.AddConstructor<void (AIRail::*)(), 1>(engine, "x");

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

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

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

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

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

STR_CONFIG_SETTING_STOP_LOCATION_FAR_END                        :far end

STR_CONFIG_SETTING_ROAD_VEHICLE_QUEUEING                        :{LTBLUE}Road vehicle queueing (with quantum effects): {ORANGE}{STRING1}

STR_CONFIG_SETTING_AUTOSCROLL                                   :{LTBLUE}Pan window when mouse is at the edge: {ORANGE}{STRING1}

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_CONFIG_SETTING_PLANE_CRASHES_NONE                           :none

STR_CONFIG_SETTING_PLANE_CRASHES_REDUCED                        :reduced

STR_CONFIG_SETTING_PLANE_CRASHES_NORMAL                         :normal

STR_ERROR_CAN_T_BUILD_CARGO_TRAM_STATION                        :{WHITE}Can't build freight tram station...

STR_ERROR_CAN_T_BUILD_DOCK_HERE                                 :{WHITE}Can't build dock here...

STR_ERROR_CAN_T_BUILD_AIRPORT_HERE                              :{WHITE}Can't build airport here...

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

STR_ERROR_TOO_MANY_TRUCK_STOPS                                  :{WHITE}Too many lorry stations

STR_ERROR_TOO_CLOSE_TO_ANOTHER_RAILROAD                         :{WHITE}Too close to another railway station

STR_ERROR_TOO_CLOSE_TO_ANOTHER_STATION                          :{WHITE}Too close to another station/loading area

	                   |           ((_settings_game.order.improved_load ? 1 : 0) << 0x08)  // fifoloading

	                   |                                                      (0 << 0x09)  // townroadbranchprob

	                   |                                                      (0 << 0x0A)  // tempsnowline

	                   |                                                      (1 << 0x0B)  // newcargo

	                   |                                                      (1 << 0x0C)  // enhancemultiplayer

	                   |                                                      (1 << 0x0D)  // onewayroads

	                   |                                                      (1 << 0x0F)  // statistics

	                   |                                                      (1 << 0x10)  // newsounds

	                   |                                                      (1 << 0x11)  // autoreplace

	                   |                                                      (1 << 0x12)  // autoslope

	                   |                                                      (0 << 0x13)  // followvehicle

	                   |                                                      (1 << 0x14)  // trams

/** Cargo handling sub-page */

static SettingsPage _settings_stations_cargo_page = {_settings_stations_cargo, lengthof(_settings_stations_cargo)};

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"),

	SettingEntry("economy.station_noise_level"),

	SettingEntry("station.modified_catchment"),

	SettingEntry("construction.road_stop_on_town_road"),

};

/** Settings related to stations. */

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

	byte   station_spread;                   ///< amount a station may spread

};

 * @return Succeeded or failed command.

 */

CommandCost CanExpandRailStation(const BaseStation *st, TileArea &new_ta, Axis axis)

{

	TileArea cur_ta = st->train_station;

	/* 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);

	}

	return CommandCost();

	TileArea new_location(tile_org, w_org, h_org);

	/* Make sure the area below consists of clear tiles. (OR tiles belonging to a certain rail station) */

	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);

	cost.AddCost(numtracks * plat_len * RailBuildCost(rt));

	Station *st = NULL;

		if (_current_company != OWNER_WATER) {

			CommandCost ret = CheckOwnership(st->owner);

			if (ret.Failed()) continue;

		}

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

		quantity++;

		if (keep_rail || IsStationTileBlocked(tile)) {

			/* Don't refund the 'steel' of the track when we keep the

			 *  rail, or when the tile didn't have any rail at all. */

	assert(ta.w != 0 && ta.h != 0);

	CommandCost cost(EXPENSES_CONSTRUCTION);

	/* clear all areas of the station */

	TILE_AREA_LOOP(tile, ta) {

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

		CommandCost ret = EnsureNoVehicleOnGround(tile);

		if (ret.Failed()) return ret;

		cost.AddCost(_price[PR_CLEAR_STATION_RAIL]);

 * @param tile TileIndex been queried

 * @param flags operation to perform

 * @return cost or failure of operation

 */

static CommandCost RemoveRailStation(TileIndex tile, DoCommandFlag flags)

{

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

	}

	Station *st = Station::GetByTile(tile);

	CommandCost cost = RemoveRailStation(st, flags);

 * @param tile TileIndex been queried

 * @param flags operation to perform

 * @return cost or failure of operation

 */

static CommandCost RemoveRailWaypoint(TileIndex tile, DoCommandFlag flags)

{

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

	}

	return RemoveRailStation(Waypoint::GetByTile(tile), flags);

}

	    SDT_BOOL(GameSettings, station.join_stations,                                               0, 0,  true,                    STR_CONFIG_SETTING_JOINSTATIONS,           NULL),

	SDTC_CONDBOOL(             gui.sg_full_load_any,                            22,             92, 0, 0,  true,                    STR_NULL,                                  NULL),

	    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),

	SDT_CONDBOOL(GameSettings, order.gradual_loading,                           40, SL_MAX_VERSION, 0,NN,  true,                    STR_CONFIG_SETTING_GRADUAL_LOADING,        NULL),

	SDT_CONDBOOL(GameSettings, construction.road_stop_on_town_road,             47, SL_MAX_VERSION, 0, 0,  true,                    STR_CONFIG_SETTING_STOP_ON_TOWN_ROAD,      NULL),

	SDT_CONDBOOL(GameSettings, construction.road_stop_on_competitor_road,      114, SL_MAX_VERSION, 0, 0,  true,                    STR_CONFIG_SETTING_STOP_ON_COMPETITOR_ROAD,NULL),

		}

		/* No vehicle could be flooded on this airport anymore */

		return;

	}

	if (!IsBridgeTile(tile)) {

		FindVehicleOnPos(tile, &z, &FloodVehicleProc);

		return;

	}

	TileIndex end = GetOtherBridgeEnd(tile);

	StationID est = INVALID_STATION;

	/* Check whether the tiles we're building on are valid rail or not. */

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

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

		TileIndex tile = start_tile + i * offset;

		if (ret.Failed()) return ret;

	}

	Waypoint *wp = NULL;

	TileArea new_location(TileArea(start_tile, width, height));

	CommandCost ret = FindJoiningWaypoint(est, station_to_join, adjacent, new_location, &wp);