cpp/openttd-patchpack/source Changeset - r3792:deb3c0493c60

Changeset - r3792:deb3c0493c60

Parent rev.

Child rev.

[Not reviewed]

master

0 15 0

rubidium - 18 years ago 2006-05-09 08:17:33
rubidium@openttd.org

(svn r4788) - Codechange: RAILTYPE_{NORMAL,ELECTRIC,...} and RAIL_TYPE_{NORMAL,SIGNAL,...} have nearly the same name, rename RAIL_TYPE_* to RAIL_TILE_* of extra clarity

15 files changed with 55 insertions and 55 deletions:

ai/default/default.c

elrail.c

newgrf_station.c

npf.c

oldloader.c

order_gui.c

rail.h

rail_cmd.c

rail_gui.c

rail_map.h

road_cmd.c

train_cmd.c

tunnelbridge_cmd.c

waypoint.c

waypoint.h

0 comments (0 inline, 0 general)

ai/default/default.c

➞

Show inline comments

@@ @@ -2175,25 +2175,25 @@ static bool AiRemoveTileAndGoForward(Pla @@
+		}
+	}
 	// Find the railtype at the position. Quit if no rail there.
 	b = GetRailTrackStatus(tile) & _dir_table_3[p->ai.cur_dir_a];
 	if (b == 0) return false;
 	// Convert into a bit position that CMD_REMOVE_SINGLE_RAIL expects.
 	bit = FindFirstBit(b);
 	// Then remove and signals if there are any.
 	if (IsTileType(tile, MP_RAILWAY) &&
-			GetRailTileType(tile) == RAIL_TYPE_SIGNALS) {
+			GetRailTileType(tile) == RAIL_TILE_SIGNALS) {
 		DoCommand(tile, 0, 0, DC_EXEC, CMD_REMOVE_SIGNALS);
+	}
 	// And also remove the rail.
 	if (CmdFailed(DoCommand(tile, 0, bit, DC_EXEC, CMD_REMOVE_SINGLE_RAIL)))
 		return false;
 	// Find the direction at the other edge of the rail.
 	ptr = _ai_table_15[p->ai.cur_dir_a ^ 2];
 	while (ptr[0] != bit) ptr += 2;
 	p->ai.cur_dir_a = ptr[1] ^ 2;

elrail.c

➞

Show inline comments

@@ @@ -67,27 +67,27 @@ static inline TLG GetTLG(TileIndex t) @@
 	return (HASBIT(TileX(t), 0) << 1) + HASBIT(TileY(t), 0);
+}
 /** Finds which Rail Bits are present on a given tile. For bridge tiles,
   * returns track bits under the bridge
   */
 static TrackBits GetRailTrackBitsUniversal(TileIndex t, byte *override)
+{
 	switch (GetTileType(t)) {
 		case MP_RAILWAY:
 			if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;
 			switch (GetRailTileType(t)) {
-				case RAIL_TYPE_NORMAL: case RAIL_TYPE_SIGNALS:
+				case RAIL_TILE_NORMAL: case RAIL_TILE_SIGNALS:
 					return GetTrackBits(t);
-				case RAIL_TYPE_DEPOT_WAYPOINT:
+				case RAIL_TILE_DEPOT_WAYPOINT:
 					if (GetRailTileSubtype(t) == RAIL_SUBTYPE_WAYPOINT) return GetRailWaypointBits(t);
 				default:
 					return 0;
+			}
 			break;
 		case MP_TUNNELBRIDGE:
 			if (IsTunnel(t)) {
 				if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;
 				if (override != NULL) *override = 1 << GetTunnelDirection(t);
 				return DiagDirToAxis(GetTunnelDirection(t)) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y;
 			} else {
 				if (GetRailType(t) != RAILTYPE_ELECTRIC) return 0;
@@ @@ -337,25 +337,25 @@ static void DrawCatenaryOnBridge(const T @@
 		if (axis == AXIS_X) {
 			AddSortableSpriteToDraw( pylons_bridge[0 + HASBIT(tlg, 0)], ti->x + 16, ti->y + 4 + 8 * HASBIT(tlg, 0), 1, 1, 10, GetBridgeHeight(ti->tile) + TILE_HEIGHT);
 		} else {
 			AddSortableSpriteToDraw( pylons_bridge[2 + HASBIT(tlg, 1)], ti->x + 4 + 8 * HASBIT(tlg, 1), ti->y + 16, 1, 1, 10, GetBridgeHeight(ti->tile) + TILE_HEIGHT);
+		}
+	}
+}
 void DrawCatenary(const TileInfo *ti)
+{
 	switch (GetTileType(ti->tile)) {
 		case MP_RAILWAY:
-			if (GetRailTileType(ti->tile) == RAIL_TYPE_DEPOT_WAYPOINT && GetRailTileSubtype(ti->tile) == RAIL_SUBTYPE_DEPOT) {
+			if (GetRailTileType(ti->tile) == RAIL_TILE_DEPOT_WAYPOINT && GetRailTileSubtype(ti->tile) == RAIL_SUBTYPE_DEPOT) {
 				const SortableSpriteStruct *sss = &CatenarySpriteData[WIRE_DEPOT_SW + ReverseDiagDir(GetRailDepotDirection(ti->tile))];
 				AddSortableSpriteToDraw( sss->image, ti->x + sss->x_offset, ti->y + sss->y_offset,
 					sss->x_size, sss->y_size, sss->z_size, GetSlopeZ(ti->x, ti->y) + sss->z_offset);
 				return;
+			}
 			/* Fall through */
 		case MP_TUNNELBRIDGE:
 			if (IsBridgeTile(ti->tile) && IsBridgeMiddle(ti->tile) && GetRailTypeOnBridge(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenaryOnBridge(ti);
 			/* Fall further */
 		case MP_STREET: case MP_STATION:
 			DrawCatenaryRailway(ti);
 			break;

newgrf_station.c

➞

Show inline comments

@@ @@ -244,25 +244,25 @@ static TileIndex FindRailStationEnd(Tile @@
 	if (waypoint) {
 		if (check_axis) orig_axis = GetWaypointAxis(tile);
 	} else {
 		if (check_type) orig_type = GetCustomStationSpecIndex(tile);
 		if (check_axis) orig_axis = GetRailStationAxis(tile);
+	}
 	while (true) {
 		TileIndex new_tile = TILE_ADD(tile, delta);
 		if (waypoint) {
 			if (!IsTileType(new_tile, MP_RAILWAY)) break;
-			if (GetRailTileType(new_tile) != RAIL_TYPE_DEPOT_WAYPOINT) break;
+			if (GetRailTileType(new_tile) != RAIL_TILE_DEPOT_WAYPOINT) break;
 			if (GetRailTileSubtype(new_tile) != RAIL_SUBTYPE_WAYPOINT) break;
 			if (check_axis && GetWaypointAxis(new_tile) != orig_axis) break;
 		} else {
 			if (!IsRailwayStationTile(new_tile)) break;
 			if (check_type && GetCustomStationSpecIndex(new_tile) != orig_type) break;
 			if (check_axis && GetRailStationAxis(new_tile) != orig_axis) break;
+		}
 		tile = new_tile;
+	}
 	return tile;
+}

npf.c

➞

Show inline comments

@@ @@ -616,25 +616,25 @@ static void NPFFollowTrack(AyStar* aysta @@
 	DEBUG(npf,6)("After filtering: (%d, %d), possible trackdirs: 0x%X", TileX(dst_tile), TileY(dst_tile), trackdirbits);
 	i = 0;
 	/* Enumerate possible track */
 	while (trackdirbits != 0) {
 		Trackdir dst_trackdir;
 		dst_trackdir =  FindFirstBit2x64(trackdirbits);
 		trackdirbits = KillFirstBit2x64(trackdirbits);
 		DEBUG(npf, 5)("Expanded into trackdir: %d, remaining trackdirs: 0x%X", dst_trackdir, trackdirbits);
 		/* Check for oneway signal against us */
-		if (IsTileType(dst_tile, MP_RAILWAY) && GetRailTileType(dst_tile) == RAIL_TYPE_SIGNALS) {
+		if (IsTileType(dst_tile, MP_RAILWAY) && GetRailTileType(dst_tile) == RAIL_TILE_SIGNALS) {
 			if (HasSignalOnTrackdir(dst_tile, ReverseTrackdir(dst_trackdir)) && !HasSignalOnTrackdir(dst_tile, dst_trackdir))
 				// if one way signal not pointing towards us, stop going in this direction.
 				break;
+		}
+		{
 			/* We've found ourselves a neighbour :-) */
 			AyStarNode* neighbour = &aystar->neighbours[i];
 			neighbour->tile = dst_tile;
 			neighbour->direction = dst_trackdir;
 			/* Save user data */
 			neighbour->user_data[NPF_NODE_FLAGS] = current->path.node.user_data[NPF_NODE_FLAGS];
 			NPFFillTrackdirChoice(neighbour, current);

oldloader.c

➞

Show inline comments

@@ @@ -1514,25 +1514,25 @@ static bool LoadOldMain(LoadgameState *l @@
 	/* Remap some pointers */
 	_cur_town_ctr      = REMAP_TOWN_IDX(_old_cur_town_ctr);
 	/* _old_map3 is changed in _map3_lo and _map3_hi */
 	for (i = 0; i < OLD_MAP_SIZE; i++) {
 		_m[i].m3 = _old_map3[i * 2];
 		_m[i].m4 = _old_map3[i * 2 + 1];
+	}
 	for (i = 0; i < OLD_MAP_SIZE; i ++) {
 		if (IsTileType(i, MP_RAILWAY)) {
 			/* We save presignals different from TTDPatch, convert them */
-			if (GetRailTileType(i) == RAIL_TYPE_SIGNALS) {
+			if (GetRailTileType(i) == RAIL_TILE_SIGNALS) {
 				/* This byte is always zero in TTD for this type of tile */
 				if (_m[i].m4) /* Convert the presignals to our own format */
 					_m[i].m4 = (_m[i].m4 >> 1) & 7;
+			}
 			/* TTDPatch stores PBS things in L6 and all elsewhere; so we'll just
 			* clear it for ourselves and let OTTD's rebuild PBS itself */
 			_m[i].m4 &= 0xF; /* Only keep the lower four bits; upper four is PBS */
+		}
+	}
 	/* Fix the game to be compatible with OpenTTD */
 	FixOldTowns();

order_gui.c

➞

Show inline comments

@@ @@ -191,25 +191,25 @@ static void DrawOrdersWindow(Window *w) @@
 static Order GetOrderCmdFromTile(const Vehicle *v, TileIndex tile)
+{
 	Order order;
 	order.next  = NULL;
 	order.index = 0;
 	// check depot first
 	if (_patches.gotodepot) {
 		switch (GetTileType(tile)) {
 		case MP_RAILWAY:
 			if (v->type == VEH_Train && IsTileOwner(tile, _local_player)) {
-				if (GetRailTileType(tile) == RAIL_TYPE_DEPOT_WAYPOINT &&
+				if (GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT &&
 						GetRailTileSubtype(tile) == RAIL_SUBTYPE_DEPOT) {
 					order.type = OT_GOTO_DEPOT;
 					order.flags = OF_PART_OF_ORDERS;
 					order.station = GetDepotByTile(tile)->index;
 					return order;
+				}
+			}
 			break;
 		case MP_STREET:
 			if (GetRoadType(tile) == ROAD_DEPOT && v->type == VEH_Road && IsTileOwner(tile, _local_player)) {
 				order.type = OT_GOTO_DEPOT;

rail.h

➞

Show inline comments

@@ @@ -328,40 +328,40 @@ static inline bool IsDiagonalTrackdir(Tr @@
 /*
  * Functions quering signals on tiles.
  */
 /**
  * Checks for the presence of signals (either way) on the given track on the
  * given rail tile.
  */
 static inline bool HasSignalOnTrack(TileIndex tile, Track track)
+{
 	assert(IsValidTrack(track));
 	return
-		GetRailTileType(tile) == RAIL_TYPE_SIGNALS &&
+		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
 		(_m[tile].m3 & SignalOnTrack(track)) != 0;
+}
 /**
  * Checks for the presence of signals along the given trackdir on the given
  * rail tile.
+ *
  * Along meaning if you are currently driving on the given trackdir, this is
  * the signal that is facing us (for which we stop when it's red).
  */
 static inline bool HasSignalOnTrackdir(TileIndex tile, Trackdir trackdir)
+{
 	assert (IsValidTrackdir(trackdir));
 	return
-		GetRailTileType(tile) == RAIL_TYPE_SIGNALS &&
+		GetRailTileType(tile) == RAIL_TILE_SIGNALS &&
 		_m[tile].m3 & SignalAlongTrackdir(trackdir);
+}
 /**
  * Gets the state of the signal along the given trackdir.
+ *
  * Along meaning if you are currently driving on the given trackdir, this is
  * the signal that is facing us (for which we stop when it's red).
  */
 static inline SignalState GetSignalStateByTrackdir(TileIndex tile, Trackdir trackdir)
+{
 	assert(IsValidTrackdir(trackdir));

rail_cmd.c

➞

Show inline comments

@@ @@ -68,41 +68,41 @@ void ShowTrainDepotWindow(TileIndex tile @@
  *               01abcdef => rail w/ signals
  *               10uuuuuu => unused
  *               11uuuudd => rail depot
  */
 static bool CheckTrackCombination(TileIndex tile, TrackBits to_build, uint flags)
+{
 	RailTileType type = GetRailTileType(tile);
 	TrackBits current; /* The current track layout */
 	TrackBits future; /* The track layout we want to build */
 	_error_message = STR_1001_IMPOSSIBLE_TRACK_COMBINATION;
-	if (type != RAIL_TYPE_NORMAL && type != RAIL_TYPE_SIGNALS)
+	if (type != RAIL_TILE_NORMAL && type != RAIL_TILE_SIGNALS)
 		return false; /* Cannot build anything on depots and checkpoints */
 	/* So, we have a tile with tracks on it (and possibly signals). Let's see
 	 * what tracks first */
 	current = GetTrackBits(tile);
 	future = current | to_build;
 	/* Are we really building something new? */
 	if (current == future) {
 		/* Nothing new is being built */
 		_error_message = STR_1007_ALREADY_BUILT;
 		return false;
+	}
 	/* Let's see if we may build this */
-	if ((flags & DC_NO_RAIL_OVERLAP) || type == RAIL_TYPE_SIGNALS) {
+	if ((flags & DC_NO_RAIL_OVERLAP) || type == RAIL_TILE_SIGNALS) {
 		/* If we are not allowed to overlap (flag is on for ai players or we have
 		 * signals on the tile), check that */
 		return future == TRACK_BIT_HORZ || future == TRACK_BIT_VERT;
 	} else {
 		/* Normally, we may overlap and any combination is valid */
 		return true;
+	}
+}
 const TrackBits _valid_tileh_slopes[2][15] = {
@@ @@ -252,25 +252,25 @@ int32 CmdBuildSingleRail(TileIndex tile, @@
 				return_cmd_error(STR_1007_ALREADY_BUILT);
 			} else {
 				// Get detailed error message
 				return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
+			}
 			break;
 		case MP_RAILWAY:
 			if (!CheckTrackCombination(tile, trackbit, flags) ||
 					!EnsureNoVehicle(tile)) {
 				return CMD_ERROR;
+			}
-			if (GetRailTileType(tile) == RAIL_TYPE_DEPOT_WAYPOINT ||
+			if (GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT ||
 					!IsTileOwner(tile, _current_player) ||
 					GetRailType(tile) != p1) {
 				// Get detailed error message
 				return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
+			}
 			ret = CheckRailSlope(tileh, trackbit, GetTrackBits(tile), tile);
 			if (CmdFailed(ret)) return ret;
 			cost += ret;
 			if (flags & DC_EXEC) {
 				SetRailGroundType(tile, RAIL_GROUND_BARREN);
@@ @@ -657,27 +657,27 @@ int32 CmdBuildSingleSignal(TileIndex til @@
 		cost = _price.build_signals;
 	} else {
 		if (p2 != 0 && sigvar != GetSignalVariant(tile)) {
 			// convert signals <-> semaphores
 			cost = _price.build_signals + _price.remove_signals;
 		} else {
 			// it is free to change orientation/pre-exit-combo signals
 			cost = 0;
+		}
+	}
 	if (flags & DC_EXEC) {
-		if (GetRailTileType(tile) != RAIL_TYPE_SIGNALS) {
+		if (GetRailTileType(tile) != RAIL_TILE_SIGNALS) {
 			// there are no signals at all on this tile yet
-			_m[tile].m5 |= RAIL_TYPE_SIGNALS; // change into signals
+			_m[tile].m5 |= RAIL_TILE_SIGNALS; // change into signals
 			_m[tile].m2 |= 0xF0;              // all signals are on
 			_m[tile].m3 &= ~0xF0;          // no signals built by default
 			SetSignalType(tile, SIGTYPE_NORMAL);
 			SetSignalVariant(tile, sigvar);
+		}
 		if (p2 == 0) {
 			if (!HasSignalOnTrack(tile, track)) {
 				// build new signals
 				_m[tile].m3 |= SignalOnTrack(track);
 			} else {
 				if (pre_signal) {
@@ @@ -735,25 +735,25 @@ static int32 CmdSignalTrackHelper(TileIn @@
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* for vertical/horizontal tracks, double the given signals density
 	* since the original amount will be too dense (shorter tracks) */
 	if (!IsDiagonalTrack(track))
 		signal_density *= 2;
 	if (CmdFailed(ValidateAutoDrag(&trackdir, tile, end_tile))) return CMD_ERROR;
 	track = TrackdirToTrack(trackdir); /* trackdir might have changed, keep track in sync */
 	// copy the signal-style of the first rail-piece if existing
-	if (GetRailTileType(tile) == RAIL_TYPE_SIGNALS && GetTrackBits(tile) != 0) { /* XXX: GetTrackBits check useless? */
+	if (GetRailTileType(tile) == RAIL_TILE_SIGNALS && GetTrackBits(tile) != 0) { /* XXX: GetTrackBits check useless? */
 		signals = _m[tile].m3 & SignalOnTrack(track);
 		if (signals == 0) signals = SignalOnTrack(track); /* Can this actually occur? */
 		// copy signal/semaphores style (independent of CTRL)
 		semaphores = (GetSignalVariant(tile) == SIG_ELECTRIC ? 0 : 8);
 	} else // no signals exist, drag a two-way signal stretch
 		signals = SignalOnTrack(track);
 	/* signal_ctr         - amount of tiles already processed
 	 * signals_density    - patch setting to put signal on every Nth tile (double space on |, -- tracks)
 	 **********
 	 * trackdir   - trackdir to build with autorail
@@ @@ -816,25 +816,25 @@ int32 CmdRemoveSingleSignal(TileIndex ti @@
 	/* Only water can remove signals from anyone */
 	if (_current_player != OWNER_WATER && !CheckTileOwnership(tile)) return CMD_ERROR;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* Do it? */
 	if (flags & DC_EXEC) {
 		_m[tile].m3 &= ~SignalOnTrack(track);
 		/* removed last signal from tile? */
 		if (GB(_m[tile].m3, 4, 4) == 0) {
 			SB(_m[tile].m2, 4, 4, 0);
-			SB(_m[tile].m5, 6, 2, RAIL_TYPE_NORMAL >> 6); // XXX >> because the constant is meant for direct application, not use with SB
+			SB(_m[tile].m5, 6, 2, RAIL_TILE_NORMAL >> 6); // XXX >> because the constant is meant for direct application, not use with SB
 			SetSignalVariant(tile, SIG_ELECTRIC); // remove any possible semaphores
+		}
 		SetSignalsOnBothDir(tile, track);
 		MarkTileDirtyByTile(tile);
+	}
 	return _price.remove_signals;
+}
 /** Remove signals on a stretch of track.
@@ @@ -948,71 +948,71 @@ static int32 RemoveTrainDepot(TileIndex @@
 	return _price.remove_train_depot;
+}
 static int32 ClearTile_Track(TileIndex tile, byte flags)
+{
 	int32 cost;
 	int32 ret;
 	byte m5;
 	m5 = _m[tile].m5;
 	if (flags & DC_AUTO) {
-		if (GetRailTileType(tile) == RAIL_TYPE_DEPOT_WAYPOINT) {
+		if (GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT) {
 			return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);
+		}
 		if (!IsTileOwner(tile, _current_player))
 			return_cmd_error(STR_1024_AREA_IS_OWNED_BY_ANOTHER);
 		return_cmd_error(STR_1008_MUST_REMOVE_RAILROAD_TRACK);
+	}
 	cost = 0;
 	switch (GetRailTileType(tile)) {
 		/* XXX: Why the fuck do we remove these thow signals first? */
-		case RAIL_TYPE_SIGNALS:
+		case RAIL_TILE_SIGNALS:
 			if (HasSignalOnTrack(tile, TRACK_X)) {
 				ret = DoCommand(tile, TRACK_X, 0, flags, CMD_REMOVE_SIGNALS);
 				if (CmdFailed(ret)) return CMD_ERROR;
 				cost += ret;
+			}
 			if (HasSignalOnTrack(tile, TRACK_LOWER)) {
 				ret = DoCommand(tile, TRACK_LOWER, 0, flags, CMD_REMOVE_SIGNALS);
 				if (CmdFailed(ret)) return CMD_ERROR;
 				cost += ret;
+			}
 			m5 &= TRACK_BIT_MASK;
 			if (!(flags & DC_EXEC)) {
 				for (; m5 != 0; m5 >>= 1) if (m5 & 1) cost += _price.remove_rail;
 				return cost;
+			}
 			/* FALLTHROUGH */
-		case RAIL_TYPE_NORMAL: {
+		case RAIL_TILE_NORMAL: {
 			uint i;
 			for (i = 0; m5 != 0; i++, m5 >>= 1) {
 				if (m5 & 1) {
 					ret = DoCommand(tile, 0, i, flags, CMD_REMOVE_SINGLE_RAIL);
 					if (CmdFailed(ret)) return CMD_ERROR;
 					cost += ret;
+				}
+			}
 			return cost;
+		}
-		case RAIL_TYPE_DEPOT_WAYPOINT:
+		case RAIL_TILE_DEPOT_WAYPOINT:
 			if (GetRailTileSubtype(tile) == RAIL_SUBTYPE_DEPOT) {
 				return RemoveTrainDepot(tile, flags);
 			} else {
 				return RemoveTrainWaypoint(tile, flags, false);
+			}
 		default:
 			return CMD_ERROR;
+	}
+}
 #include "table/track_land.h"
@@ @@ -1289,33 +1289,33 @@ static void DrawSignals(TileIndex tile, @@
 		MAYBE_DRAW_SIGNAL(3, 0x4FF, 10);
 		MAYBE_DRAW_SIGNAL(2, 0x501, 11);
+	}
+}
 static void DrawTile_Track(TileInfo *ti)
+{
 	const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
 	PalSpriteID image;
 	_drawtile_track_palette = SPRITE_PALETTE(PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile)));
-	if (GetRailTileType(ti->tile) != RAIL_TYPE_DEPOT_WAYPOINT) {
+	if (GetRailTileType(ti->tile) != RAIL_TILE_DEPOT_WAYPOINT) {
 		TrackBits rails = GetTrackBits(ti->tile);
 		DrawTrackBits(ti, rails, false);
 		if (_display_opt & DO_FULL_DETAIL) _detailed_track_proc[GetRailGroundType(ti->tile)](ti);
 		/* draw signals also? */
-		if (GetRailTileType(ti->tile) == RAIL_TYPE_SIGNALS) DrawSignals(ti->tile, rails);
+		if (GetRailTileType(ti->tile) == RAIL_TILE_SIGNALS) DrawSignals(ti->tile, rails);
 	} else {
 		/* draw depots / waypoints */
 		const DrawTrackSeqStruct *drss;
 		bool is_depot = GetRailTileSubtype(ti->tile) == RAIL_SUBTYPE_DEPOT;
 		if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, ti->tileh);
 		if (IsRailWaypoint(ti->tile) && IsCustomWaypoint(ti->tile)) {
 			// look for customization
 			byte stat_id = GetWaypointByTile(ti->tile)->stat_id;
 			const StationSpec *statspec = GetCustomStationSpec(STAT_CLASS_WAYP, stat_id);
@@ @@ -1708,41 +1708,41 @@ void SetSignalsOnBothDir(TileIndex tile, @@
 	};
 	UpdateSignalsOnSegment(tile, _search_dir_1[track]);
 	UpdateSignalsOnSegment(tile, _search_dir_2[track]);
+}
 static uint GetSlopeZ_Track(const TileInfo* ti)
+{
 	Slope tileh = ti->tileh;
 	uint z = ti->z;
 	if (tileh == SLOPE_FLAT) return z;
-	if (GetRailTileType(ti->tile) == RAIL_TYPE_DEPOT_WAYPOINT) {
+	if (GetRailTileType(ti->tile) == RAIL_TILE_DEPOT_WAYPOINT) {
 		return z + TILE_HEIGHT;
 	} else {
 		uint f = GetRailFoundation(ti->tileh, GetTrackBits(ti->tile));
 		if (f != 0) {
 			if (f < 15) return z + TILE_HEIGHT; // leveled foundation
 			tileh = _inclined_tileh[f - 15]; // inclined foundation
+		}
 		return z + GetPartialZ(ti->x & 0xF, ti->y & 0xF, tileh);
+	}
+}
 static Slope GetSlopeTileh_Track(TileIndex tile, Slope tileh)
+{
 	if (tileh == SLOPE_FLAT) return SLOPE_FLAT;
-	if (GetRailTileType(tile) == RAIL_TYPE_DEPOT_WAYPOINT) {
+	if (GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT) {
 		return SLOPE_FLAT;
 	} else {
 		uint f = GetRailFoundation(tileh, GetTrackBits(tile));
 		if (f == 0) return tileh;
 		if (f < 15) return SLOPE_FLAT; // leveled foundation
 		return _inclined_tileh[f - 15]; // inclined foundation
+	}
+}
 static void GetAcceptedCargo_Track(TileIndex tile, AcceptedCargo ac)
+{
@@ @@ -1775,25 +1775,25 @@ static void TileLoop_Track(TileIndex til @@
+			}
 			break;
+	}
 	if (new_ground != old_ground) {
 		SetRailGroundType(tile, new_ground);
 		MarkTileDirtyByTile(tile);
+	}
 	if (quick_return) return;
 	// Don't continue tile loop for depots
-	if (GetRailTileType(tile) == RAIL_TYPE_DEPOT_WAYPOINT) return;
+	if (GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT) return;
 	new_ground = RAIL_GROUND_GRASS;
 	if (old_ground != RAIL_GROUND_BARREN) { /* wait until bottom is green */
 		/* determine direction of fence */
 		TrackBits rail = GetTrackBits(tile);
 		switch (rail) {
 			case TRACK_BIT_UPPER: new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
 			case TRACK_BIT_LOWER: new_ground = RAIL_GROUND_FENCE_HORIZ2; break;
 			case TRACK_BIT_LEFT:  new_ground = RAIL_GROUND_FENCE_VERT1;  break;
 			case TRACK_BIT_RIGHT: new_ground = RAIL_GROUND_FENCE_VERT2;  break;
@@ @@ -1872,29 +1872,29 @@ static void TileLoop_Track(TileIndex til @@
 		MarkTileDirtyByTile(tile);
+	}
+}
 static uint32 GetTileTrackStatus_Track(TileIndex tile, TransportType mode)
+{
 	byte a;
 	uint16 b;
 	if (mode != TRANSPORT_RAIL) return 0;
-	if (GetRailTileType(tile) != RAIL_TYPE_DEPOT_WAYPOINT) {
+	if (GetRailTileType(tile) != RAIL_TILE_DEPOT_WAYPOINT) {
 		TrackBits rails = GetTrackBits(tile);
 		uint32 ret = rails * 0x101;
-		if (GetRailTileType(tile) != RAIL_TYPE_SIGNALS) {
+		if (GetRailTileType(tile) != RAIL_TILE_SIGNALS) {
 			if (rails == TRACK_BIT_CROSS) ret |= 0x40;
 		} else {
 			/* has_signals */
 			a = _m[tile].m3;
 			b = _m[tile].m2;
 			b &= a;
 			/* When signals are not present (in neither
 			 * direction), we pretend them to be green. (So if
 			 * signals are only one way, the other way will
@@ @@ -1921,41 +1921,41 @@ static void ClickTile_Track(TileIndex ti @@
+{
 	if (IsTileDepotType(tile, TRANSPORT_RAIL)) {
 		ShowTrainDepotWindow(tile);
 	} else if (IsRailWaypoint(tile)) {
 		ShowRenameWaypointWindow(GetWaypointByTile(tile));
+	}
+}
 static void GetTileDesc_Track(TileIndex tile, TileDesc *td)
+{
 	td->owner = GetTileOwner(tile);
 	switch (GetRailTileType(tile)) {
-		case RAIL_TYPE_NORMAL:
+		case RAIL_TILE_NORMAL:
 			td->str = STR_1021_RAILROAD_TRACK;
 			break;
-		case RAIL_TYPE_SIGNALS: {
+		case RAIL_TILE_SIGNALS: {
 			const StringID signal_type[] = {
 				STR_RAILROAD_TRACK_WITH_NORMAL_SIGNALS,
 				STR_RAILROAD_TRACK_WITH_PRESIGNALS,
 				STR_RAILROAD_TRACK_WITH_EXITSIGNALS,
 				STR_RAILROAD_TRACK_WITH_COMBOSIGNALS
 			};
 			td->str = signal_type[GetSignalType(tile)];
 			break;
+		}
-		case RAIL_TYPE_DEPOT_WAYPOINT:
+		case RAIL_TILE_DEPOT_WAYPOINT:
 		default:
 			td->str = (GetRailTileSubtype(tile) == RAIL_SUBTYPE_DEPOT) ?
 				STR_1023_RAILROAD_TRAIN_DEPOT : STR_LANDINFO_WAYPOINT;
 			break;
+	}
+}
 static void ChangeTileOwner_Track(TileIndex tile, PlayerID old_player, PlayerID new_player)
+{
 	if (!IsTileOwner(tile, old_player)) return;
 	if (new_player != OWNER_SPECTATOR) {

rail_gui.c

➞

Show inline comments

@@ @@ -81,25 +81,25 @@ static void PlaceRail_E(TileIndex tile) @@
 static void PlaceRail_NW(TileIndex tile)
+{
 	VpStartPlaceSizing(tile, VPM_FIX_X);
+}
 static void PlaceRail_AutoRail(TileIndex tile)
+{
 	VpStartPlaceSizing(tile, VPM_RAILDIRS);
+}
 static void PlaceExtraDepotRail(TileIndex tile, uint16 extra)
+{
-	if (GetRailTileType(tile) != RAIL_TYPE_NORMAL) return;
+	if (GetRailTileType(tile) != RAIL_TILE_NORMAL) return;
 	if ((GetTrackBits(tile) & GB(extra, 8, 8)) == 0) return;
 	DoCommandP(tile, _cur_railtype, extra & 0xFF, NULL, CMD_BUILD_SINGLE_RAIL | CMD_AUTO | CMD_NO_WATER);
+}
 static const uint16 _place_depot_extra[12] = {
 x604,		0x2102,		0x1202,		0x505,
 x2400,		0x2801,		0x1800,		0x1401,
 x2203,		0x904,		0x0A05,		0x1103,
 };

rail_map.h

➞

Show inline comments

 /* $Id$ */
 #ifndef RAIL_MAP_H
 #define RAIL_MAP_H
 #include "direction.h"
 #include "tile.h"
 typedef enum RailTileType {
 	RAIL_TYPE_NORMAL         = 0x0,
 	RAIL_TYPE_SIGNALS        = 0x40,
 	RAIL_TYPE_UNUSED         = 0x80, /* XXX: Maybe this could become waypoints? */
 	RAIL_TYPE_DEPOT_WAYPOINT = 0xC0, /* Is really depots and waypoints... */
 	RAIL_TILE_NORMAL         = 0x0,
 	RAIL_TILE_SIGNALS        = 0x40,
 	RAIL_TILE_UNUSED         = 0x80, /* XXX: Maybe this could become waypoints? */
 	RAIL_TILE_DEPOT_WAYPOINT = 0xC0, /* Is really depots and waypoints... */
 	RAIL_TILE_TYPE_MASK      = 0xC0
 } RailTileType;
 static inline RailTileType GetRailTileType(TileIndex t)
+{
 	assert(IsTileType(t, MP_RAILWAY));
 	return _m[t].m5 & RAIL_TILE_TYPE_MASK;
+}
 /**
  * Returns whether this is plain rails, with or without signals. Iow, if this
- * tiles RailTileType is RAIL_TYPE_NORMAL or RAIL_TYPE_SIGNALS.
+ * tiles RailTileType is RAIL_TILE_NORMAL or RAIL_TILE_SIGNALS.
  */
 static inline bool IsPlainRailTile(TileIndex tile)
+{
 	RailTileType rtt = GetRailTileType(tile);
-	return rtt == RAIL_TYPE_NORMAL || rtt == RAIL_TYPE_SIGNALS;
+	return rtt == RAIL_TILE_NORMAL || rtt == RAIL_TILE_SIGNALS;
+}
 /**
  * Checks if a rail tile has signals.
  */
 static inline bool HasSignals(TileIndex tile)
+{
-	return GetRailTileType(tile) == RAIL_TYPE_SIGNALS;
+	return GetRailTileType(tile) == RAIL_TILE_SIGNALS;
+}
 /** These specify the subtype when the main rail type is
- * RAIL_TYPE_DEPOT_WAYPOINT */
+ * RAIL_TILE_DEPOT_WAYPOINT */
 typedef enum RailTileSubtypes {
 	RAIL_SUBTYPE_DEPOT    = 0x00,
 	RAIL_SUBTYPE_WAYPOINT = 0x04,
 	RAIL_SUBTYPE_MASK     = 0x3C
 } RailTileSubtype;
 /**
  * Returns the RailTileSubtype of a given rail tile with type
- * RAIL_TYPE_DEPOT_WAYPOINT
+ * RAIL_TILE_DEPOT_WAYPOINT
  */
 static inline RailTileSubtype GetRailTileSubtype(TileIndex tile)
+{
-	assert(GetRailTileType(tile) == RAIL_TYPE_DEPOT_WAYPOINT);
+	assert(GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT);
 	return (RailTileSubtype)(_m[tile].m5 & RAIL_SUBTYPE_MASK);
+}
 typedef enum RailTypes {
 	RAILTYPE_RAIL     = 0,
 	RAILTYPE_ELECTRIC = 1,
 	RAILTYPE_MONO     = 2,
 	RAILTYPE_MAGLEV   = 3,
 	RAILTYPE_END,
 	INVALID_RAILTYPE = 0xFF
 } RailType;
@@ @@ -192,31 +192,31 @@ static inline Axis GetWaypointAxis(TileI @@
+}
 typedef enum SignalType {
 	SIGTYPE_NORMAL  = 0, // normal signal
 	SIGTYPE_ENTRY   = 1, // presignal block entry
 	SIGTYPE_EXIT    = 2, // presignal block exit
 	SIGTYPE_COMBO   = 3  // presignal inter-block
 } SignalType;
 static inline SignalType GetSignalType(TileIndex t)
+{
-	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);
+	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
 	return (SignalType)GB(_m[t].m4, 0, 2);
+}
 static inline void SetSignalType(TileIndex t, SignalType s)
+{
-	assert(GetRailTileType(t) == RAIL_TYPE_SIGNALS);
+	assert(GetRailTileType(t) == RAIL_TILE_SIGNALS);
 	SB(_m[t].m4, 0, 2, s);
+}
 static inline bool IsPresignalEntry(TileIndex t)
+{
 	return GetSignalType(t) == SIGTYPE_ENTRY || GetSignalType(t) == SIGTYPE_COMBO;
+}
 static inline bool IsPresignalExit(TileIndex t)
+{
 	return GetSignalType(t) == SIGTYPE_EXIT || GetSignalType(t) == SIGTYPE_COMBO;
+}
@@ @@ -278,70 +278,70 @@ typedef enum RailGroundType { @@
 	RAIL_GROUND_FENCE_NE = 5,
 	RAIL_GROUND_FENCE_SW = 6,
 	RAIL_GROUND_FENCE_NESW = 7,
 	RAIL_GROUND_FENCE_VERT1 = 8,
 	RAIL_GROUND_FENCE_VERT2 = 9,
 	RAIL_GROUND_FENCE_HORIZ1 = 10,
 	RAIL_GROUND_FENCE_HORIZ2 = 11,
 	RAIL_GROUND_ICE_DESERT = 12,
 } RailGroundType;
 static inline void SetRailGroundType(TileIndex t, RailGroundType rgt)
+{
-	if (GetRailTileType(t) == RAIL_TYPE_DEPOT_WAYPOINT) {
+	if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) {
 		SB(_m[t].m4, 0, 4, rgt);
 		return;
+	}
 	SB(_m[t].m2, 0, 4, rgt);
+}
 static inline RailGroundType GetRailGroundType(TileIndex t)
+{
 	/* TODO Unify this */
-	if (GetRailTileType(t) == RAIL_TYPE_DEPOT_WAYPOINT) return GB(_m[t].m4, 0, 4);
+	if (GetRailTileType(t) == RAIL_TILE_DEPOT_WAYPOINT) return GB(_m[t].m4, 0, 4);
 	return GB(_m[t].m2, 0, 4);
+}
 static inline bool IsBarrenRailGround(TileIndex t)
+{
 	return GetRailGroundType(t) == RAIL_GROUND_BARREN;
+}
 static inline bool IsSnowRailGround(TileIndex t)
+{
 	return GetRailGroundType(t) == RAIL_GROUND_ICE_DESERT;
+}
 static inline void MakeRailNormal(TileIndex t, Owner o, TrackBits b, RailType r)
+{
 	SetTileType(t, MP_RAILWAY);
 	SetTileOwner(t, o);
 	_m[t].m2 = 0;
 	_m[t].m3 = r;
 	_m[t].m4 = 0;
-	_m[t].m5 = RAIL_TYPE_NORMAL | b;
+	_m[t].m5 = RAIL_TILE_NORMAL | b;
+}
 static inline void MakeRailDepot(TileIndex t, Owner o, DiagDirection d, RailType r)
+{
 	SetTileType(t, MP_RAILWAY);
 	SetTileOwner(t, o);
 	_m[t].m2 = 0;
 	_m[t].m3 = r;
 	_m[t].m4 = 0;
-	_m[t].m5 = RAIL_TYPE_DEPOT_WAYPOINT | RAIL_SUBTYPE_DEPOT | d;
+	_m[t].m5 = RAIL_TILE_DEPOT_WAYPOINT | RAIL_SUBTYPE_DEPOT | d;
+}
 static inline void MakeRailWaypoint(TileIndex t, Owner o, Axis a, RailType r, uint index)
+{
 	SetTileType(t, MP_RAILWAY);
 	SetTileOwner(t, o);
 	_m[t].m2 = index;
 	_m[t].m3 = r;
 	_m[t].m4 = 0;
-	_m[t].m5 = RAIL_TYPE_DEPOT_WAYPOINT | RAIL_SUBTYPE_WAYPOINT | a;
+	_m[t].m5 = RAIL_TILE_DEPOT_WAYPOINT | RAIL_SUBTYPE_WAYPOINT | a;
+}
 #endif

road_cmd.c

➞

Show inline comments

@@ @@ -314,25 +314,25 @@ int32 CmdBuildRoad(TileIndex tile, uint3 @@
 			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_TYPE_NORMAL) goto do_clear;
+			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;
 				case TRACK_BIT_Y:
 					if (pieces & ROAD_Y) goto do_clear;
 					roaddir = AXIS_X;
 					break;
 				default: goto do_clear;

train_cmd.c

➞

Show inline comments

@@ @@ -1810,25 +1810,25 @@ typedef struct TrainFindDepotData { @@
 	PlayerID owner;
 	/**
 	 * true if reversing is necessary for the train to get to this depot
 	 * This value is unused when new depot finding and NPF are both disabled
 	 */
 	bool reverse;
 } TrainFindDepotData;
 static bool NtpCallbFindDepot(TileIndex tile, TrainFindDepotData *tfdd, int track, uint length)
+{
 	if (IsTileType(tile, MP_RAILWAY) &&
 			IsTileOwner(tile, tfdd->owner) &&
-			GetRailTileType(tile) == RAIL_TYPE_DEPOT_WAYPOINT &&
+			GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT &&
 			GetRailTileSubtype(tile) == RAIL_SUBTYPE_DEPOT) {
 		tfdd->best_length = length;
 		tfdd->tile = tile;
 		return true;
+	}
 	return false;
+}
 // returns the tile of a depot to goto to. The given vehicle must not be
 // crashed!
 static TrainFindDepotData FindClosestTrainDepot(Vehicle *v)
@@ @@ -2691,25 +2691,25 @@ static void AffectSpeedByZChange(Vehicle @@
 		if (spd <= v->max_speed) v->cur_speed = spd;
+	}
+}
 static const DiagDirection _otherside_signal_directions[] = {
 	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, 0, 0,
 	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE
 };
 static void TrainMovedChangeSignals(TileIndex tile, DiagDirection dir)
+{
 	if (IsTileType(tile, MP_RAILWAY) &&
-			GetRailTileType(tile) == RAIL_TYPE_SIGNALS) {
+			GetRailTileType(tile) == RAIL_TILE_SIGNALS) {
 		uint i = FindFirstBit2x64(GetTrackBits(tile) * 0x101 & _reachable_tracks[dir]);
 		UpdateSignalsOnSegment(tile, _otherside_signal_directions[i]);
+	}
+}
 typedef struct TrainCollideChecker {
 	const Vehicle *v;
 	const Vehicle *v_skip;
 } TrainCollideChecker;
 static void *FindTrainCollideEnum(Vehicle *v, void *data)

tunnelbridge_cmd.c

➞

Show inline comments

@@ @@ -325,25 +325,25 @@ int32 CmdBuildBridge(TileIndex end_tile, @@
 		if (GetTileSlope(tile, &z) != SLOPE_FLAT && z >= z_start) {
 			return_cmd_error(STR_5009_LEVEL_LAND_OR_WATER_REQUIRED);
+		}
 		switch (GetTileType(tile)) {
 			case MP_WATER:
 				if (!EnsureNoVehicle(tile)) return_cmd_error(STR_980E_SHIP_IN_THE_WAY);
 				if (!(IsWater(tile) || IsCoast(tile))) goto not_valid_below;
 				transport_under = TRANSPORT_WATER;
 				break;
 			case MP_RAILWAY:
-				if (GetRailTileType(tile) != RAIL_TYPE_NORMAL ||
+				if (GetRailTileType(tile) != RAIL_TILE_NORMAL ||
 						GetTrackBits(tile) != (direction == AXIS_X ? TRACK_BIT_Y : TRACK_BIT_X)) {
 					goto not_valid_below;
+				}
 				transport_under = TRANSPORT_RAIL;
 				owner_under = GetTileOwner(tile);
 				rail_under = GetRailType(tile);
 				break;
 			case MP_STREET:
 				if (GetRoadType(tile) != ROAD_NORMAL ||
 						GetRoadBits(tile) != (direction == AXIS_X ? ROAD_Y : ROAD_X)) {
 					goto not_valid_below;

waypoint.c

➞

Show inline comments

@@ @@ -173,25 +173,25 @@ void UpdateAllWaypointCustomGraphics(voi @@
 int32 CmdBuildTrainWaypoint(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
+{
 	Waypoint *wp;
 	Slope tileh;
 	Axis axis;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	/* if custom gfx are used, make sure it is within bounds */
 	if (p1 >= GetNumCustomStations(STAT_CLASS_WAYP)) return CMD_ERROR;
 	if (!IsTileType(tile, MP_RAILWAY) ||
-			GetRailTileType(tile) != RAIL_TYPE_NORMAL || (
+			GetRailTileType(tile) != RAIL_TILE_NORMAL || (
 				(axis = AXIS_X, GetTrackBits(tile) != TRACK_BIT_X) &&
 				(axis = AXIS_Y, GetTrackBits(tile) != TRACK_BIT_Y)
 			)) {
 		return_cmd_error(STR_1005_NO_SUITABLE_RAILROAD_TRACK);
+	}
 	if (!CheckTileOwnership(tile))
 		return CMD_ERROR;
 	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
 	tileh = GetTileSlope(tile, NULL);

waypoint.h

➞

Show inline comments

@@ @@ -16,25 +16,25 @@ struct Waypoint { @@
 	ViewportSign sign; ///< Dimensions of sign (not saved)
 	uint16 build_date; ///< Date of construction
 	byte stat_id;      ///< ID of waypoint within the waypoint class (not saved)
 	uint32 grfid;      ///< ID of GRF file
 	byte localidx;     ///< Index of station within GRF file
 	byte deleted;      ///< Delete counter. If greater than 0 then it is decremented until it reaches 0; the waypoint is then is deleted.
 };
 enum {
-	RAIL_TYPE_WAYPOINT = 0xC4,
+	RAIL_TILE_WAYPOINT = 0xC4,
 	RAIL_WAYPOINT_TRACK_MASK = 1,
 };
 extern MemoryPool _waypoint_pool;
 /**
  * Get the pointer to the waypoint with index 'index'
  */
 static inline Waypoint *GetWaypoint(uint index)
+{
 	return (Waypoint*)GetItemFromPool(&_waypoint_pool, index);
+}

0 comments (0 inline, 0 general)