cpp/openttd-patchpack/source Changeset - r6134:aa2aee9f9144

Changeset - r6134:aa2aee9f9144

Parent rev.

Child rev.

[Not reviewed]

master

0 5 1

tron - 17 years ago 2007-02-24 09:42:39
tron@openttd.org

(svn r8876) -Fix

Replace tests with magic numbers by a simple extraction template for command parameters

6 files changed with 58 insertions and 28 deletions:

src/cmd_helper.h

src/depot.h

src/rail_cmd.cpp

src/road_cmd.cpp

src/station_cmd.cpp

src/water_cmd.cpp

0 comments (0 inline, 0 general)

src/cmd_helper.h

➞

Show inline comments

@@ new file 100644 @@
 /* $Id$ */
 #ifndef CMD_HELPER_H
 #define CMD_HELPER_H
 #include "direction.h"
 #include "macros.h"
 #include "road.h"
 template<uint N> static inline void ExtractValid();
 template<> static inline void ExtractValid<1>() {}
 template<typename T> struct ExtractBits;
 template<> struct ExtractBits<Axis>          { static const uint Count =  1; };
 template<> struct ExtractBits<DiagDirection> { static const uint Count =  2; };
 template<> struct ExtractBits<RoadBits>      { static const uint Count =  4; };
 template<typename T, uint N, typename U> static inline T Extract(U v)
+{
 	// Check if there are enough bits in v
 	ExtractValid<N + ExtractBits<T>::Count <= sizeof(U) * 8>();
 	return (T)GB(v, N, ExtractBits<T>::Count);
+}
 #endif

src/depot.h

➞

Show inline comments

@@ @@ -40,73 +40,73 @@ static inline void DeleteDepot(Depot *de @@
+}
 void ShowDepotWindow(TileIndex tile, byte type);
 #define FOR_ALL_DEPOTS_FROM(d, start) for (d = GetDepot(start); d != NULL; d = (d->index + 1U < GetDepotPoolSize()) ? GetDepot(d->index + 1U) : NULL) if (IsValidDepot(d))
 #define FOR_ALL_DEPOTS(d) FOR_ALL_DEPOTS_FROM(d, 0)
 #define MIN_SERVINT_PERCENT  5
 #define MAX_SERVINT_PERCENT 90
 #define MIN_SERVINT_DAYS    30
 #define MAX_SERVINT_DAYS   800
 /**
  * Get the service interval domain.
  * Get the new proposed service interval for the vehicle is indeed, clamped
  * within the given bounds. @see MIN_SERVINT_PERCENT ,etc.
  * @param index proposed service interval
  * @return service interval
  */
 static inline Date GetServiceIntervalClamped(uint index)
+{
 	return (_patches.servint_ispercent) ? clamp(index, MIN_SERVINT_PERCENT, MAX_SERVINT_PERCENT) : clamp(index, MIN_SERVINT_DAYS, MAX_SERVINT_DAYS);
+}
 /**
  * Check if a tile is a depot of the given type.
  */
 static inline bool IsTileDepotType(TileIndex tile, TransportType type)
+{
 	switch (type) {
 		case TRANSPORT_RAIL:
 			return IsTileType(tile, MP_RAILWAY) && (_m[tile].m5 & 0xFC) == 0xC0;
 		case TRANSPORT_ROAD:
 			return IsTileType(tile, MP_STREET) && (_m[tile].m5 & 0xF0) == 0x20;
 		case TRANSPORT_WATER:
 			return IsTileType(tile, MP_WATER) && (_m[tile].m5 & ~3) == 0x80;
 		default:
 			assert(0);
 			return false;
+	}
+}
 /**
  * Find out if the slope of the tile is suitable to build a depot of given direction
- * @param direction The direction in which the depot's exit points. Starts with 0 as NE and goes Clockwise
  * @param direction The direction in which the depot's exit points
  * @param tileh The slope of the tile in question
  * @return true if the construction is possible
  * This is checked by the ugly 0x4C >> direction magic, which does the following:
  * 0x4C is 0100 1100 and tileh has only bits 0..3 set (steep tiles are ruled out)
  * So: for direction (only the significant bits are shown)<p>
  * 00 (exit towards NE) we need either bit 2 or 3 set in tileh: 0x4C >> 0 = 1100<p>
  * 01 (exit towards SE) we need either bit 1 or 2 set in tileh: 0x4C >> 1 = 0110<p>
  * 02 (exit towards SW) we need either bit 0 or 1 set in tileh: 0x4C >> 2 = 0011<p>
  * 03 (exit towards NW) we need either bit 0 or 4 set in tileh: 0x4C >> 3 = 1001<p>
  * So ((0x4C >> direction) & tileh) determines whether the depot can be built on the current tileh
  */
-static inline bool CanBuildDepotByTileh(uint32 direction, Slope tileh)
+static inline bool CanBuildDepotByTileh(DiagDirection direction, Slope tileh)
+{
 	return ((0x4C >> direction) & tileh) != 0;
+}
 Depot *GetDepotByTile(TileIndex tile);
 void InitializeDepots(void);
 Depot *AllocateDepot(void);
 void DeleteDepotHighlightOfVehicle(const Vehicle *v);
 #endif /* DEPOT_H */

src/rail_cmd.cpp

➞

Show inline comments

 /* $Id$ */
 #include "stdafx.h"
 #include "openttd.h"
 #include "bridge_map.h"
 #include "cmd_helper.h"
 #include "debug.h"
 #include "functions.h"
 #include "rail_map.h"
 #include "road_map.h"
 #include "table/sprites.h"
 #include "table/strings.h"
 #include "map.h"
 #include "tile.h"
 #include "town_map.h"
 #include "tunnel_map.h"
 #include "vehicle.h"
 #include "viewport.h"
 #include "command.h"
 #include "pathfind.h"
 #include "engine.h"
 #include "town.h"
 #include "sound.h"
 #include "station.h"
 #include "sprite.h"
 #include "depot.h"
 #include "waypoint.h"
 #include "window.h"
 #include "rail.h"
 #include "railtypes.h" // include table for railtypes
 #include "newgrf.h"
 #include "yapf/yapf.h"
 #include "newgrf_callbacks.h"
 #include "newgrf_station.h"
 #include "train.h"
 const byte _track_sloped_sprites[14] = {
 , 15, 22, 13,
 , 21, 17, 12,
 ,  0, 18, 20,
 , 16
 };
 /*         4
  *     ---------
  *    |\       /|
  *    | \    1/ |
  *    |  \   /  |
  *    |   \ /   |
  *  16|    \    |32
  *    |   / \2  |
  *    |  /   \  |
  *    | /     \ |
@@ @@ -495,142 +496,143 @@ static int32 CmdRailTrackHelper(TileInde @@
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (CmdFailed(ValidateAutoDrag(&trackdir, tile, end_tile))) return CMD_ERROR;
 	if (flags & DC_EXEC) SndPlayTileFx(SND_20_SPLAT_2, tile);
 	for (;;) {
 		ret = DoCommand(tile, railtype, TrackdirToTrack(trackdir), flags, (mode == 0) ? CMD_BUILD_SINGLE_RAIL : CMD_REMOVE_SINGLE_RAIL);
 		if (CmdFailed(ret)) {
 			if ((_error_message != STR_1007_ALREADY_BUILT) && (mode == 0)) break;
 			_error_message = INVALID_STRING_ID;
 		} else {
 			total_cost += ret;
+		}
 		if (tile == end_tile) break;
 		tile += ToTileIndexDiff(_trackdelta[trackdir]);
 		// toggle railbit for the non-diagonal tracks
 		if (!IsDiagonalTrackdir(trackdir)) ToggleBitT(trackdir, 0);
+	}
 	return (total_cost == 0) ? CMD_ERROR : total_cost;
+}
 /** Build rail on a stretch of track.
  * Stub for the unified rail builder/remover
  * @see CmdRailTrackHelper
  */
 int32 CmdBuildRailroadTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	return CmdRailTrackHelper(tile, flags, p1, CLRBIT(p2, 7));
+}
 /** Build rail on a stretch of track.
  * Stub for the unified rail builder/remover
  * @see CmdRailTrackHelper
  */
 int32 CmdRemoveRailroadTrack(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	return CmdRailTrackHelper(tile, flags, p1, SETBIT(p2, 7));
+}
 /** Build a train depot
  * @param tile position of the train depot
  * @param p1 rail type
  * @param p2 entrance direction (DiagDirection)
+ * @param p2 bit 0..1 entrance direction (DiagDirection)
+ *
  * @todo When checking for the tile slope,
  * distingush between "Flat land required" and "land sloped in wrong direction"
  */
 int32 CmdBuildTrainDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	Depot *d;
 	int32 cost, ret;
 	Slope tileh;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* check railtype and valid direction for depot (0 through 3), 4 in total */
-	if (!ValParamRailtype(p1) || p2 > 3) return CMD_ERROR;
 	if (!ValParamRailtype(p1)) return CMD_ERROR;
 	tileh = GetTileSlope(tile, NULL);
 	DiagDirection dir = Extract<DiagDirection, 0>(p2);
 	/* Prohibit construction if
 	 * The tile is non-flat AND
 	 * 1) The AI is "old-school"
 	 * 2) build-on-slopes is disabled
 	 * 3) the tile is steep i.e. spans two height levels
 	 * 4) the exit points in the wrong direction
 	 */
 	if (tileh != SLOPE_FLAT && (
 				_is_old_ai_player ||
 				!_patches.build_on_slopes ||
 				IsSteepSlope(tileh) ||
-				!CanBuildDepotByTileh(p2, tileh)
+				!CanBuildDepotByTileh(dir, tileh)
 			)) {
 		return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
+	}
 	ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 	if (CmdFailed(ret)) return CMD_ERROR;
 	cost = ret;
 	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
 	d = AllocateDepot();
 	if (d == NULL) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		DiagDirection dir = (DiagDirection)p2;
 		MakeRailDepot(tile, _current_player, dir, (RailType)p1);
 		MarkTileDirtyByTile(tile);
 		d->xy = tile;
 		d->town_index = ClosestTownFromTile(tile, (uint)-1)->index;
 		UpdateSignalsOnSegment(tile, dir);
 		YapfNotifyTrackLayoutChange(tile, TrackdirToTrack(DiagdirToDiagTrackdir(dir)));
+	}
 	return cost + _price.build_train_depot;
+}
 /** Build signals, alternate between double/single, signal/semaphore,
  * pre/exit/combo-signals, and what-else not. If the rail piece does not
  * have any signals, bit 4 (cycle signal-type) is ignored
  * @param tile tile where to build the signals
  * @param p1 various bitstuffed elements
  * - p1 = (bit 0-2) - track-orientation, valid values: 0-5 (Track enum)
  * - p1 = (bit 3)   - 1 = override signal/semaphore, or pre/exit/combo signal (CTRL-toggle)
  * - p1 = (bit 4)   - 0 = signals, 1 = semaphores
  * @param p2 used for CmdBuildManySignals() to copy direction of first signal
  * TODO: p2 should be replaced by two bits for "along" and "against" the track.
  */
 int32 CmdBuildSingleSignal(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	Track track = (Track)GB(p1, 0, 3);
 	bool pre_signal = HASBIT(p1, 3);
 	SignalVariant sigvar = (pre_signal ^ HASBIT(p1, 4)) ? SIG_SEMAPHORE : SIG_ELECTRIC;
 	int32 cost;
 	if (!ValParamTrackOrientation(track) || !IsTileType(tile, MP_RAILWAY) || !EnsureNoVehicle(tile))
 		return CMD_ERROR;
 	/* Protect against invalid signal copying */
 	if (p2 != 0 && (p2 & SignalOnTrack(track)) == 0) return CMD_ERROR;
 	/* You can only build signals on plain rail tiles, and the selected track must exist */
 	if (!IsPlainRailTile(tile) || !HasTrack(tile, track)) return CMD_ERROR;
 	if (!CheckTileOwnership(tile)) return CMD_ERROR;
 	_error_message = STR_1005_NO_SUITABLE_RAILROAD_TRACK;
+	{
 		/* See if this is a valid track combination for signals, (ie, no overlap) */
 		TrackBits trackbits = GetTrackBits(tile);
 		if (KILL_FIRST_BIT(trackbits) != 0 && /* More than one track present */

src/road_cmd.cpp

➞

Show inline comments

 /* $Id$ */
 #include "stdafx.h"
 #include "openttd.h"
 #include "bridge_map.h"
 #include "cmd_helper.h"
 #include "rail_map.h"
 #include "road_map.h"
 #include "sprite.h"
 #include "table/sprites.h"
 #include "table/strings.h"
 #include "functions.h"
 #include "map.h"
 #include "tile.h"
 #include "town_map.h"
 #include "vehicle.h"
 #include "viewport.h"
 #include "command.h"
 #include "player.h"
 #include "town.h"
 #include "gfx.h"
 #include "sound.h"
 #include "yapf/yapf.h"
 #include "depot.h"
 static uint CountRoadBits(RoadBits r)
+{
 	uint count = 0;
 	if (r & ROAD_NW) ++count;
 	if (r & ROAD_SW) ++count;
 	if (r & ROAD_SE) ++count;
 	if (r & ROAD_NE) ++count;
 	return count;
+}
 bool CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, Owner owner, bool *edge_road)
+{
 	RoadBits present;
 	RoadBits n;
 	*edge_road = true;
 	if (_game_mode == GM_EDITOR) return true;
 	// Only do the special processing for actual players.
 	if (!IsValidPlayer(_current_player)) return true;
 	// Only do the special processing if the road is owned
 	// by a town
 	if (owner != OWNER_TOWN) return (owner == OWNER_NONE) || CheckOwnership(owner);
 	if (_cheats.magic_bulldozer.value) return true;
 	// Get a bitmask of which neighbouring roads has a tile
 	n = ROAD_NONE;
 	present = GetAnyRoadBits(tile);
 	if (present & ROAD_NE && GetAnyRoadBits(TILE_ADDXY(tile,-1, 0)) & ROAD_SW) n |= ROAD_NE;
 	if (present & ROAD_SE && GetAnyRoadBits(TILE_ADDXY(tile, 0, 1)) & ROAD_NW) n |= ROAD_SE;
 	if (present & ROAD_SW && GetAnyRoadBits(TILE_ADDXY(tile, 1, 0)) & ROAD_NE) n |= ROAD_SW;
 	if (present & ROAD_NW && GetAnyRoadBits(TILE_ADDXY(tile, 0,-1)) & ROAD_SE) n |= ROAD_NW;
 	// If 0 or 1 bits are set in n, or if no bits that match the bits to remove,
 	// then allow it
 	if ((n & (n - 1)) != 0 && (n & remove) != 0) {
 		Town *t;
 		*edge_road = false;
 		// you can remove all kind of roads with extra dynamite
 		if (_patches.extra_dynamite) return true;
 		t = ClosestTownFromTile(tile, _patches.dist_local_authority);
 		SetDParam(0, t->index);
 		_error_message = STR_2009_LOCAL_AUTHORITY_REFUSES;
 		return false;
+	}
 	return true;
+}
 static bool CheckAllowRemoveRoad(TileIndex tile, RoadBits remove, bool *edge_road)
+{
 	return CheckAllowRemoveRoad(tile, remove, IsLevelCrossingTile(tile) ? GetCrossingRoadOwner(tile) : GetTileOwner(tile), edge_road);
+}
 /** Delete a piece of road.
  * @param tile tile where to remove road from
- * @param p1 road piece flags
+ * @param p1 bit 0..3 road pieces to remove (RoadBits)
  * @param p2 unused
  */
 int32 CmdRemoveRoad(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	// cost for removing inner/edge -roads
 	static const uint16 road_remove_cost[2] = {50, 18};
 	Owner owner;
 	Town *t;
 	/* true if the roadpiece was always removeable,
 	 * false if it was a center piece. Affects town ratings drop */
 	bool edge_road;
 	RoadBits pieces;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* Road pieces are max 4 bitset values (NE, NW, SE, SW) */
 	if (p1 >> 4) return CMD_ERROR;
 	pieces = (RoadBits)p1;
 	if (!IsTileType(tile, MP_STREET)) return CMD_ERROR;
 	owner = IsLevelCrossingTile(tile) ? GetCrossingRoadOwner(tile) : GetTileOwner(tile);
 	if (owner == OWNER_TOWN && _game_mode != GM_EDITOR) {
 		t = GetTownByTile(tile);
 	} else {
 		t = NULL;
+	}
 	RoadBits pieces = Extract<RoadBits, 0>(p1);
 	if (!CheckAllowRemoveRoad(tile, pieces, &edge_road)) return CMD_ERROR;
 	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
 	// check if you're allowed to remove the street owned by a town
 	// removal allowance depends on difficulty setting
 	if (!CheckforTownRating(flags, t, ROAD_REMOVE)) return CMD_ERROR;
 	switch (GetRoadTileType(tile)) {
 		case ROAD_TILE_NORMAL: {
 			RoadBits present = GetRoadBits(tile);
 			RoadBits c = pieces;
 			if (HasRoadWorks(tile)) return_cmd_error(STR_ROAD_WORKS_IN_PROGRESS);
 			if (GetTileSlope(tile, NULL) != SLOPE_FLAT  &&
 					(present == ROAD_Y || present == ROAD_X)) {
 				c |= (RoadBits)((c & 0xC) >> 2);
 				c |= (RoadBits)((c & 0x3) << 2);
+			}
 			// limit the bits to delete to the existing bits.
 			c &= present;
 			if (c == 0) return CMD_ERROR;
 			if (flags & DC_EXEC) {
 				ChangeTownRating(t, -road_remove_cost[(byte)edge_road], RATING_ROAD_MINIMUM);
 				present ^= c;
 				if (present == 0) {
 					DoClearSquare(tile);
 				} else {
 					SetRoadBits(tile, present);
 					MarkTileDirtyByTile(tile);
+				}
+			}
 			return CountRoadBits(c) * _price.remove_road;
+		}
 		case ROAD_TILE_CROSSING: {
 			if (pieces & ComplementRoadBits(GetCrossingRoadBits(tile))) {
 				return CMD_ERROR;
+			}
 			if (flags & DC_EXEC) {
 				ChangeTownRating(t, -road_remove_cost[(byte)edge_road], RATING_ROAD_MINIMUM);
 				MakeRailNormal(tile, GetTileOwner(tile), GetCrossingRailBits(tile), GetRailTypeCrossing(tile));
@@ @@ -204,113 +202,113 @@ static const RoadBits _valid_tileh_slope @@
 		ROAD_ALL,
 		ROAD_Y  | ROAD_NE, // 12
 		ROAD_ALL,
 		ROAD_ALL
 	},
 };
 static uint32 CheckRoadSlope(Slope tileh, RoadBits* pieces, RoadBits existing)
+{
 	RoadBits road_bits;
 	if (IsSteepSlope(tileh)) {
 		if (existing == 0) {
 			// force full pieces.
 			*pieces |= (RoadBits)((*pieces & 0xC) >> 2);
 			*pieces |= (RoadBits)((*pieces & 0x3) << 2);
 			if (*pieces == ROAD_X || *pieces == ROAD_Y) return _price.terraform;
+		}
 		return CMD_ERROR;
+	}
 	road_bits = *pieces | existing;
 	// no special foundation
 	if ((~_valid_tileh_slopes_road[0][tileh] & road_bits) == 0) {
 		// force that all bits are set when we have slopes
 		if (tileh != SLOPE_FLAT) *pieces |= _valid_tileh_slopes_road[0][tileh];
 		return 0; // no extra cost
+	}
 	// foundation is used. Whole tile is leveled up
 	if ((~_valid_tileh_slopes_road[1][tileh] & road_bits) == 0) {
 		return existing != 0 ? 0 : _price.terraform;
+	}
 	// partly leveled up tile, only if there's no road on that tile
 	if (existing == 0 && (tileh == SLOPE_W || tileh == SLOPE_S || tileh == SLOPE_E || tileh == SLOPE_N)) {
 		// force full pieces.
 		*pieces |= (RoadBits)((*pieces & 0xC) >> 2);
 		*pieces |= (RoadBits)((*pieces & 0x3) << 2);
 		if (*pieces == ROAD_X || *pieces == ROAD_Y) return _price.terraform;
+	}
 	return CMD_ERROR;
+}
 /** Build a piece of road.
  * @param tile tile where to build road
- * @param p1 road piece flags
+ * @param p1 bit 0..3 road pieces to build (RoadBits)
  * @param p2 the town that is building the road (0 if not applicable)
  */
 int32 CmdBuildRoad(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	int32 cost = 0;
 	int32 ret;
 	RoadBits existing = ROAD_NONE;
 	RoadBits pieces;
 	Slope tileh;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* Road pieces are max 4 bitset values (NE, NW, SE, SW) and town can only be non-zero
 	 * if a non-player is building the road */
 	if ((p1 >> 4) || (IsValidPlayer(_current_player) && p2 != 0) || (_current_player == OWNER_TOWN && !IsValidTownID(p2))) return CMD_ERROR;
 	pieces = (RoadBits)p1;
 	if ((IsValidPlayer(_current_player) && p2 != 0) || (_current_player == OWNER_TOWN && !IsValidTownID(p2))) return CMD_ERROR;
 	RoadBits pieces = Extract<RoadBits, 0>(p1);
 	tileh = GetTileSlope(tile, NULL);
 	switch (GetTileType(tile)) {
 		case MP_STREET:
 			switch (GetRoadTileType(tile)) {
 				case ROAD_TILE_NORMAL:
 					if (HasRoadWorks(tile)) return_cmd_error(STR_ROAD_WORKS_IN_PROGRESS);
 					existing = GetRoadBits(tile);
 					if ((existing & pieces) == pieces) {
 						return_cmd_error(STR_1007_ALREADY_BUILT);
+					}
 					if (!EnsureNoVehicle(tile)) return CMD_ERROR;
 					break;
 				case ROAD_TILE_CROSSING:
 					if (pieces != GetCrossingRoadBits(tile)) { // XXX is this correct?
 						return_cmd_error(STR_1007_ALREADY_BUILT);
+					}
 					goto do_clear;
 				default:
 				case ROAD_TILE_DEPOT:
 					goto do_clear;
+			}
 			break;
 		case MP_RAILWAY: {
 			Axis roaddir;
 			if (IsSteepSlope(tileh)) {
 				return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
+			}
 #define M(x) (1 << (x))
 			/* Level crossings may only be built on these slopes */
 			if (!HASBIT(M(SLOPE_SEN) | M(SLOPE_ENW) | M(SLOPE_NWS) | M(SLOPE_NS) | M(SLOPE_WSE) | M(SLOPE_EW) | M(SLOPE_FLAT), tileh)) {
 				return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
+			}
 #undef M
 			if (GetRailTileType(tile) != RAIL_TILE_NORMAL) goto do_clear;
 			switch (GetTrackBits(tile)) {
 				case TRACK_BIT_X:
 					if (pieces & ROAD_X) goto do_clear;
 					roaddir = AXIS_Y;
 					break;
@@ @@ -457,134 +455,134 @@ int32 CmdBuildLongRoad(TileIndex end_til @@
 int32 CmdRemoveLongRoad(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	TileIndex start_tile, tile;
 	int32 cost, ret;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (p1 >= MapSize()) return CMD_ERROR;
 	start_tile = p1;
 	/* Only drag in X or Y direction dictated by the direction variable */
 	if (!HASBIT(p2, 2) && TileY(start_tile) != TileY(end_tile)) return CMD_ERROR; // x-axis
 	if (HASBIT(p2, 2)  && TileX(start_tile) != TileX(end_tile)) return CMD_ERROR; // y-axis
 	/* Swap start and ending tile, also the half-tile drag var (bit 0 and 1) */
 	if (start_tile > end_tile || (start_tile == end_tile && HASBIT(p2, 0))) {
 		TileIndex t = start_tile;
 		start_tile = end_tile;
 		end_tile = t;
 		p2 ^= IS_INT_INSIDE(p2 & 3, 1, 3) ? 3 : 0;
+	}
 	cost = 0;
 	tile = start_tile;
 	// Start tile is the small number.
 	for (;;) {
 		RoadBits bits = HASBIT(p2, 2) ? ROAD_Y : ROAD_X;
 		if (tile == end_tile && !HASBIT(p2, 1)) bits &= ROAD_NW | ROAD_NE;
 		if (tile == start_tile && HASBIT(p2, 0)) bits &= ROAD_SE | ROAD_SW;
 		// try to remove the halves.
 		if (bits != 0) {
 			ret = DoCommand(tile, bits, 0, flags, CMD_REMOVE_ROAD);
 			if (!CmdFailed(ret)) cost += ret;
+		}
 		if (tile == end_tile) break;
 		tile += HASBIT(p2, 2) ? TileDiffXY(0, 1) : TileDiffXY(1, 0);
+	}
 	return (cost == 0) ? CMD_ERROR : cost;
+}
 /** Build a road depot.
  * @param tile tile where to build the depot
  * @param p1 entrance direction (DiagDirection)
+ * @param p1 bit 0..1 entrance direction (DiagDirection)
  * @param p2 unused
+ *
  * @todo When checking for the tile slope,
  * distingush between "Flat land required" and "land sloped in wrong direction"
  */
 int32 CmdBuildRoadDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	int32 cost;
 	Depot *dep;
 	Slope tileh;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
-	if (p1 > 3) return CMD_ERROR; // check direction
+	DiagDirection dir = Extract<DiagDirection, 0>(p1);
 	tileh = GetTileSlope(tile, NULL);
 	if (tileh != SLOPE_FLAT && (
 				!_patches.build_on_slopes ||
 				IsSteepSlope(tileh) ||
-				!CanBuildDepotByTileh(p1, tileh)
+				!CanBuildDepotByTileh(dir, tileh)
 			)) {
 		return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
+	}
 	cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 	if (CmdFailed(cost)) return CMD_ERROR;
 	if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
 	dep = AllocateDepot();
 	if (dep == NULL) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		dep->xy = tile;
 		dep->town_index = ClosestTownFromTile(tile, (uint)-1)->index;
-		MakeRoadDepot(tile, _current_player, (DiagDirection)p1);
+		MakeRoadDepot(tile, _current_player, dir);
 		MarkTileDirtyByTile(tile);
+	}
 	return cost + _price.build_road_depot;
+}
 static int32 RemoveRoadDepot(TileIndex tile, uint32 flags)
+{
 	if (!CheckTileOwnership(tile) && _current_player != OWNER_WATER)
 		return CMD_ERROR;
 	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
 	if (flags & DC_EXEC) DeleteDepot(GetDepotByTile(tile));
 	return _price.remove_road_depot;
+}
 static int32 ClearTile_Road(TileIndex tile, byte flags)
+{
 	switch (GetRoadTileType(tile)) {
 		case ROAD_TILE_NORMAL: {
 			RoadBits b = GetRoadBits(tile);
 #define M(x) (1 << (x))
 			/* Clear the road if only one piece is on the tile OR the AI tries
 			 * to clear town road OR we are not using the DC_AUTO flag */
 			if ((M(b) & (M(ROAD_NW) | M(ROAD_SW) | M(ROAD_SE) | M(ROAD_NE))) ||
 			    ((flags & DC_AI_BUILDING) && IsTileOwner(tile, OWNER_TOWN)) ||
 			    !(flags & DC_AUTO)
 				) {
 				return DoCommand(tile, b, 0, flags, CMD_REMOVE_ROAD);
+			}
 			return_cmd_error(STR_1801_MUST_REMOVE_ROAD_FIRST);
+		}
 #undef M
 		case ROAD_TILE_CROSSING: {
 			int32 ret;
 			if (flags & DC_AUTO) return_cmd_error(STR_1801_MUST_REMOVE_ROAD_FIRST);
 			ret = DoCommand(tile, GetCrossingRoadBits(tile), 0, flags, CMD_REMOVE_ROAD);
 			if (CmdFailed(ret)) return CMD_ERROR;
 			if (flags & DC_EXEC) {
 				DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
+			}
 			return ret;

src/station_cmd.cpp

➞

Show inline comments

 /* $Id$ */
 /** @file station_cmd.cpp */
 #include "stdafx.h"
 #include "openttd.h"
 #include "aircraft.h"
 #include "bridge_map.h"
 #include "cmd_helper.h"
 #include "debug.h"
 #include "functions.h"
 #include "station_map.h"
 #include "table/sprites.h"
 #include "table/strings.h"
 #include "map.h"
 #include "tile.h"
 #include "station.h"
 #include "gfx.h"
 #include "window.h"
 #include "viewport.h"
 #include "command.h"
 #include "town.h"
 #include "vehicle.h"
 #include "news.h"
 #include "saveload.h"
 #include "economy.h"
 #include "player.h"
 #include "airport.h"
 #include "sprite.h"
 #include "depot.h"
 #include "train.h"
 #include "water_map.h"
 #include "industry_map.h"
 #include "newgrf_callbacks.h"
 #include "newgrf_station.h"
 #include "yapf/yapf.h"
 #include "date.h"
 #include "helpers.hpp"
 #include "misc/autoptr.hpp"
 #include "road.h"
 #include "cargotype.h"
 /**
  * Called if a new block is added to the station-pool
  */
 static void StationPoolNewBlock(uint start_item)
+{
 	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.
 	 *  TODO - This is just a temporary stage, this will be removed. */
 	for (Station *st = GetStation(start_item); st != NULL; st = (st->index + 1U < GetStationPoolSize()) ? GetStation(st->index + 1U) : NULL) st->index = start_item++;
+}
 static void StationPoolCleanBlock(uint start_item, uint end_item)
+{
 	for (uint i = start_item; i <= end_item; i++) {
 		Station *st = GetStation(i);
 		if (st->IsValid()) st->~Station();
@@ @@ -742,117 +743,117 @@ static bool CanExpandRailroadStation(con @@
+}
 static inline byte *CreateSingle(byte *layout, int n)
+{
 	int i = n;
 	do *layout++ = 0; while (--i);
 	layout[((n-1) >> 1)-n] = 2;
 	return layout;
+}
 static inline byte *CreateMulti(byte *layout, int n, byte b)
+{
 	int i = n;
 	do *layout++ = b; while (--i);
 	if (n > 4) {
 		layout[0-n] = 0;
 		layout[n-1-n] = 0;
+	}
 	return layout;
+}
 static void GetStationLayout(byte *layout, int numtracks, int plat_len, const StationSpec *statspec)
+{
 	if (statspec != NULL && statspec->lengths >= plat_len &&
 			statspec->platforms[plat_len - 1] >= numtracks &&
 			statspec->layouts[plat_len - 1][numtracks - 1]) {
 		/* Custom layout defined, follow it. */
 		memcpy(layout, statspec->layouts[plat_len - 1][numtracks - 1],
 			plat_len * numtracks);
 		return;
+	}
 	if (plat_len == 1) {
 		CreateSingle(layout, numtracks);
 	} else {
 		if (numtracks & 1) layout = CreateSingle(layout, plat_len);
 		numtracks >>= 1;
 		while (--numtracks >= 0) {
 			layout = CreateMulti(layout, plat_len, 4);
 			layout = CreateMulti(layout, plat_len, 6);
+		}
+	}
+}
 /** Build railroad station
  * @param tile_org starting position of station dragging/placement
  * @param p1 various bitstuffed elements
- * - p1 = (bit  0)    - orientation (p1 & 1)
+ * - p1 = (bit  0)    - orientation (Axis)
  * - p1 = (bit  8-15) - number of tracks
  * - p1 = (bit 16-23) - platform length
  * @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
  */
 int32 CmdBuildRailroadStation(TileIndex tile_org, uint32 flags, uint32 p1, uint32 p2)
+{
 	int w_org, h_org;
 	int32 ret;
 	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;
 	/* unpack parameters */
-	Axis axis = (Axis)GB(p1, 0, 1);
+	Axis axis = Extract<Axis, 0>(p1);
 	uint numtracks = GB(p1,  8, 8);
 	uint plat_len  = GB(p1, 16, 8);
 	if (axis == AXIS_X) {
 		w_org = plat_len;
 		h_org = numtracks;
 	} else {
 		h_org = plat_len;
 		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
 	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)
 	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;
 	int32 cost = ret + (numtracks * _price.train_station_track + _price.train_station_length) * plat_len;
 	// Make sure there are no similar stations around us.
 	Station *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.
 	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.
 		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?
 			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;

src/water_cmd.cpp

➞

Show inline comments

 /* $Id$ */
 #include "stdafx.h"
 #include "openttd.h"
 #include "bridge_map.h"
 #include "cmd_helper.h"
 #include "station_map.h"
 #include "table/sprites.h"
 #include "table/strings.h"
 #include "functions.h"
 #include "map.h"
 #include "tile.h"
 #include "vehicle.h"
 #include "viewport.h"
 #include "command.h"
 #include "town.h"
 #include "news.h"
 #include "sound.h"
 #include "depot.h"
 #include "vehicle_gui.h"
 #include "train.h"
 #include "water_map.h"
 #include "newgrf.h"
 static const SpriteID _water_shore_sprites[] = {
 ,
 	SPR_SHORE_TILEH_1,
 	SPR_SHORE_TILEH_2,
 	SPR_SHORE_TILEH_3,
 	SPR_SHORE_TILEH_4,
 ,
 	SPR_SHORE_TILEH_6,
 ,
 	SPR_SHORE_TILEH_8,
 	SPR_SHORE_TILEH_9,
 ,
 ,
 	SPR_SHORE_TILEH_12,
 ,
 };
 static Vehicle *FindFloodableVehicleOnTile(TileIndex tile);
 static void FloodVehicle(Vehicle *v);
 /** Build a ship depot.
  * @param tile tile where ship depot is built
- * @param p1 depot direction (0 == X or 1 == Y)
+ * @param p1 bit 0 depot orientation (Axis)
  * @param p2 unused
  */
 int32 CmdBuildShipDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	TileIndex tile2;
 	int32 cost, ret;
 	Depot *depot;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (p1 > 1) return CMD_ERROR;
 	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
 	tile2 = tile + (p1 ? TileDiffXY(0, 1) : TileDiffXY(1, 0));
 	Axis axis = Extract<Axis, 0>(p1);
 	tile2 = tile + (axis == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
 	if (!EnsureNoVehicle(tile2)) return CMD_ERROR;
 	if (!IsClearWaterTile(tile) || !IsClearWaterTile(tile2))
 		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);
 	if (IsBridgeAbove(tile) || IsBridgeAbove(tile2)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
 	ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 	if (CmdFailed(ret)) return CMD_ERROR;
 	ret = DoCommand(tile2, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 	if (CmdFailed(ret)) return CMD_ERROR;
 	// pretend that we're not making land from the water even though we actually are.
 	cost = 0;
 	depot = AllocateDepot();
 	if (depot == NULL) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		depot->xy = tile;
 		depot->town_index = ClosestTownFromTile(tile, (uint)-1)->index;
 		MakeShipDepot(tile, _current_player, DEPOT_NORTH, (Axis)p1);
 		MakeShipDepot(tile2, _current_player, DEPOT_SOUTH, (Axis)p1);
 		MakeShipDepot(tile,  _current_player, DEPOT_NORTH, axis);
 		MakeShipDepot(tile2, _current_player, DEPOT_SOUTH, axis);
 		MarkTileDirtyByTile(tile);
 		MarkTileDirtyByTile(tile2);
+	}
 	return cost + _price.build_ship_depot;
+}
 static int32 RemoveShipDepot(TileIndex tile, uint32 flags)
+{
 	TileIndex tile2;
 	if (!IsShipDepot(tile)) return CMD_ERROR;
 	if (!CheckTileOwnership(tile)) return CMD_ERROR;
 	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
 	tile2 = GetOtherShipDepotTile(tile);
 	if (!EnsureNoVehicle(tile2)) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		/* Kill the depot, which is registered at the northernmost tile. Use that one */
 		DeleteDepot(GetDepotByTile(tile2 < tile ? tile2 : tile));
 		MakeWater(tile);
 		MakeWater(tile2);
 		MarkTileDirtyByTile(tile);
 		MarkTileDirtyByTile(tile2);
+	}
 	return _price.remove_ship_depot;
+}
 // build a shiplift
 static int32 DoBuildShiplift(TileIndex tile, DiagDirection dir, uint32 flags)
+{
 	int32 ret;
 	int delta;
 	// middle tile
 	ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 	if (CmdFailed(ret)) return CMD_ERROR;
 	delta = TileOffsByDiagDir(dir);
 	// lower tile
 	ret = DoCommand(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 	if (CmdFailed(ret)) return CMD_ERROR;
 	if (GetTileSlope(tile - delta, NULL) != SLOPE_FLAT) {
 		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);

0 comments (0 inline, 0 general)