InvalidateWindow(WC_STATION_LIST, st->owner);

	}

	/* station remains but it probably lost some parts - station sign should stay in the station boundaries */

	UpdateStationSignCoord(st);

}

// Tries to clear the given area. Returns the cost in case of success.

// Or an error code if it failed.

{

	int allowed_z = -1;

	BEGIN_TILE_LOOP(tile_cur, w, h, tile) {

		if (MayHaveBridgeAbove(tile_cur) && IsBridgeAbove(tile_cur)) {

			return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);

		}

					*station = st;

				} else if (*station != st) {

					return_cmd_error(STR_3006_ADJOINS_MORE_THAN_ONE_EXISTING);

				}

			}

		} else if (check_clear) {

			if (CmdFailed(ret)) return ret;

			cost += ret;

		}

	} END_TILE_LOOP(tile_cur, w, h, tile)

	return cost;

 * - p1 = (bit 24)    - allow stations directly adjacent to other stations.

 * @param p2 various bitstuffed elements

 * - p2 = (bit  0- 3) - railtype (p2 & 0xF)

 * - p2 = (bit  8-15) - custom station class

 * - p2 = (bit 16-23) - custom station id

 */

{

	int w_org, h_org;

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

	/* Does the authority allow this? */

	if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile_org)) return CMD_ERROR;

	if (!ValParamRailtype(p2 & 0xF)) return CMD_ERROR;

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

	StationID est = INVALID_STATION;

	// If DC_EXEC is in flag, do not want to pass it to CheckFlatLandBelow, because of a nice bug

	//  for detail info, see: https://sourceforge.net/tracker/index.php?func=detail&aid=1029064&group_id=103924&atid=636365

	ret = CheckFlatLandBelow(tile_org, w_org, h_org, flags & ~DC_EXEC, 5 << axis, _patches.nonuniform_stations ? &est : NULL);

	if (CmdFailed(ret)) return ret;

	Station *st = NULL;

	bool check_surrounding = true;

	if (_patches.adjacent_stations) {

		if (est != INVALID_STATION) {

 * This allows for custom-built station with holes and weird layouts

 * @param tile tile of station piece to remove

 * @param flags operation to perform

 * @param p1 start_tile

 * @param p2 unused

 */

{

	TileIndex start = p1 == 0 ? tile : p1;

	/* Count of the number of tiles removed */

	int quantity = 0;

	if (quantity == 0) return CMD_ERROR;

	return _price.remove_rail_station * quantity;

}

{

	/* if there is flooding and non-uniform stations are enabled, remove platforms tile by tile */

	if (_current_player == OWNER_WATER && _patches.nonuniform_stations)

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

	/* Current player owns the station? */

	tile = st->train_tile;

	int w = st->trainst_w;

	int h = st->trainst_h;

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

	/* clear all areas of the station */

	do {

		int w_bak = w;

		do {

			// for nonuniform stations, only remove tiles that are actually train station tiles

			if (st->TileBelongsToRailStation(tile)) {

 * @param tile        The tile on which the railtype is to be convert.

 * @param totype      The railtype we want to convert to

 * @param exec        Switches between test and execute mode

 * @return            The cost and state of the operation

 * @retval CMD_ERROR  An error occured during the operation.

 */

{

	const Station* st = GetStationByTile(tile);

	if (!CheckOwnership(st->owner) || !EnsureNoVehicle(tile)) return CMD_ERROR;

	// tile is not a railroad station?

 * @param p1 entrance direction (DiagDirection)

 * @param p2 bit 0: 0 for Bus stops, 1 for truck stops

 *           bit 1: 0 for normal, 1 for drive-through

 *           bit 2..4: the roadtypes

 *           bit 5: allow stations directly adjacent to other stations.

 */

{

	bool type = HASBIT(p2, 0);

	bool is_drive_through = HASBIT(p2, 1);

	bool build_over_road  = is_drive_through && IsTileType(tile, MP_STREET) && GetRoadTileType(tile) == ROAD_TILE_NORMAL;

	bool town_owned_road  = build_over_road && IsTileOwner(tile, OWNER_TOWN);

	RoadTypes rts = (RoadTypes)GB(p2, 2, 3);

	if (build_over_road && (GetAllRoadBits(tile) & ((Axis)p1 == AXIS_X ? ROAD_Y : ROAD_X)) != 0) return_cmd_error(STR_DRIVE_THROUGH_ERROR_DIRECTION);

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

	if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile)) return CMD_ERROR;

	/* Not allowed to build over this road */

	if (build_over_road) {

		if (IsTileOwner(tile, OWNER_TOWN) && !_patches.road_stop_on_town_road) return_cmd_error(STR_DRIVE_THROUGH_ERROR_ON_TOWN_ROAD);

		if (GetRoadTileType(tile) != ROAD_TILE_NORMAL) return CMD_ERROR;

		rs_auto_delete.Release();

	}

	return cost;

}

// Remove a bus station

{

	if (_current_player != OWNER_WATER && !CheckOwnership(st->owner)) {

		return CMD_ERROR;

	}

	bool is_truck = IsTruckStop(tile);

/** Remove a bus or truck stop

 * @param tile tile to remove the stop from

 * @param flags operation to perform

 * @param p1 not used

 * @param p2 bit 0: 0 for Bus stops, 1 for truck stops

 */

{

	/* Make sure the specified tile is a road stop of the correct type */

	if (!IsTileType(tile, MP_STATION) || !IsRoadStop(tile) || (uint32)GetRoadStopType(tile) != p2) return CMD_ERROR;

	Station *st = GetStationByTile(tile);

	/* Save the stop info before it is removed */

	bool is_drive_through = IsDriveThroughStopTile(tile);

	RoadTypes rts = GetRoadTypes(tile);

	RoadBits road_bits = IsDriveThroughStopTile(tile) ?

			((GetRoadStopDir(tile) == DIAGDIR_NE) ? ROAD_X : ROAD_Y) :

			DiagDirToRoadBits(GetRoadStopDir(tile));

	bool is_towns_road = is_drive_through && GetStopBuiltOnTownRoad(tile);

	/* If the stop was a drive-through stop replace the road */

	if ((flags & DC_EXEC) && !CmdFailed(ret) && is_drive_through) {

		/* Rebuild the drive throuhg road stop. As a road stop can only be

		 * removed by the owner of the roadstop, _current_player is the

		 * owner of the road stop. */

/** Place an Airport.

 * @param tile tile where airport will be built

 * @param flags operation to perform

 * @param p1 airport type, @see airport.h

 * @param p2 (bit 0) - allow airports directly adjacent to other airports.

 */

{

	bool airport_upgrade = true;

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

	/* Check if a valid, buildable airport was chosen for construction */

	}

	const AirportFTAClass *afc = GetAirport(p1);

	int w = afc->size_x;

	int h = afc->size_y;

	if (CmdFailed(ret)) return ret;

	Station *st = NULL;

	if (!_patches.adjacent_stations || !HASBIT(p2, 0)) {

		st = GetStationAround(tile, w, h, INVALID_STATION);

		if (st == CHECK_STATIONS_ERR) return CMD_ERROR;

		st_auto_delete.Release();

	}

	return cost;

}

{

	if (_current_player != OWNER_WATER && !CheckOwnership(st->owner))

		return CMD_ERROR;

	TileIndex tile = st->airport_tile;

	const AirportFTAClass *afc = st->Airport();

	int w = afc->size_x;

	int h = afc->size_y;

	Vehicle *v;

	FOR_ALL_VEHICLES(v) {

		if (!(v->type == VEH_AIRCRAFT && IsNormalAircraft(v))) continue;

		if (v->u.air.targetairport == st->index && v->u.air.state != FLYING) return CMD_ERROR;

/** Build a buoy.

 * @param tile tile where to place the bouy

 * @param flags operation to perform

 * @param p1 unused

 * @param p2 unused

 */

{

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

	if (!IsClearWaterTile(tile) || tile == 0) return_cmd_error(STR_304B_SITE_UNSUITABLE);

	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);

			}

		}

	}

	return false;

}

{

	/* XXX: strange stuff */

	if (!IsValidPlayer(_current_player))  return_cmd_error(INVALID_STRING_ID);

	TileIndex tile = st->dock_tile;

/** Build a dock/haven.

 * @param tile tile where dock will be built

 * @param flags operation to perform

 * @param p1 (bit 0) - allow docks directly adjacent to other docks.

 * @param p2 unused

 */

{

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

	DiagDirection direction;

	switch (GetTileSlope(tile, NULL)) {

		case SLOPE_SW: direction = DIAGDIR_NE; break;

		/* success, so don't delete the new station */

		st_auto_delete.Release();

	}

	return _price.build_dock;

}

{

	if (!CheckOwnership(st->owner)) return CMD_ERROR;

	TileIndex tile1 = st->dock_tile;

	TileIndex tile2 = tile1 + TileOffsByDiagDir(GetDockDirection(tile1));

/** Rename a station

 * @param tile unused

 * @param flags operation to perform

 * @param p1 station ID that is to be renamed

 * @param p2 unused

 */

{

	if (!IsValidStationID(p1) || _cmd_text[0] == '\0') return CMD_ERROR;

	Station *st = GetStation(p1);

	if (!CheckOwnership(st->owner)) return CMD_ERROR;

	bool edge_road;

	return CheckAllowRemoveRoad(tile, GetAnyRoadBits(tile, ROADTYPE_ROAD), OWNER_TOWN, &edge_road, ROADTYPE_ROAD) &&

				CheckAllowRemoveRoad(tile, GetAnyRoadBits(tile, ROADTYPE_TRAM), OWNER_TOWN, &edge_road, ROADTYPE_TRAM);

}

{

	if (flags & DC_AUTO) {

		switch (GetStationType(tile)) {

			case STATION_RAIL:    return_cmd_error(STR_300B_MUST_DEMOLISH_RAILROAD);

			case STATION_AIRPORT: return_cmd_error(STR_300E_MUST_DEMOLISH_AIRPORT_FIRST);

			case STATION_TRUCK:   return_cmd_error(HASBIT(GetRoadTypes(tile), ROADTYPE_TRAM) ? STR_3047_MUST_DEMOLISH_CARGO_TRAM_STATION : STR_3047_MUST_DEMOLISH_TRUCK_STATION);