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

@@ @@ -64,49 +64,49 @@ static inline Date GetServiceIntervalCla @@
 /**
  * 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
@@ @@ -519,94 +520,95 @@ static int32 CmdRailTrackHelper(TileInde @@
 	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.
  */

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;
@@ @@ -64,79 +65,76 @@ bool CheckAllowRemoveRoad(TileIndex tile @@
 	// 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;
@@ @@ -228,65 +226,65 @@ static uint32 CheckRoadSlope(Slope tileh @@
 	// 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:
@@ @@ -481,86 +479,86 @@ int32 CmdRemoveLongRoad(TileIndex end_ti @@
 	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))

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"
@@ @@ -766,69 +767,69 @@ static void GetStationLayout(byte *layou @@
 			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;

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

0 comments (0 inline, 0 general)