openttd-mini: comparison src/elrail.cpp

equal deleted inserted replaced

-:506e4aef33b6
+:7e8b8f37259a
 	TLG tlg = GetTLG(ti->tile);
 	byte PCPstatus = 0;
 	byte OverridePCP = 0;
 	byte PPPpreferred[DIAGDIR_END];
 	byte PPPallowed[DIAGDIR_END];
-	DiagDirection i;
-	Track t;
 	/* Find which rail bits are present, and select the override points.
 	 * We don't draw a pylon:
 	 * 1) INSIDE a tunnel (we wouldn't see it anyway)
 	 * 2) on the "far" end of a bridge head (the one that connects to bridge middle),
 	/* If a track bit is present that is not in the main direction, the track is level */
 	isflat[TS_HOME] = ((trackconfig[TS_HOME] & (TRACK_BIT_HORZ | TRACK_BIT_VERT)) != 0);
 	AdjustTileh(ti->tile, &tileh[TS_HOME]);
-	for (i = DIAGDIR_NE; i < DIAGDIR_END; i++) {
+	for (DiagDirection i = DIAGDIR_NE; i < DIAGDIR_END; i++) {
 		TileIndex neighbour = ti->tile + TileOffsByDiagDir(i);
 		Foundation foundation = FOUNDATION_NONE;
-		int k;
+		byte elevation = GetPCPElevation(ti->tile, i);
 		/* Here's one of the main headaches. GetTileSlope does not correct for possibly
 		 * existing foundataions, so we do have to do that manually later on.*/
 		tileh[TS_NEIGHBOUR] = GetTileSlope(neighbour, NULL);
 		trackconfig[TS_NEIGHBOUR] = GetRailTrackBitsUniversal(neighbour, NULL);
 		if (IsTunnelTile(neighbour) && i != GetTunnelBridgeDirection(neighbour)) trackconfig[TS_NEIGHBOUR] = TRACK_BIT_NONE;
 		/* If the neighboured tile does not smoothly connect to the current tile (because of a foundation),
 		 * we have to draw all pillars on the current tile. */
-		if (GetPCPElevation(ti->tile, i) != GetPCPElevation(neighbour, ReverseDiagDir(i))) trackconfig[TS_NEIGHBOUR] = TRACK_BIT_NONE;
+		if (elevation != GetPCPElevation(neighbour, ReverseDiagDir(i))) trackconfig[TS_NEIGHBOUR] = TRACK_BIT_NONE;
 		isflat[TS_NEIGHBOUR] = ((trackconfig[TS_NEIGHBOUR] & (TRACK_BIT_HORZ | TRACK_BIT_VERT)) != 0);
 		PPPpreferred[i] = 0xFF; // We start with preferring everything (end-of-line in any direction)
 		PPPallowed[i] = AllowedPPPonPCP[i];
 		/* We cycle through all the existing tracks at a PCP and see what
 		 * PPPs we want to have, or may not have at all */
-		for (k = 0; k < NUM_TRACKS_AT_PCP; k++) {
+		for (uint k = 0; k < NUM_TRACKS_AT_PCP; k++) {
 			/* Next to us, we have a bridge head, don't worry about that one, if it shows away from us */
 			if (TrackSourceTile[i][k] == TS_NEIGHBOUR &&
 			    IsBridgeTile(neighbour) &&
 			    GetTunnelBridgeDirection(neighbour) == ReverseDiagDir(i)) {
 				continue;
 				PPPallowed[i] &= ~DisallowedPPPofTrackAtPCP[TracksAtPCP[i][k]][PCPpos];
 			}
 		}
 		/* Deactivate all PPPs if PCP is not used */
-		PPPpreferred[i] *= HasBit(PCPstatus, i);
+		if (!HasBit(PCPstatus, i)) {
-		PPPallowed[i] *= HasBit(PCPstatus, i);
+			PPPpreferred[i] = 0;
+			PPPallowed[i] = 0;
+		}
 		/* A station is always "flat", so adjust the tileh accordingly */
 		if (IsTileType(neighbour, MP_STATION)) tileh[TS_NEIGHBOUR] = SLOPE_FLAT;
 		/* Read the foundataions if they are present, and adjust the tileh */
 			foundation = GetBridgeFoundation(tileh[TS_NEIGHBOUR], DiagDirToAxis(GetTunnelBridgeDirection(neighbour)));
 		}
 		ApplyFoundationToSlope(foundation, &tileh[TS_NEIGHBOUR]);
-	/* Half tile slopes coincide only with horizontal/vertical track.
+		/* Half tile slopes coincide only with horizontal/vertical track.
-	 * Faking a flat slope results in the correct sprites on positions. */
+		 * Faking a flat slope results in the correct sprites on positions. */
 		if (IsHalftileSlope(tileh[TS_NEIGHBOUR])) tileh[TS_NEIGHBOUR] = SLOPE_FLAT;
 		AdjustTileh(neighbour, &tileh[TS_NEIGHBOUR]);
 		/* If we have a straight (and level) track, we want a pylon only every 2 tiles
 		 * Delete the PCP if this is the case. */
 		/* Level means that the slope is the same, or the track is flat */
 		if (tileh[TS_HOME] == tileh[TS_NEIGHBOUR] || (isflat[TS_HOME] && isflat[TS_NEIGHBOUR])) {
-			for (k = 0; k < NUM_IGNORE_GROUPS; k++)
+			for (uint k = 0; k < NUM_IGNORE_GROUPS; k++) {
 				if (PPPpreferred[i] == IgnoredPCP[k][tlg][i]) ClrBit(PCPstatus, i);
+			}
 		}
 		/* Now decide where we draw our pylons. First try the preferred PPPs, but they may not exist.
 		 * In that case, we try the any of the allowed ones. if they don't exist either, don't draw
 		 * anything. Note that the preferred PPPs still contain the end-of-line markers.
 				SetBit(OverridePCP, i);
 			}
 		}
 		if (PPPallowed[i] != 0 && HasBit(PCPstatus, i) && !HasBit(OverridePCP, i)) {
-			for (k = 0; k < DIR_END; k++) {
+			for (Direction k = DIR_BEGIN; k < DIR_END; k++) {
 				byte temp = PPPorder[i][GetTLG(ti->tile)][k];
 				if (HasBit(PPPallowed[i], temp)) {
 					uint x  = ti->x + x_pcp_offsets[i] + x_ppp_offsets[temp];
 					uint y  = ti->y + y_pcp_offsets[i] + y_ppp_offsets[temp];
 						if (trackconfig[TS_NEIGHBOUR] != 0) break;
 						continue; /* No neighbour, go looking for a better position */
 					}
 					AddSortableSpriteToDraw(pylon_sprites[temp], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE,
-							GetPCPElevation(ti->tile, i),
+						elevation, IsTransparencySet(TO_CATENARY), -1, -1);
-							IsTransparencySet(TO_CATENARY), -1, -1);
 					break; /* We already have drawn a pylon, bail out */
 				}
 			}
 		}
 	}
 		if (height <= GetTileMaxZ(ti->tile) + TILE_HEIGHT) return;
 	}
 	/* Drawing of pylons is finished, now draw the wires */
-	for (t = TRACK_BEGIN; t < TRACK_END; t++) {
+	for (Track t = TRACK_BEGIN; t < TRACK_END; t++) {
 		if (HasBit(trackconfig[TS_HOME], t)) {
 			if (IsTunnelTile(ti->tile)) break; // drawn together with tunnel-roof (see DrawCatenaryOnTunnel())
 			byte PCPconfig = HasBit(PCPstatus, PCPpositions[t][0]) +
 				(HasBit(PCPstatus, PCPpositions[t][1]) << 1);

changeset 9035	7e8b8f37259a
parent 9034	506e4aef33b6
child 9070	dd0121143eba