openttd-ottdgrfs: comparison src/rail

equal deleted inserted replaced

-:96b4b92b86ae
+:9c3129cb019b
 	TRACK_BIT_RIGHT,
 	TRACK_BIT_UPPER,
 	TRACK_BIT_X,
 	TRACK_BIT_LEFT,
-	0,
+	TRACK_BIT_NONE,
 	TRACK_BIT_Y,
 	TRACK_BIT_LOWER,
 	TRACK_BIT_LOWER,
 	TRACK_BIT_Y,
-	0,
+	TRACK_BIT_NONE,
 	TRACK_BIT_LEFT,
 	TRACK_BIT_X,
 	TRACK_BIT_UPPER,
 	TRACK_BIT_RIGHT,
 },
 // allowed rail for an evenly raised platform
 {
-	0,
+	TRACK_BIT_NONE,
 	TRACK_BIT_LEFT,
 	TRACK_BIT_LOWER,
 	TRACK_BIT_Y | TRACK_BIT_LOWER | TRACK_BIT_LEFT,
 	TRACK_BIT_RIGHT,
 	Track track;
 	TrackBits trackbit;
 	int32 cost = 0;
 	int32 ret;
-	if (!ValParamRailtype(p1) || !ValParamTrackOrientation(p2)) return CMD_ERROR;
+	if (!ValParamRailtype(p1) || !ValParamTrackOrientation((Track)p2)) return CMD_ERROR;
 	railtype = (RailType)p1;
 	track = (Track)p2;
 	tileh = GetTileSlope(tile, NULL);
 	trackbit = TrackToTrackBits(track);
 				return_cmd_error(STR_1007_ALREADY_BUILT);
 			}
 			/* FALLTHROUGH */
 		default:
-			ret = CheckRailSlope(tileh, trackbit, 0, tile);
+			ret = CheckRailSlope(tileh, trackbit, TRACK_BIT_NONE, tile);
 			if (CmdFailed(ret)) return ret;
 			cost += ret;
 			ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 			if (CmdFailed(ret)) return ret;
 	Track track = (Track)p2;
 	TrackBits trackbit;
 	int32 cost = _price.remove_rail;
 	bool crossing = false;
-	if (!ValParamTrackOrientation(p2)) return CMD_ERROR;
+	if (!ValParamTrackOrientation((Track)p2)) return CMD_ERROR;
 	trackbit = TrackToTrackBits(track);
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	switch (GetTileType(tile)) {
 	int y = TileY(start);
 	int ex = TileX(end);
 	int ey = TileY(end);
 	int dx, dy, trdx, trdy;
-	if (!ValParamTrackOrientation(*trackdir)) return CMD_ERROR;
+	if (!ValParamTrackOrientation(TrackdirToTrack(*trackdir))) return CMD_ERROR;
 	// calculate delta x,y from start to end tile
 	dx = ex - x;
 	dy = ey - y;
 		(trdx >= 0 && dx < 0) ||
 		(trdy <= 0 && dy > 0) ||
 		(trdy >= 0 && dy < 0)
 	) {
 		if (!HASBIT(*trackdir, 3)) { // first direction is invalid, try the other
-			SETBIT(*trackdir, 3); // reverse the direction
+			*trackdir = SetBitT(*trackdir, 3); // reverse the direction
 			trdx = -trdx;
 			trdy = -trdy;
 		} else { // other direction is invalid too, invalid drag
 			return CMD_ERROR;
 		}
 		if (tile == end_tile) break;
 		tile += ToTileIndexDiff(_trackdelta[trackdir]);
 		// toggle railbit for the non-diagonal tracks
-		if (!IsDiagonalTrackdir(trackdir)) trackdir ^= 1;
+		if (!IsDiagonalTrackdir(trackdir)) trackdir = ToggleBitT(trackdir, 0);
 	}
 	return (total_cost == 0) ? CMD_ERROR : total_cost;
 }
 	d = AllocateDepot();
 	if (d == NULL) return CMD_ERROR;
 	if (flags & DC_EXEC) {
-		MakeRailDepot(tile, _current_player, p2, p1);
+		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, p2);
+		UpdateSignalsOnSegment(tile, dir);
-		YapfNotifyTrackLayoutChange(tile, TrackdirToTrack(DiagdirToDiagTrackdir(p2)));
+		YapfNotifyTrackLayoutChange(tile, TrackdirToTrack(DiagdirToDiagTrackdir(dir)));
 	}
 	return cost + _price.build_train_depot;
 }
 			} else {
 				if (pre_signal) {
 					// cycle between normal -> pre -> exit -> combo -> ...
 					SignalType type = GetSignalType(tile);
-					SetSignalType(tile, type == SIGTYPE_COMBO ? SIGTYPE_NORMAL : type + 1);
+					SetSignalType(tile, type == SIGTYPE_COMBO ? SIGTYPE_NORMAL : (SignalType)(type + 1));
 				} else {
 					CycleSignalSide(tile, track);
 				}
 			}
 		} else {
 	byte signals;
 	bool error = true;
 	TileIndex end_tile;
 	int mode = p2 & 0x1;
-	Track track = GB(p2, 4, 3);
+	Track track = (Track)GB(p2, 4, 3);
 	Trackdir trackdir = TrackToTrackdir(track);
 	byte semaphores = (HASBIT(p2, 3) ? 8 : 0);
 	byte signal_density = (p2 >> 24);
 	if (p1 >= MapSize()) return CMD_ERROR;
 		tile += ToTileIndexDiff(_trackdelta[trackdir]);
 		signal_ctr++;
 		// toggle railbit for the non-diagonal tracks (|, -- tracks)
-		if (!IsDiagonalTrackdir(trackdir)) trackdir ^= 1;
+		if (!IsDiagonalTrackdir(trackdir)) trackdir = ToggleBitT(trackdir, 0);
 	}
 	return error ? CMD_ERROR : total_cost;
 }
 	// 'hidden' elrails can't be downgraded to normal rail when elrails are disabled
 	if (_patches.disable_elrails && totype == RAILTYPE_RAIL && GetRailType(tile) == RAILTYPE_ELECTRIC) return CMD_ERROR;
 	// change type.
 	if (exec) {
-		TrackBits tracks;
 		SetRailType(tile, totype);
 		MarkTileDirtyByTile(tile);
 		// notify YAPF about the track layout change
-		for (tracks = GetTrackBits(tile); tracks != TRACK_BIT_NONE; tracks = KILL_FIRST_BIT(tracks))
+		TrackBits tracks = GetTrackBits(tile);
-			YapfNotifyTrackLayoutChange(tile, FIND_FIRST_BIT(tracks));
+		while (tracks != TRACK_BIT_NONE) {
+			YapfNotifyTrackLayoutChange(tile, RemoveFirstTrack(tracks));
+		}
 		if (IsTileDepotType(tile, TRANSPORT_RAIL)) {
 			Vehicle *v;
 			/* Update build vehicle window related to this depot */
 				case MP_STREET:       proc = DoConvertStreetRail;       break;
 				case MP_TUNNELBRIDGE: proc = DoConvertTunnelBridgeRail; break;
 				default: continue;
 			}
-			ret = proc(tile, p2, false);
+			ret = proc(tile, (RailType)p2, false);
 			if (CmdFailed(ret)) continue;
 			cost += ret;
 			if (flags & DC_EXEC) {
 				money -= ret;
 				if (money < 0) {
 					_additional_cash_required = ret;
 					return cost - ret;
 				}
-				proc(tile, p2, true);
+				proc(tile, (RailType)p2, true);
 			}
 		}
 	}
 	return (cost == 0) ? ret : cost;
 	switch (GetRailTileType(tile)) {
 		case RAIL_TILE_SIGNALS:
 		case RAIL_TILE_NORMAL: {
 			TrackBits tracks = GetTrackBits(tile);
-			uint i;
+			while (tracks != TRACK_BIT_NONE) {
+				Track track = RemoveFirstTrack(tracks);
-			for_each_bit (i, tracks) {
+				ret = DoCommand(tile, 0, track, flags, CMD_REMOVE_SINGLE_RAIL);
-				ret = DoCommand(tile, 0, i, flags, CMD_REMOVE_SINGLE_RAIL);
 				if (CmdFailed(ret)) return CMD_ERROR;
 				cost += ret;
 			}
 			return cost;
 		}
 #include "table/track_land.h"
 static void DrawSingleSignal(TileIndex tile, byte condition, uint image, uint pos)
 {
-	bool side = _opt.road_side & _patches.signal_side;
+	bool side = (_opt.road_side != 0) && _patches.signal_side;
 	static const Point SignalPositions[2][12] = {
 		{      /* Signals on the left side */
 		/*  LEFT      LEFT      RIGHT     RIGHT     UPPER     UPPER */
 			{ 8,  5}, {14,  1}, { 1, 14}, { 9, 11}, { 1,  0}, { 3, 10},
 		/*  LOWER     LOWER     X         X         Y         Y     */
 	// presignal info
 	int presignal_exits;
 	int presignal_exits_free;
 	// these are used to keep track of the signals that change.
-	byte bit[NUM_SSD_ENTRY];
+	TrackdirByte bit[NUM_SSD_ENTRY];
 	TileIndex tile[NUM_SSD_ENTRY];
 	// these are used to keep track of the stack that modifies presignals recursively
 	TileIndex next_tile[NUM_SSD_STACK];
-	byte next_dir[NUM_SSD_STACK];
+	DiagDirectionByte next_dir[NUM_SSD_STACK];
 } SetSignalsData;
-static bool SetSignalsEnumProc(TileIndex tile, void* data, int track, uint length, byte* state)
+static bool SetSignalsEnumProc(TileIndex tile, void* data, Trackdir trackdir, uint length, byte* state)
 {
-	SetSignalsData* ssd = data;
+	SetSignalsData* ssd = (SetSignalsData*)data;
 	if (!IsTileType(tile, MP_RAILWAY)) return false;
 	// the tile has signals?
-	if (HasSignalOnTrack(tile, TrackdirToTrack(track))) {
+	if (HasSignalOnTrack(tile, TrackdirToTrack(trackdir))) {
-		if (HasSignalOnTrackdir(tile, ReverseTrackdir(track))) {
+		if (HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir))) {
 			// yes, add the signal to the list of signals
 			if (ssd->cur != NUM_SSD_ENTRY) {
 				ssd->tile[ssd->cur] = tile; // remember the tile index
-				ssd->bit[ssd->cur] = track; // and the controlling bit number
+				ssd->bit[ssd->cur] = trackdir; // and the controlling bit number
 				ssd->cur++;
 			}
 			// remember if this block has a presignal.
 			ssd->has_presignal |= IsPresignalEntry(tile);
 		}
-		if (HasSignalOnTrackdir(tile, track) && IsPresignalExit(tile)) {
+		if (HasSignalOnTrackdir(tile, trackdir) && IsPresignalExit(tile)) {
 			// this is an exit signal that points out from the segment
 			ssd->presignal_exits++;
-			if (GetSignalStateByTrackdir(tile, track) != SIGNAL_STATE_RED)
+			if (GetSignalStateByTrackdir(tile, trackdir) != SIGNAL_STATE_RED)
 				ssd->presignal_exits_free++;
 		}
 		return true;
 	} else if (IsTileDepotType(tile, TRANSPORT_RAIL)) {
 	uint track;
 } SignalVehicleCheckStruct;
 static void *SignalVehicleCheckProc(Vehicle *v, void *data)
 {
-	const SignalVehicleCheckStruct* dest = data;
+	const SignalVehicleCheckStruct* dest = (SignalVehicleCheckStruct*)data;
 	if (v->type != VEH_Train) return NULL;
 	/* Wrong tile, or no train? Not a match */
 	if (v->tile != dest->tile) return NULL;
 	return VehicleFromPos(tile, &dest, SignalVehicleCheckProc) != NULL;
 }
 static void SetSignalsAfterProc(TrackPathFinder *tpf)
 {
-	SetSignalsData *ssd = tpf->userdata;
+	SetSignalsData *ssd = (SetSignalsData*)tpf->userdata;
 	const TrackPathFinderLink* link;
 	uint offs;
 	uint i;
 	ssd->stop = false;
 			} while ((offs = link->next) != 0xFFFF);
 		}
 	}
 }
-static const byte _dir_from_track[14] = {
+static const DiagDirection _dir_from_track[14] = {
-	0,1,0,1,2,1, 0,0,
+	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_NE,
-	2,3,3,2,3,0,
+	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE,
 };
 static void ChangeSignalStates(SetSignalsData *ssd)
 {
 	}
 }
 static const byte _fractcoords_behind[4] = { 0x8F, 0x8, 0x80, 0xF8 };
 static const byte _fractcoords_enter[4] = { 0x8A, 0x48, 0x84, 0xA8 };
-static const byte _deltacoord_leaveoffset[8] = {
+static const signed char _deltacoord_leaveoffset[8] = {
 	-1,  0,  1,  0, /* x */
 	 0,  1,  0, -1  /* y */
 };
 static uint32 VehicleEnter_Track(Vehicle *v, TileIndex tile, int x, int y)
 		/* make sure a train is not entering the tile from behind */
 		return 8;
 	} else if (_fractcoords_enter[dir] == fract_coord) {
 		if (DiagDirToDir(ReverseDiagDir(dir)) == v->direction) {
 			/* enter the depot */
-			v->u.rail.track = 0x80,
+			v->u.rail.track = TRACK_BIT_SPECIAL,
 			v->vehstatus |= VS_HIDDEN; /* hide it */
 			v->direction = ReverseDir(v->direction);
 			if (v->next == NULL) VehicleEnterDepot(v);
 			v->tile = tile;
 	} else if (fract_coord_leave == fract_coord) {
 		if (DiagDirToDir(dir) == v->direction) {
 			/* leave the depot? */
 			if ((v = v->next) != NULL) {
 				v->vehstatus &= ~VS_HIDDEN;
-				v->u.rail.track = (DiagDirToAxis(dir) == AXIS_X ? 1 : 2);
+				v->u.rail.track = (DiagDirToAxis(dir) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y);
 			}
 		}
 	}
 	return 0;
 }
-const TileTypeProcs _tile_type_rail_procs = {
+extern const TileTypeProcs _tile_type_rail_procs = {
 	DrawTile_Track,           /* draw_tile_proc */
 	GetSlopeZ_Track,          /* get_slope_z_proc */
 	ClearTile_Track,          /* clear_tile_proc */
 	GetAcceptedCargo_Track,   /* get_accepted_cargo_proc */
 	GetTileDesc_Track,        /* get_tile_desc_proc */

changeset 5838	9c3129cb019b
parent 5835	e0ff603ae0b7
child 5849	58039c9dc565