openttd-ottdgrfs: comparison src/station

equal deleted inserted replaced

-:ca3fd1fbe311
+:5a9dc001e1ad
 #include "road.h"
 #include "cargotype.h"
 #include "strings.h"
 #include "autoslope.h"
 #include "newgrf_fsmports.h"
+#include "transparency.h"
+#include "water.h"
 DEFINE_OLD_POOL_GENERIC(Station, Station)
 DEFINE_OLD_POOL_GENERIC(RoadStop, RoadStop)
 	return num;
 }
-/* Calculate the radius of the station. Basicly it is the biggest
+/** Calculate the radius of the station. Basicly it is the biggest
-*  radius that is available within the station */
+*  radius that is available within the station
+* @param st Station to query
+* @return the so calculated radius
+*/
 static uint FindCatchmentRadius(const Station* st)
 {
 	uint ret = CA_NONE;
 	if (st->bus_stops   != NULL) ret = max<uint>(ret, CA_BUS);
 	return false;
 }
 #define M(x) ((x) - STR_SV_STNAME)
+enum StationNaming {
+	STATIONNAMING_RAIL = 0,
+	STATIONNAMING_ROAD = 0,
+	STATIONNAMING_AIRPORT,
+	STATIONNAMING_OILRIG,
+	STATIONNAMING_DOCK,
+	STATIONNAMING_BUOY,
+	STATIONNAMING_HELIPORT,
+};
 static bool GenerateStationName(Station *st, TileIndex tile, int flag)
 {
 	static const uint32 _gen_station_name_bits[] = {
 		0,                                      /* 0 */
 		1 << M(STR_SV_STNAME_AIRPORT),          /* 1 */
 			if (s != st && s->town == t) {
 				uint str = M(s->string_id);
 				if (str <= 0x20) {
 					if (str == M(STR_SV_STNAME_FOREST))
 						str = M(STR_SV_STNAME_WOODS);
-					CLRBIT(free_names, str);
+					ClrBit(free_names, str);
 				}
 			}
 		}
 	}
 		found = FindFirstBit(tmp);
 		goto done;
 	}
 	/* check mine? */
-	if (HASBIT(free_names, M(STR_SV_STNAME_MINES))) {
+	if (HasBit(free_names, M(STR_SV_STNAME_MINES))) {
 		if (CountMapSquareAround(tile, CMSAMine) >= 2) {
 			found = M(STR_SV_STNAME_MINES);
 			goto done;
 		}
 	}
 	/* check close enough to town to get central as name? */
 	if (DistanceMax(tile, t->xy) < 8) {
 		found = M(STR_SV_STNAME);
-		if (HASBIT(free_names, M(STR_SV_STNAME))) goto done;
+		if (HasBit(free_names, M(STR_SV_STNAME))) goto done;
 		found = M(STR_SV_STNAME_CENTRAL);
-		if (HASBIT(free_names, M(STR_SV_STNAME_CENTRAL))) goto done;
+		if (HasBit(free_names, M(STR_SV_STNAME_CENTRAL))) goto done;
 	}
 	/* Check lakeside */
-	if (HASBIT(free_names, M(STR_SV_STNAME_LAKESIDE)) &&
+	if (HasBit(free_names, M(STR_SV_STNAME_LAKESIDE)) &&
 			DistanceFromEdge(tile) < 20 &&
 			CountMapSquareAround(tile, CMSAWater) >= 5) {
 		found = M(STR_SV_STNAME_LAKESIDE);
 		goto done;
 	}
 	/* Check woods */
-	if (HASBIT(free_names, M(STR_SV_STNAME_WOODS)) && (
+	if (HasBit(free_names, M(STR_SV_STNAME_WOODS)) && (
 				CountMapSquareAround(tile, CMSATree) >= 8 ||
 				CountMapSquareAround(tile, CMSAForest) >= 2)
 			) {
 		found = _opt.landscape == LT_TROPIC ?
 			M(STR_SV_STNAME_FOREST) : M(STR_SV_STNAME_WOODS);
 	{
 		uint z = GetTileZ(tile);
 		uint z2 = GetTileZ(t->xy);
 		if (z < z2) {
 			found = M(STR_SV_STNAME_VALLEY);
-			if (HASBIT(free_names, M(STR_SV_STNAME_VALLEY))) goto done;
+			if (HasBit(free_names, M(STR_SV_STNAME_VALLEY))) goto done;
 		} else if (z > z2) {
 			found = M(STR_SV_STNAME_HEIGHTS);
-			if (HASBIT(free_names, M(STR_SV_STNAME_HEIGHTS))) goto done;
+			if (HasBit(free_names, M(STR_SV_STNAME_HEIGHTS))) goto done;
 		}
 	}
 	/* check direction compared to town */
 	{
 	}
 	return best_station;
 }
-// Update the virtual coords needed to draw the station sign.
+/** Update the virtual coords needed to draw the station sign.
-// st = Station to update for.
+* @param st Station to update for.
+*/
 static void UpdateStationVirtCoord(Station *st)
 {
 	Point pt = RemapCoords2(TileX(st->xy) * TILE_SIZE, TileY(st->xy) * TILE_SIZE);
 	pt.y -= 32;
 	SetDParam(0, st->index);
 	SetDParam(1, st->facilities);
 	UpdateViewportSignPos(&st->sign, pt.x, pt.y, STR_305C_0);
 }
-// Update the virtual coords needed to draw the station sign for all stations.
+/** Update the virtual coords needed to draw the station sign for all stations. */
 void UpdateAllStationVirtCoord()
 {
 	Station* st;
 	FOR_ALL_STATIONS(st) {
 	st->MarkDirty();
 	UpdateStationVirtCoord(st);
 	st->MarkDirty();
 }
-// Get a mask of the cargo types that the station accepts.
+/** Get a mask of the cargo types that the station accepts.
+* @param st Station to query
+* @return the expected mask
+*/
 static uint GetAcceptanceMask(const Station *st)
 {
 	uint mask = 0;
 	for (CargoID i = 0; i < NUM_CARGO; i++) {
-		if (HASBIT(st->goods[i].acceptance_pickup, GoodsEntry::ACCEPTANCE)) mask |= 1 << i;
+		if (HasBit(st->goods[i].acceptance_pickup, GoodsEntry::ACCEPTANCE)) mask |= 1 << i;
 	}
 	return mask;
 }
-// Items contains the two cargo names that are to be accepted or rejected.
+/** Items contains the two cargo names that are to be accepted or rejected.
-// msg is the string id of the message to display.
+* msg is the string id of the message to display.
+*/
 static void ShowRejectOrAcceptNews(const Station *st, uint num_items, CargoID *cargo, StringID msg)
 {
 	for (uint i = 0; i < num_items; i++) {
 		SetDParam(i + 1, GetCargo(cargo[i])->name);
 	}
 	SetDParam(0, st->index);
 	AddNewsItem(msg, NEWS_FLAGS(NM_SMALL, NF_VIEWPORT | NF_TILE, NT_ACCEPTANCE, 0), st->xy, 0);
 }
-// Get a list of the cargo types being produced around the tile.
+/**
+* Get a list of the cargo types being produced around the tile (in a rectangle).
+* @param produced: Destination array of produced cargo
+* @param tile: Center of the search area
+* @param w: Width of the center
+* @param h: Height of the center
+* @param rad: Radius of the search area
+*/
 void GetProductionAroundTiles(AcceptedCargo produced, TileIndex tile,
 	int w, int h, int rad)
 {
 	memset(produced, 0, sizeof(AcceptedCargo));
 	int x = TileX(tile);
 	int y = TileY(tile);
-	// expand the region by rad tiles on each side
+	/* expand the region by rad tiles on each side
-	// while making sure that we remain inside the board.
+	 * while making sure that we remain inside the board. */
 	int x2 = min(x + w + rad, MapSizeX());
 	int x1 = max(x - rad, 0);
 	int y2 = min(y + h + rad, MapSizeY());
 	int y1 = max(y - rad, 0);
 	assert(w > 0);
 	assert(h > 0);
 	for (int yc = y1; yc != y2; yc++) {
 		for (int xc = x1; xc != x2; xc++) {
-			if (!(IS_INSIDE_1D(xc, x, w) && IS_INSIDE_1D(yc, y, h))) {
+			if (!(IsInsideBS(xc, x, w) && IsInsideBS(yc, y, h))) {
 				TileIndex tile = TileXY(xc, yc);
 				GetProducedCargoProc *gpc = _tile_type_procs[GetTileType(tile)]->get_produced_cargo_proc;
 				if (gpc != NULL) {
 					CargoID cargos[2] = { CT_INVALID, CT_INVALID };
 			}
 		}
 	}
 }
-// Get a list of the cargo types that are accepted around the tile.
+/**
+* Get a list of the cargo types that are accepted around the tile.
+* @param accepts: Destination array of accepted cargo
+* @param tile: Center of the search area
+* @param w: Width of the center
+* @param h: Height of the center
+* @param rad: Radius of the rectangular search area
+*/
 void GetAcceptanceAroundTiles(AcceptedCargo accepts, TileIndex tile,
 	int w, int h, int rad)
 {
 	memset(accepts, 0, sizeof(AcceptedCargo));
 	int x = TileX(tile);
 	int y = TileY(tile);
-	// expand the region by rad tiles on each side
+	/* expand the region by rad tiles on each side
-	// while making sure that we remain inside the board.
+	 * while making sure that we remain inside the board. */
 	int x2 = min(x + w + rad, MapSizeX());
 	int y2 = min(y + h + rad, MapSizeY());
 	int x1 = max(x - rad, 0);
 	int y1 = max(y - rad, 0);
 	if (rect->min_y > y) rect->min_y = y;
 	if (rect->max_x < x) rect->max_x = x;
 	if (rect->max_y < y) rect->max_y = y;
 }
-// Update the acceptance for a station.
+/** Update the acceptance for a station.
-// show_msg controls whether to display a message that acceptance was changed.
+* @param st Station to update
+* @param show_msg controls whether to display a message that acceptance was changed.
+*/
 static void UpdateStationAcceptance(Station *st, bool show_msg)
 {
-	// Don't update acceptance for a buoy
+	/* Don't update acceptance for a buoy */
 	if (st->IsBuoy()) return;
 	ottd_Rectangle rect;
 	rect.min_x = MapSizeX();
 	rect.min_y = MapSizeY();
 	rect.max_y = 0;
 	/* old accepted goods types */
 	uint old_acc = GetAcceptanceMask(st);
-	// Put all the tiles that span an area in the table.
+	/* Put all the tiles that span an area in the table. */
 	if (st->train_tile != 0) {
 		MergePoint(&rect, st->train_tile);
 		MergePoint(&rect,
 			st->train_tile + TileDiffXY(st->trainst_w - 1, st->trainst_h - 1)
 		);
 	for (const RoadStop *rs = st->truck_stops; rs != NULL; rs = rs->next) {
 		MergePoint(&rect, rs->xy);
 	}
-	// And retrieve the acceptance.
+	/* And retrieve the acceptance. */
 	AcceptedCargo accepts;
 	if (rect.max_x >= rect.min_x) {
 		GetAcceptanceAroundTiles(
 			accepts,
 			TileXY(rect.min_x, rect.min_y),
 		);
 	} else {
 		memset(accepts, 0, sizeof(accepts));
 	}
-	// Adjust in case our station only accepts fewer kinds of goods
+	/* Adjust in case our station only accepts fewer kinds of goods */
 	for (CargoID i = 0; i < NUM_CARGO; i++) {
 		uint amt = min(accepts[i], 15);
-		// Make sure the station can accept the goods type.
+		/* Make sure the station can accept the goods type. */
 		bool is_passengers = IsCargoInClass(i, CC_PASSENGERS);
 		if ((!is_passengers && !(st->facilities & (byte)~FACIL_BUS_STOP)) ||
 				(is_passengers && !(st->facilities & (byte)~FACIL_TRUCK_STOP)))
 			amt = 0;
 		SB(st->goods[i].acceptance_pickup, GoodsEntry::ACCEPTANCE, 1, amt >= 8);
 	}
-	// Only show a message in case the acceptance was actually changed.
+	/* Only show a message in case the acceptance was actually changed. */
 	uint new_acc = GetAcceptanceMask(st);
 	if (old_acc == new_acc)
 		return;
-	// show a message to report that the acceptance was changed?
+	/* show a message to report that the acceptance was changed? */
 	if (show_msg && st->owner == _local_player && st->facilities) {
 		/* List of accept and reject strings for different number of
 		 * cargo types */
 		static const StringID accept_msg[] = {
 			STR_3040_NOW_ACCEPTS,
 		uint num_acc = 0;
 		uint num_rej = 0;
 		/* Test each cargo type to see if its acceptange has changed */
 		for (CargoID i = 0; i < NUM_CARGO; i++) {
-			if (HASBIT(new_acc, i)) {
+			if (HasBit(new_acc, i)) {
-				if (!HASBIT(old_acc, i) && num_acc < lengthof(accepts)) {
+				if (!HasBit(old_acc, i) && num_acc < lengthof(accepts)) {
 					/* New cargo is accepted */
 					accepts[num_acc++] = i;
 				}
 			} else {
-				if (HASBIT(old_acc, i) && num_rej < lengthof(rejects)) {
+				if (HasBit(old_acc, i) && num_rej < lengthof(rejects)) {
 					/* Old cargo is no longer accepted */
 					rejects[num_rej++] = i;
 				}
 			}
 		}
 		/* Show news message if there are any changes */
 		if (num_acc > 0) ShowRejectOrAcceptNews(st, num_acc, accepts, accept_msg[num_acc - 1]);
 		if (num_rej > 0) ShowRejectOrAcceptNews(st, num_rej, rejects, reject_msg[num_rej - 1]);
 	}
-	// redraw the station view since acceptance changed
+	/* redraw the station view since acceptance changed */
 	InvalidateWindowWidget(WC_STATION_VIEW, st->index, 4);
 }
 static void UpdateStationSignCoord(Station *st)
 {
 	const StationRect *r = &st->rect;
-	if (r->IsEmpty()) return; // no tiles belong to this station
+	if (r->IsEmpty()) return; /* no tiles belong to this station */
-	// clamp sign coord to be inside the station rect
+	/* clamp sign coord to be inside the station rect */
-	st->xy = TileXY(clampu(TileX(st->xy), r->left, r->right), clampu(TileY(st->xy), r->top, r->bottom));
+	st->xy = TileXY(ClampU(TileX(st->xy), r->left, r->right), ClampU(TileY(st->xy), r->top, r->bottom));
 	UpdateStationVirtCoordDirty(st);
 }
-// This is called right after a station was deleted.
+/** This is called right after a station was deleted.
-// It checks if the whole station is free of substations, and if so, the station will be
+* It checks if the whole station is free of substations, and if so, the station will be
-// deleted after a little while.
+* deleted after a little while.
-static void DeleteStationIfEmpty(Station* st)
+* @param st Station
+*/
+static void DeleteStationIfEmpty(Station *st)
 {
 	if (st->facilities == 0) {
 		st->delete_ctr = 0;
 		RebuildStationLists();
 		InvalidateWindow(WC_STATION_LIST, st->owner);
 	UpdateStationSignCoord(st);
 }
 static CommandCost ClearTile_Station(TileIndex tile, byte flags);
-// Tries to clear the given area. Returns the cost in case of success.
+/** Tries to clear the given area.
-// Or an error code if it failed.
+* @param tile TileIndex to start check
+* @param w width of search area
+* @param h height of search area
+* @param flags operation to perform
+* @param invalid_dirs prohibited directions
+* @param station StationID to be queried and returned if available
+* @param check_clear if clearing tile should be performed (in wich case, cost will be added)
+* @return the cost in case of success, or an error code if it failed.
+*/
 CommandCost CheckFlatLandBelow(TileIndex tile, uint w, uint h, uint flags, uint32 invalid_dirs, StationID* station, const FSMportsSpec *fsmportspec, bool check_clear = true)
 {
 	CommandCost cost;
 	int allowed_z = -1;
 	byte layout_set = GB(invalid_dirs, 0, 3);
 			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
 		}
 		int flat_z = z;
 		if (tileh != SLOPE_FLAT) {
-			// need to check so the entrance to the station is not pointing at a slope.
+			/* need to check so the entrance to the station is not pointing at a slope. */
 			if ((invalid_dirs & 1 && !(tileh & SLOPE_NE) && (uint)w_cur == w) ||
 					(invalid_dirs & 2 && !(tileh & SLOPE_SE) && h_cur == 1) ||
 					(invalid_dirs & 4 && !(tileh & SLOPE_SW) && w_cur == 1) ||
 					(invalid_dirs & 8 && !(tileh & SLOPE_NW) && (uint)h_cur == h)) {
 				return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
 			if ((byte)*b++ == (byte)255) {
 				do_tile_test = false;
 			}
 		};
-		// get corresponding flat level and make sure that all parts of the station have the same level.
+		/* get corresponding flat level and make sure that all parts of the station have the same level. */
 		if (allowed_z == -1) {
-			// first tile
+			/* first tile */
 			allowed_z = flat_z;
 		} else if (do_tile_test && (allowed_z != flat_z)) {
 			/* test here whether build on height permitted. for FSM ports with layout masks, this is not an error
 			 * land checking is done in airport placement
 			 */
 					} else if (*station != st) {
 						return_cmd_error(STR_3006_ADJOINS_MORE_THAN_ONE_EXISTING);
 					}
 				}
 			} else if (check_clear) {
-				bool water_tile = IsClearWaterTile(tile_cur);
+				bool water_tile = IsWaterTile(tile_cur);
 				CommandCost ret = DoCommand(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 				if (CmdFailed(ret)) return ret;
 				if (!water_tile) cost.AddCost(ret);
 			}
 		}
 	TileIndex tile = fin[0];
 	uint w = fin[1];
 	uint h = fin[2];
 	if (_patches.nonuniform_stations) {
-		// determine new size of train station region..
+		/* determine new size of train station region.. */
 		int x = min(TileX(st->train_tile), TileX(tile));
 		int y = min(TileY(st->train_tile), TileY(tile));
 		curw = max(TileX(st->train_tile) + curw, TileX(tile) + w) - x;
 		curh = max(TileY(st->train_tile) + curh, TileY(tile) + h) - y;
 		tile = TileXY(x, y);
 	} else {
-		// check so the orientation is the same
+		/* check so the orientation is the same */
 		if (GetRailStationAxis(st->train_tile) != axis) {
 			_error_message = STR_306D_NONUNIFORM_STATIONS_DISALLOWED;
 			return false;
 		}
-		// check if the new station adjoins the old station in either direction
+		/* check if the new station adjoins the old station in either direction */
 		if (curw == w && st->train_tile == tile + TileDiffXY(0, h)) {
-			// above
+			/* above */
 			curh += h;
 		} else if (curw == w && st->train_tile == tile - TileDiffXY(0, curh)) {
-			// below
+			/* below */
 			tile -= TileDiffXY(0, curh);
 			curh += h;
 		} else if (curh == h && st->train_tile == tile + TileDiffXY(w, 0)) {
-			// to the left
+			/* to the left */
 			curw += w;
 		} else if (curh == h && st->train_tile == tile - TileDiffXY(curw, 0)) {
-			// to the right
+			/* to the right */
 			tile -= TileDiffXY(curw, 0);
 			curw += w;
 		} else {
 			_error_message = STR_306D_NONUNIFORM_STATIONS_DISALLOWED;
 			return false;
 		}
 	}
-	// make sure the final size is not too big.
+	/* make sure the final size is not too big. */
 	if (curw > _patches.station_spread || curh > _patches.station_spread) {
 		_error_message = STR_306C_STATION_TOO_SPREAD_OUT;
 		return false;
 	}
-	// now tile contains the new value for st->train_tile
+	/* now tile contains the new value for st->train_tile
-	// curw, curh contain the new value for width and height
+	 * curw, curh contain the new value for width and height */
 	fin[0] = tile;
 	fin[1] = curw;
 	fin[2] = curh;
 	return true;
 }
 		w_org = numtracks;
 	}
 	if (h_org > _patches.station_spread || w_org > _patches.station_spread) return CMD_ERROR;
-	// these values are those that will be stored in train_tile and station_platforms
+	/* these values are those that will be stored in train_tile and station_platforms */
 	uint finalvalues[3];
 	finalvalues[0] = tile_org;
 	finalvalues[1] = w_org;
 	finalvalues[2] = h_org;
-	// Make sure the area below consists of clear tiles. (OR tiles belonging to a certain rail station)
+	/* 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
+	/* 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
+	 * 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;
 	CommandCost cost(ret.GetCost() + (numtracks * _price.train_station_track + _price.train_station_length) * plat_len);
 	Station *st = NULL;
 	bool check_surrounding = true;
 	if (_patches.adjacent_stations) {
 		if (est != INVALID_STATION) {
-			if (HASBIT(p1, 24)) {
+			if (HasBit(p1, 24)) {
 				/* You can't build an adjacent station over the top of one that
 				 * already exists. */
 				return_cmd_error(STR_MUST_REMOVE_RAILWAY_STATION_FIRST);
 			} else {
 				/* Extend the current station, and don't check whether it will
 				check_surrounding = false;
 			}
 		} else {
 			/* There's no station here. Don't check the tiles surrounding this
 			 * one if the player wanted to build an adjacent station. */
-			if (HASBIT(p1, 24)) check_surrounding = false;
+			if (HasBit(p1, 24)) check_surrounding = false;
 		}
 	}
 	if (check_surrounding) {
-		// Make sure there are no similar stations around us.
+		/* Make sure there are no similar stations around us. */
 		st = GetStationAround(tile_org, w_org, h_org, est);
 		if (st == CHECK_STATIONS_ERR) return CMD_ERROR;
 	}
-	// See if there is a deleted station close to us.
+	/* See if there is a deleted station close to us. */
 	if (st == NULL) st = GetClosestStationFromTile(tile_org);
 	/* In case of new station if DC_EXEC is NOT set we still need to create the station
 	 * to test if everything is OK. In this case we need to delete it before return. */
 	AutoPtrT<Station> st_auto_delete;
 	if (st != NULL) {
-		// Reuse an existing station.
+		/* Reuse an existing station. */
 		if (st->owner != _current_player)
 			return_cmd_error(STR_3009_TOO_CLOSE_TO_ANOTHER_STATION);
 		if (st->train_tile != 0) {
-			// check if we want to expanding an already existing station?
+			/* check if we want to expanding an already existing station? */
 			if (_is_old_ai_player || !_patches.join_stations)
 				return_cmd_error(STR_3005_TOO_CLOSE_TO_ANOTHER_RAILROAD);
 			if (!CanExpandRailroadStation(st, finalvalues, axis))
 				return CMD_ERROR;
 		}
-		//XXX can't we pack this in the "else" part of the if above?
+		/* XXX can't we pack this in the "else" part of the if above? */
 		if (!st->rect.BeforeAddRect(tile_org, w_org, h_org, StationRect::ADD_TEST)) return CMD_ERROR;
 	} else {
 		/* allocate and initialize new station */
 		st = new Station(tile_org);
 		if (st == NULL) return_cmd_error(STR_3008_TOO_MANY_STATIONS_LOADING);
 		/* ensure that in case of error (or no DC_EXEC) the station gets deleted upon return */
 		st_auto_delete = st;
 		st->town = ClosestTownFromTile(tile_org, (uint)-1);
-		if (!GenerateStationName(st, tile_org, 0)) return CMD_ERROR;
+		if (!GenerateStationName(st, tile_org, STATIONNAMING_RAIL)) return CMD_ERROR;
 		if (IsValidPlayer(_current_player) && (flags & DC_EXEC) != 0) {
-			SETBIT(st->town->have_ratings, _current_player);
+			SetBit(st->town->have_ratings, _current_player);
 		}
 	}
 	/* Check if the given station class is valid */
 	if (GB(p2, 8, 8) >= STAT_CLASS_MAX) return CMD_ERROR;
 	if (statspec != NULL) {
 		/* Perform NewStation checks */
 		/* Check if the station size is permitted */
-		if (HASBIT(statspec->disallowed_platforms, numtracks - 1) || HASBIT(statspec->disallowed_lengths, plat_len - 1)) {
+		if (HasBit(statspec->disallowed_platforms, numtracks - 1) || HasBit(statspec->disallowed_lengths, plat_len - 1)) {
 			return CMD_ERROR;
 		}
 		/* Check if the station is buildable */
-		if (HASBIT(statspec->callbackmask, CBM_STATION_AVAIL) && GetStationCallback(CBID_STATION_AVAILABILITY, 0, 0, statspec, NULL, INVALID_TILE) == 0) {
+		if (HasBit(statspec->callbackmask, CBM_STATION_AVAIL) && GetStationCallback(CBID_STATION_AVAILABILITY, 0, 0, statspec, NULL, INVALID_TILE) == 0) {
 			return CMD_ERROR;
 		}
 	}
 	if (flags & DC_EXEC) {
 		TileIndexDiff tile_delta;
 		byte *layout_ptr;
 		byte numtracks_orig;
 		Track track;
-		// Now really clear the land below the station
+		/* Now really clear the land below the station
-		// It should never return CMD_ERROR.. but you never know ;)
+		 * It should never return CMD_ERROR.. but you never know ;)
-		//  (a bit strange function name for it, but it really does clear the land, when DC_EXEC is in flags)
+		 * (a bit strange function name for it, but it really does clear the land, when DC_EXEC is in flags) */
 		ret = CheckFlatLandBelow(tile_org, w_org, h_org, flags, 5 << axis, _patches.nonuniform_stations ? &est : NULL);
 		if (CmdFailed(ret)) return ret;
 		st->train_tile = finalvalues[0];
 		st->AddFacility(FACIL_TRAIN, finalvalues[0]);
 				SetStationTileRandomBits(tile, GB(Random(), 0, 4));
 				if (statspec != NULL) {
 					/* Use a fixed axis for GetPlatformInfo as our platforms / numtracks are always the right way around */
 					uint32 platinfo = GetPlatformInfo(AXIS_X, 0, plat_len, numtracks_orig, plat_len - w, numtracks_orig - numtracks, false);
-					uint16 callback = GetStationCallback(CBID_STATION_TILE_LAYOUT, platinfo, 0, statspec, st, tile);
+					/* As the station is not yet completely finished, the station does not yet exist. */
+					uint16 callback = GetStationCallback(CBID_STATION_TILE_LAYOUT, platinfo, 0, statspec, NULL, tile);
 					if (callback != CALLBACK_FAILED && callback < 8) SetStationGfx(tile, (callback & ~1) + axis);
 				}
 				tile += tile_delta;
 			} while (--w);
 	uint h = st->trainst_h;
 	TileIndex tile = st->train_tile;
 restart:
-	// too small?
+	/* too small? */
 	if (w != 0 && h != 0) {
-		// check the left side, x = constant, y changes
+		/* check the left side, x = constant, y changes */
 		for (uint i = 0; !st->TileBelongsToRailStation(tile + TileDiffXY(0, i));) {
-			// the left side is unused?
+			/* the left side is unused? */
 			if (++i == h) {
 				tile += TileDiffXY(1, 0);
 				w--;
 				goto restart;
 			}
 		}
-		// check the right side, x = constant, y changes
+		/* check the right side, x = constant, y changes */
 		for (uint i = 0; !st->TileBelongsToRailStation(tile + TileDiffXY(w - 1, i));) {
-			// the right side is unused?
+			/* the right side is unused? */
 			if (++i == h) {
 				w--;
 				goto restart;
 			}
 		}
-		// check the upper side, y = constant, x changes
+		/* check the upper side, y = constant, x changes */
 		for (uint i = 0; !st->TileBelongsToRailStation(tile + TileDiffXY(i, 0));) {
-			// the left side is unused?
+			/* the left side is unused? */
 			if (++i == w) {
 				tile += TileDiffXY(0, 1);
 				h--;
 				goto restart;
 			}
 		}
-		// check the lower side, y = constant, x changes
+		/* check the lower side, y = constant, x changes */
 		for (uint i = 0; !st->TileBelongsToRailStation(tile + TileDiffXY(i, h - 1));) {
-			// the left side is unused?
+			/* the left side is unused? */
 			if (++i == w) {
 				h--;
 				goto restart;
 			}
 		}
 			continue;
 		}
 		/* Check ownership of station */
 		Station *st = GetStationByTile(tile2);
-		if (_current_player != OWNER_WATER && (!CheckOwnership(st->owner) || !EnsureNoVehicle(tile2))) {
+		if (_current_player != OWNER_WATER && (!CheckOwnership(st->owner) || !EnsureNoVehicleOnGround(tile2))) {
 			continue;
 		}
 		/* If we reached here, the tile is valid so increase the quantity of tiles we will remove */
 		quantity++;
 			SetSignalsOnBothDir(tile2, track);
 			YapfNotifyTrackLayoutChange(tile2, track);
 			DeallocateSpecFromStation(st, specindex);
-			// now we need to make the "spanned" area of the railway station smaller if we deleted something at the edges.
+			/* now we need to make the "spanned" area of the railway station smaller
-			// we also need to adjust train_tile.
+			 * if we deleted something at the edges.
+			 * we also need to adjust train_tile. */
 			MakeRailwayStationAreaSmaller(st);
 			st->MarkTilesDirty(false);
 			UpdateStationSignCoord(st);
-			// if we deleted the whole station, delete the train facility.
+			/* if we deleted the whole station, delete the train facility. */
 			if (st->train_tile == 0) {
 				st->facilities &= ~FACIL_TRAIN;
 				UpdateStationVirtCoordDirty(st);
 				DeleteStationIfEmpty(st);
 			}
 	do {
 		int w_bak = w;
 		do {
 			// for nonuniform stations, only remove tiles that are actually train station tiles
 			if (st->TileBelongsToRailStation(tile)) {
-				if (!EnsureNoVehicle(tile))
+				if (!EnsureNoVehicleOnGround(tile))
 					return CMD_ERROR;
 				cost.AddCost(_price.remove_rail_station);
 				if (flags & DC_EXEC) {
 					Track track = GetRailStationTrack(tile);
 					DoClearSquare(tile);
 		MarkTileDirtyByTile(tile);
 		YapfNotifyTrackLayoutChange(tile, GetRailStationTrack(tile));
 		VehicleFromPos(tile, &tile, UpdateTrainPowerProc);
 	}
-	return CommandCost(_price.build_rail / 2);
+	return CommandCost(RailBuildCost(totype) / 2);
 }
 /**
 * @param truck_station Determines whether a stop is RoadStop::BUS or RoadStop::TRUCK
 * @param st The Station to do the whole procedure for
 *           bit 2..4: the roadtypes
 *           bit 5: allow stations directly adjacent to other stations.
 */
 CommandCost CmdBuildRoadStop(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	bool type = HASBIT(p2, 0);
+	bool type = HasBit(p2, 0);
-	bool is_drive_through = HASBIT(p2, 1);
+	bool is_drive_through = HasBit(p2, 1);
 	bool build_over_road  = is_drive_through && IsTileType(tile, MP_ROAD) && GetRoadTileType(tile) == ROAD_TILE_NORMAL;
 	bool town_owned_road  = build_over_road && IsTileOwner(tile, OWNER_TOWN);
 	RoadTypes rts = (RoadTypes)GB(p2, 2, 3);
-	if (rts == ROADTYPES_NONE || HASBIT(rts, ROADTYPE_HWAY)) return CMD_ERROR;
+	if (!AreValidRoadTypes(rts) || !HasRoadTypesAvail(_current_player, rts)) return CMD_ERROR;
 	/* Trams only have drive through stops */
-	if (!is_drive_through && HASBIT(rts, ROADTYPE_TRAM)) return CMD_ERROR;
+	if (!is_drive_through && HasBit(rts, ROADTYPE_TRAM)) return CMD_ERROR;
 	/* Saveguard the parameters */
 	if (!IsValidDiagDirection((DiagDirection)p1)) return CMD_ERROR;
 	/* If it is a drive-through stop check for valid axis */
 	if (is_drive_through && !IsValidAxis((Axis)p1)) return CMD_ERROR;
 		/* Don't allow building the roadstop when vehicles are already driving on it */
 		if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 		RoadTypes cur_rts = GetRoadTypes(tile);
-		if (GetRoadOwner(tile, ROADTYPE_ROAD) != OWNER_TOWN && HASBIT(cur_rts, ROADTYPE_ROAD) && !CheckOwnership(GetRoadOwner(tile, ROADTYPE_ROAD))) return CMD_ERROR;
+		if (GetRoadOwner(tile, ROADTYPE_ROAD) != OWNER_TOWN && HasBit(cur_rts, ROADTYPE_ROAD) && !CheckOwnership(GetRoadOwner(tile, ROADTYPE_ROAD))) return CMD_ERROR;
-		if (HASBIT(cur_rts, ROADTYPE_TRAM) && !CheckOwnership(GetRoadOwner(tile, ROADTYPE_TRAM))) return CMD_ERROR;
+		if (HasBit(cur_rts, ROADTYPE_TRAM) && !CheckOwnership(GetRoadOwner(tile, ROADTYPE_TRAM))) return CMD_ERROR;
 		/* Do not remove roadtypes! */
 		rts |= cur_rts;
 	}
 	cost = CheckFlatLandBelow(tile, 1, 1, flags, is_drive_through ? 5 << p1 : 1 << p1, NULL, false, !build_over_road);
 	if (CmdFailed(cost)) return cost;
 	Station *st = NULL;
-	if (!_patches.adjacent_stations || !HASBIT(p2, 5)) {
+	if (!_patches.adjacent_stations || !HasBit(p2, 5)) {
 		st = GetStationAround(tile, 1, 1, INVALID_STATION);
 		if (st == CHECK_STATIONS_ERR) return CMD_ERROR;
 	}
 	/* Find a station close to us */
 	if (st == NULL) st = GetClosestStationFromTile(tile);
-	//give us a road stop in the list, and check if something went wrong
+	/* give us a road stop in the list, and check if something went wrong */
 	RoadStop *road_stop = new RoadStop(tile);
 	if (road_stop == NULL) {
 		return_cmd_error(type ? STR_3008B_TOO_MANY_TRUCK_STOPS : STR_3008A_TOO_MANY_BUS_STOPS);
 	}
 			GetNumRoadStopsInStation(st, RoadStop::BUS) + GetNumRoadStopsInStation(st, RoadStop::TRUCK) >= RoadStop::LIMIT) {
 		return_cmd_error(type ? STR_3008B_TOO_MANY_TRUCK_STOPS : STR_3008A_TOO_MANY_BUS_STOPS);
 	}
 	/* In case of new station if DC_EXEC is NOT set we still need to create the station
-	* to test if everything is OK. In this case we need to delete it before return. */
+	 * to test if everything is OK. In this case we need to delete it before return. */
 	AutoPtrT<Station> st_auto_delete;
 	if (st != NULL) {
 		if (st->owner != _current_player) {
 			return_cmd_error(STR_3009_TOO_CLOSE_TO_ANOTHER_STATION);
 		/* ensure that in case of error (or no DC_EXEC) the new station gets deleted upon return */
 		st_auto_delete = st;
 		Town *t = st->town = ClosestTownFromTile(tile, (uint)-1);
-		if (!GenerateStationName(st, tile, 0)) return CMD_ERROR;
+		if (!GenerateStationName(st, tile, STATIONNAMING_ROAD)) return CMD_ERROR;
 		if (IsValidPlayer(_current_player) && (flags & DC_EXEC) != 0) {
-			SETBIT(t->have_ratings, _current_player);
+			SetBit(t->have_ratings, _current_player);
 		}
 		st->sign.width_1 = 0;
 	}
 	cost.AddCost((type) ? _price.build_truck_station : _price.build_bus_station);
 	if (flags & DC_EXEC) {
-		// Insert into linked list of RoadStops
+		/* Insert into linked list of RoadStops */
 		RoadStop **currstop = FindRoadStopSpot(type, st);
 		*currstop = road_stop;
-		//initialize an empty station
+		/*initialize an empty station */
 		st->AddFacility((type) ? FACIL_TRUCK_STOP : FACIL_BUS_STOP, tile);
 		st->rect.BeforeAddTile(tile, StationRect::ADD_TRY);
 		RoadStop::Type rs_type = type ? RoadStop::TRUCK : RoadStop::BUS;
 		rs_auto_delete.Detach();
 	}
 	return cost;
 }
-// Remove a bus station
+/** Remove a bus station
+* @param st Station to remove
+* @param flags operation to perform
+* @param tile TileIndex been queried
+* @return cost or failure of operation
+*/
 static CommandCost RemoveRoadStop(Station *st, uint32 flags, TileIndex tile)
 {
 	if (_current_player != OWNER_WATER && !CheckOwnership(st->owner)) {
 		return CMD_ERROR;
 	}
 		cur_stop = GetRoadStopByTile(tile, RoadStop::BUS);
 	}
 	assert(cur_stop != NULL);
-	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
+	if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		if (*primary_stop == cur_stop) {
-			// removed the first stop in the list
+			/* removed the first stop in the list */
 			*primary_stop = cur_stop->next;
-			// removed the only stop?
+			/* removed the only stop? */
 			if (*primary_stop == NULL) {
 				st->facilities &= (is_truck ? ~FACIL_TRUCK_STOP : ~FACIL_BUS_STOP);
 			}
 		} else {
-			// tell the predecessor in the list to skip this stop
+			/* tell the predecessor in the list to skip this stop */
 			RoadStop *pred = *primary_stop;
 			while (pred->next != cur_stop) pred = pred->next;
 			pred->next = cur_stop->next;
 		}
 	const uint32 airport_type_for_flat_check = (GB(p2, 8, 8) << 3) | layout_set;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* Check if a valid, buildable airport was chosen for construction */
-	//if (p1 > lengthof(_airport_sections) || !HASBIT(GetValidAirports(), p1)) return CMD_ERROR;
+	//if (p1 > lengthof(_airport_sections) || !HasBit(GetValidAirports(), p1)) return CMD_ERROR;
 	if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile))
 		return CMD_ERROR;
 	Town *t = ClosestTownFromTile(tile, (uint)-1);
 	/* Perform NewStation checks */
 	byte w = fsmportsspec->size_x[layout_set];
 	byte h = fsmportsspec->size_y[layout_set];
 	/* Check if the station is buildable */
-	if (HASBIT(fsmportsspec->callbackmask, CBM_STATION_AVAIL) && GetFSMportsCallback(CBID_STATION_AVAILABILITY, 0, 0, fsmportsspec, NULL, INVALID_TILE) == 0) {
+	if (HasBit(fsmportsspec->callbackmask, CBM_STATION_AVAIL) && GetFSMportsCallback(CBID_STATION_AVAILABILITY, 0, 0, fsmportsspec, NULL, INVALID_TILE) == 0) {
 		return CMD_ERROR;
 	}
-	if (!_patches.adjacent_stations || !HASBIT(p1, 24)) {
+	if (!_patches.adjacent_stations || !HasBit(p1, 24)) {
 		st = GetStationAround(tile, w, h, INVALID_STATION);
 		if (st == CHECK_STATIONS_ERR) return CMD_ERROR;
 	}
 	/* Find a station close to us */
 		st_auto_delete = st;
 		st->town = t;
 		if (IsValidPlayer(_current_player) && (flags & DC_EXEC) != 0) {
-			SETBIT(t->have_ratings, _current_player);
+			SetBit(t->have_ratings, _current_player);
 		}
 		st->sign.width_1 = 0;
 		/* If only helicopters may use the airport generate a helicopter related (5)
 		 * station name, otherwise generate a normal airport name (1) */
-		if (!GenerateStationName(st, tile, !(fsmportsspec->flags & AirportFTAClass::AIRPLANES) ? 5 : 1)) {
+		if (!GenerateStationName(st, tile, !(fsmportsspec->flags & AirportFTAClass::AIRPLANES) ? STATIONNAMING_HELIPORT : STATIONNAMING_AIRPORT)) {
 			return CMD_ERROR;
 		}
 	}
 	flags |= DC_NO_WATER;
 		const byte *mask_ptr = fsmportsspec->layout_mask[layout_set] + 2;  // width*length flagbytes. Also skip orientation and "filler" byte
 		BEGIN_TILE_LOOP(tile_cur, w, h, tile) {
 			byte mask = *mask_ptr++;
 			if (mask & 0x80) {
 				/* do water tests */
-				if (IsClearWaterTile(tile_cur)) {
+				if (IsWaterTile(tile_cur)) {
 					flags &= ~DC_NO_WATER;
 					st->FSMport_flood_protected = true;
 				} else {
 					_error_message = STR_304B_SITE_UNSUITABLE;
 					return CMD_ERROR;
 				}
-			} else if (IsClearWaterTile(tile_cur)) {
+			} else if (IsWaterTile(tile_cur)) {
 				/* tile should be land, but is water */
 				_error_message = STR_3807_CAN_T_BUILD_ON_WATER;
 				return CMD_ERROR;
 			}
 			//TODO: add height comparison & validation code here
 */
 CommandCost CmdBuildBuoy(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
-	if (!IsClearWaterTile(tile) || tile == 0) return_cmd_error(STR_304B_SITE_UNSUITABLE);
+	if (!IsWaterTile(tile) || tile == 0) return_cmd_error(STR_304B_SITE_UNSUITABLE);
 	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
 	/* allocate and initialize new station */
 	Station *st = new Station(tile);
 	if (st == NULL) return_cmd_error(STR_3008_TOO_MANY_STATIONS_LOADING);
 	AutoPtrT<Station> st_auto_delete(st);
 	st->town = ClosestTownFromTile(tile, (uint)-1);
 	st->sign.width_1 = 0;
-	if (!GenerateStationName(st, tile, 4)) return CMD_ERROR;
+	if (!GenerateStationName(st, tile, STATIONNAMING_BUOY)) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		st->dock_tile = tile;
 		st->facilities |= FACIL_DOCK;
 		/* Buoys are marked in the Station struct by this flag. Yes, it is this
 	if (!IsValidPlayer(_current_player))  return_cmd_error(INVALID_STRING_ID);
 	TileIndex tile = st->dock_tile;
 	if (CheckShipsOnBuoy(st))   return_cmd_error(STR_BUOY_IS_IN_USE);
-	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
+	if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		st->dock_tile = 0;
 		/* Buoys are marked in the Station struct by this flag. Yes, it is this
 		 * braindead.. */
 		st->had_vehicle_of_type &= ~HVOT_BUOY;
 		/* We have to set the water tile's state to the same state as before the
 		 * buoy was placed. Otherwise one could plant a buoy on a canal edge,
 		 * remove it and flood the land (if the canal edge is at level 0) */
-		Owner o = GetTileOwner(tile);
+		MakeWaterOrCanalDependingOnSurroundings(tile, GetTileOwner(tile));
-		if (o == OWNER_WATER) {
-			MakeWater(tile);
-		} else {
-			MakeCanal(tile, o);
-		}
 		MarkTileDirtyByTile(tile);
 		UpdateStationVirtCoordDirty(st);
 		DeleteStationIfEmpty(st);
 	}
 	}
 	/* middle */
 	Station *st = NULL;
-	if (!_patches.adjacent_stations || !HASBIT(p1, 0)) {
+	if (!_patches.adjacent_stations || !HasBit(p1, 0)) {
 		st = GetStationAround(
 				tile + ToTileIndexDiff(_dock_tileoffs_chkaround[direction]),
 				_dock_w_chk[direction], _dock_h_chk[direction], INVALID_STATION);
 		if (st == CHECK_STATIONS_ERR) return CMD_ERROR;
 	}
 	/* Find a station close to us */
 	if (st == NULL) st = GetClosestStationFromTile(tile);
 	/* In case of new station if DC_EXEC is NOT set we still need to create the station
-	* to test if everything is OK. In this case we need to delete it before return. */
+	 * to test if everything is OK. In this case we need to delete it before return. */
 	AutoPtrT<Station> st_auto_delete;
 	if (st != NULL) {
 		if (st->owner != _current_player)
 			return_cmd_error(STR_3009_TOO_CLOSE_TO_ANOTHER_STATION);
 		st_auto_delete = st;
 		Town *t = st->town = ClosestTownFromTile(tile, (uint)-1);
 		if (IsValidPlayer(_current_player) && (flags & DC_EXEC) != 0) {
-			SETBIT(t->have_ratings, _current_player);
+			SetBit(t->have_ratings, _current_player);
 		}
 		st->sign.width_1 = 0;
-		if (!GenerateStationName(st, tile, 3)) return CMD_ERROR;
+		if (!GenerateStationName(st, tile, STATIONNAMING_DOCK)) return CMD_ERROR;
 	}
 	if (flags & DC_EXEC) {
 		st->dock_tile = tile;
 		st->AddFacility(FACIL_DOCK, tile);
 	if (!CheckOwnership(st->owner)) return CMD_ERROR;
 	TileIndex tile1 = st->dock_tile;
 	TileIndex tile2 = tile1 + TileOffsByDiagDir(GetDockDirection(tile1));
-	if (!EnsureNoVehicle(tile1)) return CMD_ERROR;
+	if (!EnsureNoVehicleOnGround(tile1)) return CMD_ERROR;
-	if (!EnsureNoVehicle(tile2)) return CMD_ERROR;
+	if (!EnsureNoVehicleOnGround(tile2)) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		DoClearSquare(tile1);
-		MakeWater(tile2);
+		MakeWaterOrCanalDependingOnSurroundings(tile2, st->owner);
 		st->rect.AfterRemoveTile(st, tile1);
 		st->rect.AfterRemoveTile(st, tile2);
 		MarkTileDirtyByTile(tile2);
 const DrawTileSprites *GetStationTileLayout(StationType st, byte gfx)
 {
 	return &_station_display_datas[st][gfx];
 }
-/* For drawing canal edges on buoys */
-extern void DrawCanalWater(TileIndex tile);
 static void DrawTile_Station(TileInfo *ti)
 {
 	const DrawTileSprites *t = NULL;
 	RailType railtype;
 	SpriteID palette;
 	if (IsValidPlayer(owner)) {
 		palette = PLAYER_SPRITE_COLOR(owner);
 	} else {
-		// Some stations are not owner by a player, namely oil rigs
+		/* Some stations are not owner by a player, namely oil rigs */
 		palette = PALETTE_TO_GREY;
 	}
-	// don't show foundation for docks
+	/* don't show foundation for docks */
 	if (ti->tileh != SLOPE_FLAT && !IsDock(ti->tile))
 		DrawFoundation(ti, FOUNDATION_LEVELED);
 	if (IsCustomStationSpecIndex(ti->tile)) {
-		// look for customization
+		/* look for customization */
 		st = GetStationByTile(ti->tile);
 		int specindex = GetCustomStationSpecIndex(ti->tile);
 		FSMport = IsCustomFSMportsSpecIndex(ti->tile);
 		if (FSMport) {
 			fsmportspec = st->fsmportsspeclist[specindex].spec;
 		if (statspec != NULL) {
 			uint tile = GetStationGfx(ti->tile);
 			relocation = GetCustomStationRelocation(statspec, st, ti->tile);
-			if (HASBIT(statspec->callbackmask, CBM_STATION_SPRITE_LAYOUT)) {
+			if (HasBit(statspec->callbackmask, CBM_STATION_SPRITE_LAYOUT)) {
 				uint16 callback = GetStationCallback(CBID_STATION_SPRITE_LAYOUT, 0, 0, statspec, st, ti->tile);
 				if (callback != CALLBACK_FAILED) tile = (callback & ~1) + GetRailStationAxis(ti->tile);
 			}
 			/* Ensure the chosen tile layout is valid for this custom station */
 	}
 	if (t == NULL || t->seq == NULL) t = &_station_display_datas[GetStationType(ti->tile)][GetStationGfx(ti->tile)];
 	SpriteID image = t->ground_sprite;
-	if (HASBIT(image, SPRITE_MODIFIER_USE_OFFSET)) {
+	if (HasBit(image, SPRITE_MODIFIER_USE_OFFSET)) {
 		image += (FSMport)? GetCustomFSMportsGroundRelocation(fsmportspec, st, ti->tile) : GetCustomStationGroundRelocation(statspec, st, ti->tile);
 		image += rti->custom_ground_offset;
 	} else {
 		image += rti->total_offset;
 	}
 	// if ground tile 0x0F8D, but tile is desert/snow, then choose desert/snow graphic
 	if ((image == 0x0F8D) && (GetTropicZone(ti->tile) == TROPICZONE_DESERT))
 		image = 0x11C6;  // snow tile (arctic) or desert tile (tropical)
-	// station_land array has been increased from 82 elements to 114
+	/* station_land array has been increased from 82 elements to 114
-	// but this is something else. If AI builds station with 114 it looks all weird
+	 * but this is something else. If AI builds station with 114 it looks all weird */
-	DrawGroundSprite(image, HASBIT(image, PALETTE_MODIFIER_COLOR) ? palette : PAL_NONE);
+	DrawGroundSprite(image, HasBit(image, PALETTE_MODIFIER_COLOR) ? palette : PAL_NONE);
 	if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC && IsStationTileElectrifiable(ti->tile)) DrawCatenary(ti);
-	if (HASBIT(roadtypes, ROADTYPE_TRAM)) {
+	if (HasBit(roadtypes, ROADTYPE_TRAM)) {
 		Axis axis = GetRoadStopDir(ti->tile) == DIAGDIR_NE ? AXIS_X : AXIS_Y;
-		DrawGroundSprite((HASBIT(roadtypes, ROADTYPE_ROAD) ? SPR_TRAMWAY_OVERLAY : SPR_TRAMWAY_TRAM) + (axis ^ 1), PAL_NONE);
+		DrawGroundSprite((HasBit(roadtypes, ROADTYPE_ROAD) ? SPR_TRAMWAY_OVERLAY : SPR_TRAMWAY_TRAM) + (axis ^ 1), PAL_NONE);
 		DrawTramCatenary(ti, axis == AXIS_X ? ROAD_X : ROAD_Y);
 	}
-	if (IsBuoyTile(ti->tile) && (ti->z != 0 || !IsTileOwner(ti->tile, OWNER_WATER))) DrawCanalWater(ti->tile);
+	if (IsCanalBuoyTile(ti->tile)) DrawCanalWater(ti->tile);
 	const DrawTileSeqStruct *dtss;
 	foreach_draw_tile_seq(dtss, t->seq) {
 		image = dtss->image;
-		if (relocation == 0 || HASBIT(image, SPRITE_MODIFIER_USE_OFFSET)) {
+		if (relocation == 0 || HasBit(image, SPRITE_MODIFIER_USE_OFFSET)) {
 			image += rti->total_offset;
 		} else {
 			image += relocation;
 		}
 		SpriteID pal;
-		if (!HASBIT(_transparent_opt, TO_BUILDINGS) && HASBIT(image, PALETTE_MODIFIER_COLOR)) {
+		if (!IsTransparencySet(TO_BUILDINGS) && HasBit(image, PALETTE_MODIFIER_COLOR)) {
 			pal = palette;
 		} else {
 			pal = dtss->pal;
 		}
 			AddSortableSpriteToDraw(
 				image, pal,
 				ti->x + dtss->delta_x, ti->y + dtss->delta_y,
 				dtss->size_x, dtss->size_y,
 				dtss->size_z, ti->z + dtss->delta_z,
-				HASBIT(_transparent_opt, TO_BUILDINGS)
+				IsTransparencySet(TO_BUILDINGS)
 			);
 		} else {
-			AddChildSpriteScreen(image, pal, dtss->delta_x, dtss->delta_y, HASBIT(_transparent_opt, TO_BUILDINGS));
+			AddChildSpriteScreen(image, pal, dtss->delta_x, dtss->delta_y, IsTransparencySet(TO_BUILDINGS));
 		}
 	}
 }
 void StationPickerDrawSprite(int x, int y, StationType st, RailType railtype, RoadType roadtype, int image)
 	const RailtypeInfo *rti = GetRailTypeInfo(railtype);
 	SpriteID pal = PLAYER_SPRITE_COLOR(_local_player);
 	const DrawTileSprites *t = &_station_display_datas[st][image];
 	SpriteID img = t->ground_sprite;
-	DrawSprite(img + rti->total_offset, HASBIT(img, PALETTE_MODIFIER_COLOR) ? pal : PAL_NONE, x, y);
+	DrawSprite(img + rti->total_offset, HasBit(img, PALETTE_MODIFIER_COLOR) ? pal : PAL_NONE, x, y);
 	if (roadtype == ROADTYPE_TRAM) {
 		DrawSprite(SPR_TRAMWAY_TRAM + (t->ground_sprite == SPR_ROAD_PAVED_STRAIGHT_X ? 1 : 0), PAL_NONE, x, y);
 	}
 				return TrackToTrackBits(GetRailStationTrack(tile)) * 0x101;
 			}
 			break;
 		case TRANSPORT_WATER:
-			// buoy is coded as a station, it is always on open water
+			/* buoy is coded as a station, it is always on open water */
 			if (IsBuoy(tile)) {
 				TrackBits ts = TRACK_BIT_ALL;
-				// remove tracks that connect NE map edge
+				/* remove tracks that connect NE map edge */
 				if (TileX(tile) == 0) ts &= ~(TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT);
-				// remove tracks that connect NW map edge
+				/* remove tracks that connect NW map edge */
 				if (TileY(tile) == 0) ts &= ~(TRACK_BIT_Y | TRACK_BIT_LEFT | TRACK_BIT_UPPER);
 				return uint32(ts) * 0x101;
 			}
 			break;
 }
 static void TileLoop_Station(TileIndex tile)
 {
-	// FIXME -- GetTileTrackStatus_Station -> animated stationtiles
+	/* FIXME -- GetTileTrackStatus_Station -> animated stationtiles
-	// hardcoded.....not good
+	 * hardcoded.....not good */
 	switch (GetStationType(tile)) {
 		case STATION_AIRPORT:
 			//TODO: animated tiles from newgrf
 			//switch (GetStationGfx(tile)) {
 			//	case GFX_RADAR_LARGE_FIRST:
 					if (!rs->IsFreeBay(side)) return VETSB_CANNOT_ENTER;
 					/* Check if the vehicle is stopping at this road stop */
 					if (GetRoadStopType(tile) == (IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK) &&
 							v->current_order.dest == GetStationIndex(tile)) {
-						SETBIT(v->u.road.state, RVS_IS_STOPPING);
+						SetBit(v->u.road.state, RVS_IS_STOPPING);
 						rs->AllocateDriveThroughBay(side);
 					}
 					/* Indicate if vehicle is using second bay. */
-					if (side == 1) SETBIT(v->u.road.state, RVS_USING_SECOND_BAY);
+					if (side == 1) SetBit(v->u.road.state, RVS_USING_SECOND_BAY);
 					/* Indicate a drive-through stop */
-					SETBIT(v->u.road.state, RVS_IN_DT_ROAD_STOP);
+					SetBit(v->u.road.state, RVS_IN_DT_ROAD_STOP);
 					return VETSB_CONTINUE;
 				}
 				/* For normal (non drive-through) road stops */
 				/* Check if station is busy or if there are no free bays or whether it is a articulated vehicle. */
 				if (rs->IsEntranceBusy() || !rs->HasFreeBay() || RoadVehHasArticPart(v)) return VETSB_CANNOT_ENTER;
-				SETBIT(v->u.road.state, RVS_IN_ROAD_STOP);
+				SetBit(v->u.road.state, RVS_IN_ROAD_STOP);
 				/* Allocate a bay and update the road state */
 				uint bay_nr = rs->AllocateBay();
 				SB(v->u.road.state, RVS_USING_SECOND_BAY, 1, bay_nr);
 	GoodsEntry *ge = st->goods;
 	do {
 		/* Slowly increase the rating back to his original level in the case we
 		 *  didn't deliver cargo yet to this station. This happens when a bribe
 		 *  failed while you didn't moved that cargo yet to a station. */
-		if (!HASBIT(ge->acceptance_pickup, GoodsEntry::PICKUP) && ge->rating < INITIAL_STATION_RATING) {
+		if (!HasBit(ge->acceptance_pickup, GoodsEntry::PICKUP) && ge->rating < INITIAL_STATION_RATING) {
 			ge->rating++;
 		}
 		/* Only change the rating if we are moving this cargo */
-		if (HASBIT(ge->acceptance_pickup, GoodsEntry::PICKUP)) {
+		if (HasBit(ge->acceptance_pickup, GoodsEntry::PICKUP)) {
 			byte_inc_sat(&ge->days_since_pickup);
 			int rating = 0;
 			{
 				(rating += 10, age >= 2) ||
 				(rating += 10, age >= 1) ||
 				(rating += 13, true);
 			}
-			if (IsValidPlayer(st->owner) && HASBIT(st->town->statues, st->owner)) rating += 26;
+			if (IsValidPlayer(st->owner) && HasBit(st->town->statues, st->owner)) rating += 26;
 			{
 				byte days = ge->days_since_pickup;
-				if (st->last_vehicle_type == VEH_SHIP)
+				if (st->last_vehicle_type == VEH_SHIP) days >>= 2;
-							days >>= 2;
 				(days > 21) ||
 				(rating += 25, days > 12) ||
 				(rating += 25, days > 6) ||
 				(rating += 45, days > 3) ||
 				(rating += 35, true);
 			(rating += 10, true);
 			{
 				int or_ = ge->rating; // old rating
-				// only modify rating in steps of -2, -1, 0, 1 or 2
+				/* only modify rating in steps of -2, -1, 0, 1 or 2 */
-				ge->rating = rating = or_ + clamp(clamp(rating, 0, 255) - or_, -2, 2);
+				ge->rating = rating = or_ + Clamp(Clamp(rating, 0, 255) - or_, -2, 2);
-				// if rating is <= 64 and more than 200 items waiting, remove some random amount of goods from the station
+				/* if rating is <= 64 and more than 200 items waiting,
+				 * remove some random amount of goods from the station */
 				if (rating <= 64 && waiting >= 200) {
 					int dec = Random() & 0x1F;
 					if (waiting < 400) dec &= 7;
 					waiting -= dec + 1;
 					waiting_changed = true;
 				}
-				// if rating is <= 127 and there are any items waiting, maybe remove some goods.
+				/* if rating is <= 127 and there are any items waiting, maybe remove some goods. */
 				if (rating <= 127 && waiting != 0) {
 					uint32 r = Random();
 					if (rating <= (int)GB(r, 0, 7)) {
 						/* Need to have int, otherwise it will just overflow etc. */
 						waiting = max((int)waiting - (int)GB(r, 8, 2) - 1, 0);
 				DistanceManhattan(tile, st->xy) <= radius) {
 			for (CargoID i = 0; i < NUM_CARGO; i++) {
 				GoodsEntry* ge = &st->goods[i];
 				if (ge->acceptance_pickup != 0) {
-					ge->rating = clamp(ge->rating + amount, 0, 255);
+					ge->rating = Clamp(ge->rating + amount, 0, 255);
 				}
 			}
 		}
 	}
 }
 static void UpdateStationWaiting(Station *st, CargoID type, uint amount)
 {
 	st->goods[type].cargo.Append(new CargoPacket(st->index, amount));
-	SETBIT(st->goods[type].acceptance_pickup, GoodsEntry::PICKUP);
+	SetBit(st->goods[type].acceptance_pickup, GoodsEntry::PICKUP);
 	InvalidateWindow(WC_STATION_VIEW, st->index);
 	st->MarkTilesDirty(true);
 }
 	}
 	return CommandCost();
 }
+/**
-uint MoveGoodsToStation(TileIndex tile, int w, int h, CargoID type, uint amount)
+* Find all (non-buoy) stations around an industry tile
-{
+*
-	Station* around[8];
+* @param tile: Center tile to search from
+* @param w: Width of the center
-	for (uint i = 0; i < lengthof(around); i++) around[i] = NULL;
+* @param h: Height of the center
+*
-	int w_prod; //width and height of the "producer" of the cargo
+* @return: Set of found stations
+*/
+StationSet FindStationsAroundIndustryTile(TileIndex tile, int w, int h)
+{
+	StationSet station_set;
+	int w_prod; // width and height of the "producer" of the cargo
 	int h_prod;
 	int max_rad;
 	if (_patches.modified_catchment) {
 		w_prod = w;
 		h_prod = h;
 		cur_tile = TILE_MASK(cur_tile);
 		if (!IsTileType(cur_tile, MP_STATION)) continue;
 		Station *st = GetStationByTile(cur_tile);
-		for (uint i = 0; i != lengthof(around); i++) {
+		if (st->IsBuoy()) continue; // bouys don't accept cargo
-			if (around[i] == NULL) {
-				if (!st->IsBuoy() &&
-						(st->town->exclusive_counter == 0 || st->town->exclusivity == st->owner) && // check exclusive transport rights
+		if (_patches.modified_catchment) {
-						st->goods[type].rating != 0 && // when you've got the lowest rating you can get, it's better not to give cargo anymore
+			/* min and max coordinates of the producer relative */
-						(!_patches.selectgoods || st->goods[type].last_speed != 0) && // we are servicing the station (or cargo is dumped on all stations)
+			const int x_min_prod = max_rad + 1;
-						((st->facilities & ~FACIL_BUS_STOP)   != 0 || IsCargoInClass(type, CC_PASSENGERS)) && // if we have other fac. than a bus stop, or the cargo is passengers
+			const int x_max_prod = max_rad + w_prod;
-						((st->facilities & ~FACIL_TRUCK_STOP) != 0 || !IsCargoInClass(type, CC_PASSENGERS))) { // if we have other fac. than a cargo bay or the cargo is not passengers
+			const int y_min_prod = max_rad + 1;
-					if (_patches.modified_catchment) {
+			const int y_max_prod = max_rad + h_prod;
-						// min and max coordinates of the producer relative
-						const int x_min_prod = max_rad + 1;
+			int rad = FindCatchmentRadius(st);
-						const int x_max_prod = max_rad + w_prod;
-						const int y_min_prod = max_rad + 1;
+			int x_dist = min(w_cur - x_min_prod, x_max_prod - w_cur);
-						const int y_max_prod = max_rad + h_prod;
+			if (w_cur < x_min_prod) {
+				x_dist = x_min_prod - w_cur;
-						int rad = FindCatchmentRadius(st);
+			} else if (w_cur > x_max_prod) {
+				x_dist = w_cur - x_max_prod;
-						int x_dist = min(w_cur - x_min_prod, x_max_prod - w_cur);
+			}
-						if (w_cur < x_min_prod) {
-							x_dist = x_min_prod - w_cur;
+			if (x_dist > rad) continue;
-						} else if (w_cur > x_max_prod) {
-							x_dist = w_cur - x_max_prod;
+			int y_dist = min(h_cur - y_min_prod, y_max_prod - h_cur);
-						}
+			if (h_cur < y_min_prod) {
+				y_dist = y_min_prod - h_cur;
-						int y_dist = min(h_cur - y_min_prod, y_max_prod - h_cur);
+			} else if (h_cur > y_max_prod) {
-						if (h_cur < y_min_prod) {
+				y_dist = h_cur - y_max_prod;
-							y_dist = y_min_prod - h_cur;
+			}
-						} else if (h_cur > y_max_prod) {
-							y_dist = h_cur - y_max_prod;
+			if (y_dist > rad) continue;
-						}
+		}
-						if (x_dist > rad || y_dist > rad) break;
+		/* Insert the station in the set. This will fail if it has
-					}
+		 * already been added.
+		 */
-					around[i] = st;
+		station_set.insert(st);
-				}
-				break;
-			} else if (around[i] == st) {
-				break;
-			}
-		}
 	END_TILE_LOOP(cur_tile, w, h, tile - TileDiffXY(max_rad, max_rad))
+	return station_set;
+}
+uint MoveGoodsToStation(TileIndex tile, int w, int h, CargoID type, uint amount)
+{
+	Station *st1 = NULL;	// Station with best rating
+	Station *st2 = NULL;	// Second best station
+	uint best_rating1 = 0;	// rating of st1
+	uint best_rating2 = 0;	// rating of st2
+	StationSet all_stations = FindStationsAroundIndustryTile(tile, w, h);
+	for (StationSet::iterator st_iter = all_stations.begin(); st_iter != all_stations.end(); ++st_iter) {
+		Station *st = *st_iter;
+		/* Is the station reserved exclusively for somebody else? */
+		if (st->town->exclusive_counter > 0 && st->town->exclusivity != st->owner) continue;
+		if (st->goods[type].rating == 0) continue; // Lowest possible rating, better not to give cargo anymore
+		if (_patches.selectgoods && st->goods[type].last_speed == 0) continue; // Selectively servicing stations, and not this one
+		if (IsCargoInClass(type, CC_PASSENGERS)) {
+			if (st->facilities == FACIL_TRUCK_STOP) continue; // passengers are never served by just a truck stop
+		} else {
+			if (st->facilities == FACIL_BUS_STOP) continue; // non-passengers are never served by just a bus stop
+		}
+		/* This station can be used, add it to st1/st2 */
+		if (st1 == NULL || st->goods[type].rating >= best_rating1) {
+			st2 = st1; best_rating2 = best_rating1; st1 = st; best_rating1 = st->goods[type].rating;
+		} else if (st2 == NULL || st->goods[type].rating >= best_rating2) {
+			st2 = st; best_rating2 = st->goods[type].rating;
+		}
+	}
 	/* no stations around at all? */
-	if (around[0] == NULL) return 0;
+	if (st1 == NULL) return 0;
-	if (around[1] == NULL) {
+	if (st2 == NULL) {
 		/* only one station around */
-		uint moved = (amount * around[0]->goods[type].rating >> 8) + 1;
+		uint moved = amount * best_rating1 / 256 + 1;
-		UpdateStationWaiting(around[0], type, moved);
+		UpdateStationWaiting(st1, type, moved);
 		return moved;
 	}
-	/* several stations around, find the two with the highest rating */
+	/* several stations around, the best two (highest rating) are in st1 and st2 */
-	Station *st1 = NULL;
-	Station *st2 = NULL;
-	uint best_rating  = 0;
-	uint best_rating2 = 0;
-	for (uint i = 0; i != lengthof(around) && around[i] != NULL; i++) {
-		if (around[i]->goods[type].rating >= best_rating) {
-			best_rating2 = best_rating;
-			st2 = st1;
-			best_rating = around[i]->goods[type].rating;
-			st1 = around[i];
-		} else if (around[i]->goods[type].rating >= best_rating2) {
-			best_rating2 = around[i]->goods[type].rating;
-			st2 = around[i];
-		}
-	}
 	assert(st1 != NULL);
 	assert(st2 != NULL);
-	assert(best_rating != 0 || best_rating2 != 0);
+	assert(best_rating1 != 0 || best_rating2 != 0);
 	/* the 2nd highest one gets a penalty */
 	best_rating2 >>= 1;
 	/* amount given to station 1 */
-	uint t = (best_rating * (amount + 1)) / (best_rating + best_rating2);
+	uint t = (best_rating1 * (amount + 1)) / (best_rating1 + best_rating2);
 	uint moved = 0;
 	if (t != 0) {
-		moved = t * best_rating / 256 + 1;
+		moved = t * best_rating1 / 256 + 1;
 		amount -= t;
 		UpdateStationWaiting(st1, type, moved);
 	}
 	if (amount != 0) {
 	if (st == NULL) {
 		DEBUG(misc, 0, "Can't allocate station for oilrig at 0x%X, reverting to oilrig only", tile);
 		return;
 	}
-	if (!GenerateStationName(st, tile, 2)) {
-		DEBUG(misc, 0, "Can't allocate station-name for oilrig at 0x%X, reverting to oilrig only", tile);
-		return;
-	}
 	st->town = ClosestTownFromTile(tile, (uint)-1);
 	st->sign.width_1 = 0;
+	if (!GenerateStationName(st, tile, STATIONNAMING_OILRIG)) {
+		DEBUG(misc, 0, "Can't allocate station-name for oilrig at 0x%X, reverting to oilrig only", tile);
+		delete st;
+		return;
+	}
 	MakeOilrig(tile, st->index);
 	st->owner = OWNER_NONE;
 	st->airport_flags.ResetAll();
 {
 	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);
+			case STATION_TRUCK:   return_cmd_error(HasBit(GetRoadTypes(tile), ROADTYPE_TRAM) ? STR_3047_MUST_DEMOLISH_CARGO_TRAM_STATION : STR_3047_MUST_DEMOLISH_TRUCK_STATION);
-			case STATION_BUS:     return_cmd_error(HASBIT(GetRoadTypes(tile), ROADTYPE_TRAM) ? STR_3046_MUST_DEMOLISH_PASSENGER_TRAM_STATION : STR_3046_MUST_DEMOLISH_BUS_STATION);
+			case STATION_BUS:     return_cmd_error(HasBit(GetRoadTypes(tile), ROADTYPE_TRAM) ? STR_3046_MUST_DEMOLISH_PASSENGER_TRAM_STATION : STR_3046_MUST_DEMOLISH_BUS_STATION);
 			case STATION_BUOY:    return_cmd_error(STR_306A_BUOY_IN_THE_WAY);
 			case STATION_DOCK:    return_cmd_error(STR_304D_MUST_DEMOLISH_DOCK_FIRST);
 			case STATION_OILRIG:
 				SetDParam(0, STR_4807_OIL_RIG);
 				return_cmd_error(STR_4800_IN_THE_WAY);
 	SLE_CONDVAR(Station, dock_tile,                  SLE_UINT32,                  6, SL_MAX_VERSION),
 	    SLE_REF(Station, town,                       REF_TOWN),
 	    SLE_VAR(Station, trainst_w,                  SLE_UINT8),
 	SLE_CONDVAR(Station, trainst_h,                  SLE_UINT8,                   2, SL_MAX_VERSION),
-	// alpha_order was stored here in savegame format 0 - 3
+	/* alpha_order was stored here in savegame format 0 - 3 */
 	SLE_CONDNULL(1, 0, 3),
 	    SLE_VAR(Station, string_id,                  SLE_STRINGID),
 	    SLE_VAR(Station, had_vehicle_of_type,        SLE_UINT16),
 	SLE_CONDARR(Station, airport_flags,              SLE_UINT64, 2,              NEWGRF_AIRPORTS_SAVEGAME, SL_MAX_VERSION),
 	SLE_CONDNULL(2, 0, 25), /* Ex last-vehicle */
 	SLE_CONDVAR(Station, last_vehicle_type,          SLE_UINT8,                  26, SL_MAX_VERSION),
-	// Was custom station class and id
+	/* Was custom station class and id */
 	SLE_CONDNULL(2, 3, 25),
 	SLE_CONDVAR(Station, build_date,                 SLE_FILE_U16 | SLE_VAR_I32,  3, 30),
 	SLE_CONDVAR(Station, build_date,                 SLE_INT32,                  31, SL_MAX_VERSION),
 	SLE_CONDREF(Station, bus_stops,                  REF_ROADSTOPS,               6, SL_MAX_VERSION),
 	SLE_CONDVAR(Station, FSMport_orientation,        SLE_UINT8,                  NEWGRF_AIRPORTS_SAVEGAME, SL_MAX_VERSION),
 	SLE_CONDVAR(Station, FSMport_flood_protected,    SLE_BOOL,                   NEWGRF_AIRPORTS_SAVEGAME, SL_MAX_VERSION),
 	SLE_CONDLST(Station, loading_vehicles,           REF_VEHICLE,                57, SL_MAX_VERSION),
-	// reserve extra space in savegame here. (currently 32 bytes)
+	/* reserve extra space in savegame here. (currently 32 bytes) */
 	SLE_CONDNULL(32, 2, SL_MAX_VERSION),
 	SLE_END()
 };
 	uint num_cargo = CheckSavegameVersion(55) ? 12 : NUM_CARGO;
 	for (CargoID i = 0; i < num_cargo; i++) {
 		GoodsEntry *ge = &st->goods[i];
 		SlObject(ge, _goods_desc);
 		if (CheckSavegameVersion(68)) {
-			SB(ge->acceptance_pickup, GoodsEntry::ACCEPTANCE, 1, HASBIT(_waiting_acceptance, 15));
+			SB(ge->acceptance_pickup, GoodsEntry::ACCEPTANCE, 1, HasBit(_waiting_acceptance, 15));
 			if (GB(_waiting_acceptance, 0, 12) != 0) {
 				/* Don't construct the packet with station here, because that'll fail with old savegames */
 				CargoPacket *cp = new CargoPacket();
 				/* In old versions, enroute_from used 0xFF as INVALID_STATION */
 				cp->source          = (CheckSavegameVersion(7) && _cargo_source == 0xFF) ? INVALID_STATION : _cargo_source;
 }
 static void Save_STNS()
 {
 	Station *st;
-	// Write the stations
+	/* Write the stations */
 	FOR_ALL_STATIONS(st) {
 		SlSetArrayIndex(st->index);
 		SlAutolength((AutolengthProc*)SaveLoad_STNS, st);
 	}
 }
 	while ((index = SlIterateArray()) != -1) {
 		Station *st = new (index) Station();
 		SaveLoad_STNS(st);
-		// this means it's an oldstyle savegame without support for nonuniform stations
+		/* this means it's an oldstyle savegame without support for nonuniform stations */
 		if (st->train_tile != 0 && st->trainst_h == 0) {
 			uint w = GB(st->trainst_w, 4, 4);
 			uint h = GB(st->trainst_w, 0, 4);
 			if (GetRailStationAxis(st->train_tile) != AXIS_X) Swap(w, h);

branch	NewGRF_ports
changeset 6871	5a9dc001e1ad
parent 6870	ca3fd1fbe311
child 6872	1c4a4a609f85