openttd-ottdgrfs: comparison src/elrail.cpp

equal deleted inserted replaced

-:9a27928bcd5e
+:ebf0ece7d8f6
 #include "table/sprites.h"
 #include "table/elrail_data.h"
 #include "vehicle.h"
 #include "train.h"
 #include "gui.h"
+#include "transparency.h"
 static inline TLG GetTLG(TileIndex t)
 {
-	return (TLG)((HASBIT(TileX(t), 0) << 1) + HASBIT(TileY(t), 0));
+	return (TLG)((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
 */
 	const int *BB_data = _tunnel_wire_BB[dir];
 	AddSortableSpriteToDraw(
 		sss->image, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset,
 		BB_data[2] - sss->x_offset, BB_data[3] - sss->y_offset, BB_Z_SEPARATOR - sss->z_offset + 1,
 		GetTileZ(ti->tile) + sss->z_offset,
-		HASBIT(_transparent_opt, TO_BUILDINGS),
+		IsTransparencySet(TO_BUILDINGS),
 		BB_data[0] - sss->x_offset, BB_data[1] - sss->y_offset, BB_Z_SEPARATOR - sss->z_offset
 	);
 }
 /** Draws wires and, if required, pylons on a given tile
 	 * current tile (home tile) while [1] holds the neighbour */
 	TrackBits trackconfig[TS_END];
 	bool isflat[TS_END];
 	/* Note that ti->tileh has already been adjusted for Foundations */
 	Slope tileh[TS_END] = { ti->tileh, SLOPE_FLAT };
+	/* Half tile slopes coincide only with horizontal/vertical track.
+	 * Faking a flat slope results in the correct sprites on positions. */
+	if (IsHalftileSlope(tileh[TS_HOME])) tileh[TS_HOME] = SLOPE_FLAT;
 	TLG tlg = GetTLG(ti->tile);
 	byte PCPstatus = 0;
 	byte OverridePCP = 0;
 	byte PPPpreferred[DIAGDIR_END];
 				continue;
 			}
 			/* We check whether the track in question (k) is present in the tile
 			 * (TrackSourceTile) */
-			if (HASBIT(trackconfig[TrackSourceTile[i][k]], TracksAtPCP[i][k])) {
+			if (HasBit(trackconfig[TrackSourceTile[i][k]], TracksAtPCP[i][k])) {
 				/* track found, if track is in the neighbour tile, adjust the number
 				 * of the PCP for preferred/allowed determination*/
 				DiagDirection PCPpos = (TrackSourceTile[i][k] == TS_HOME) ? i : ReverseDiagDir(i);
-				SETBIT(PCPstatus, i); // This PCP is in use
+				SetBit(PCPstatus, i); // This PCP is in use
 				PPPpreferred[i] &= PreferredPPPofTrackAtPCP[TracksAtPCP[i][k]][PCPpos];
 				PPPallowed[i] &= ~DisallowedPPPofTrackAtPCP[TracksAtPCP[i][k]][PCPpos];
 			}
 		}
 		/* Deactivate all PPPs if PCP is not used */
-		PPPpreferred[i] *= HASBIT(PCPstatus, i);
+		PPPpreferred[i] *= HasBit(PCPstatus, i);
-		PPPallowed[i] *= HASBIT(PCPstatus, i);
+		PPPallowed[i] *= HasBit(PCPstatus, i);
 		/* 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 */
 		if (IsBridgeTile(neighbour)) {
 			foundation = GetBridgeFoundation(tileh[TS_NEIGHBOUR], DiagDirToAxis(GetBridgeRampDirection(neighbour)));
 		}
 		ApplyFoundationToSlope(foundation, &tileh[TS_NEIGHBOUR]);
+	/* Half tile slopes coincide only with horizontal/vertical track.
+	 * 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++)
-				if (PPPpreferred[i] == IgnoredPCP[k][tlg][i]) CLRBIT(PCPstatus, i);
+				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.
 			Track bridgetrack = GetBridgeAxis(ti->tile) == AXIS_X ? TRACK_X : TRACK_Y;
 			uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile));
 			if ((height <= GetTileMaxZ(ti->tile) + TILE_HEIGHT) &&
 					(i == PCPpositions[bridgetrack][0] || i == PCPpositions[bridgetrack][1])) {
-				SETBIT(OverridePCP, i);
+				SetBit(OverridePCP, i);
 			}
 		}
-		if (PPPallowed[i] != 0 && HASBIT(PCPstatus, i) && !HASBIT(OverridePCP, i)) {
+		if (PPPallowed[i] != 0 && HasBit(PCPstatus, i) && !HasBit(OverridePCP, i)) {
 			for (k = 0; k < DIR_END; k++) {
 				byte temp = PPPorder[i][GetTLG(ti->tile)][k];
-				if (HASBIT(PPPallowed[i], temp)) {
+				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];
 					/* Don't build the pylon if it would be outside the tile */
-					if (!HASBIT(OwnedPPPonPCP[i], temp)) {
+					if (!HasBit(OwnedPPPonPCP[i], temp)) {
 						/* We have a neighour that will draw it, bail out */
 						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),
-							HASBIT(_transparent_opt, TO_BUILDINGS), -1, -1);
+							IsTransparencySet(TO_BUILDINGS), -1, -1);
 					break; /* We already have drawn a pylon, bail out */
 				}
 			}
 		}
 	}
 	/* Don't draw a wire under a low bridge */
-	if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !HASBIT(_transparent_opt, TO_BUILDINGS)) {
+	if (MayHaveBridgeAbove(ti->tile) && IsBridgeAbove(ti->tile) && !IsTransparencySet(TO_BUILDINGS)) {
 		uint height = GetBridgeHeight(GetNorthernBridgeEnd(ti->tile));
 		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++) {
-		if (HASBIT(trackconfig[TS_HOME], 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]) +
+			byte PCPconfig = HasBit(PCPstatus, PCPpositions[t][0]) +
-				(HASBIT(PCPstatus, PCPpositions[t][1]) << 1);
+				(HasBit(PCPstatus, PCPpositions[t][1]) << 1);
 			const SortableSpriteStruct *sss;
 			int tileh_selector = !(tileh[TS_HOME] % 3) * tileh[TS_HOME] / 3; /* tileh for the slopes, 0 otherwise */
 			assert(PCPconfig != 0); /* We have a pylon on neither end of the wire, that doesn't work (since we have no sprites for that) */
 			 * Therefore it is save to use GetSlopeZ() for the elevation.
 			 * Also note, that the result of GetSlopeZ() is very special for bridge-ramps.
 			 */
 			AddSortableSpriteToDraw(sss->image, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset,
 				sss->x_size, sss->y_size, sss->z_size, GetSlopeZ(ti->x + sss->x_offset, ti->y + sss->y_offset) + sss->z_offset,
-				HASBIT(_transparent_opt, TO_BUILDINGS));
+				IsTransparencySet(TO_BUILDINGS));
 		}
 	}
 }
 static void DrawCatenaryOnBridge(const TileInfo *ti)
 	height = GetBridgeHeight(end);
 	AddSortableSpriteToDraw(sss->image, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset,
 		sss->x_size, sss->y_size, sss->z_size, height + sss->z_offset,
-		HASBIT(_transparent_opt, TO_BUILDINGS)
+		IsTransparencySet(TO_BUILDINGS)
 	);
 	/* Finished with wires, draw pylons */
 	/* every other tile needs a pylon on the northern end */
 	if (num % 2) {
 		DiagDirection PCPpos = (axis == AXIS_X ? DIAGDIR_NE : DIAGDIR_NW);
 		Direction PPPpos = (axis == AXIS_X ? DIR_NW : DIR_NE);
-		if (HASBIT(tlg, (axis == AXIS_X ? 0 : 1))) PPPpos = ReverseDir(PPPpos);
+		if (HasBit(tlg, (axis == AXIS_X ? 0 : 1))) PPPpos = ReverseDir(PPPpos);
 		uint x = ti->x + x_pcp_offsets[PCPpos] + x_ppp_offsets[PPPpos];
 		uint y = ti->y + y_pcp_offsets[PCPpos] + y_ppp_offsets[PPPpos];
-		AddSortableSpriteToDraw(pylon_sprites[PPPpos], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, height, HASBIT(_transparent_opt, TO_BUILDINGS), -1, -1);
+		AddSortableSpriteToDraw(pylon_sprites[PPPpos], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, height, IsTransparencySet(TO_BUILDINGS), -1, -1);
 	}
 	/* need a pylon on the southern end of the bridge */
 	if (DistanceMax(ti->tile, start) == length) {
 		DiagDirection PCPpos = (axis == AXIS_X ? DIAGDIR_SW : DIAGDIR_SE);
 		Direction PPPpos = (axis == AXIS_X ? DIR_NW : DIR_NE);
-		if (HASBIT(tlg, (axis == AXIS_X ? 0 : 1))) PPPpos = ReverseDir(PPPpos);
+		if (HasBit(tlg, (axis == AXIS_X ? 0 : 1))) PPPpos = ReverseDir(PPPpos);
 		uint x = ti->x + x_pcp_offsets[PCPpos] + x_ppp_offsets[PPPpos];
 		uint y = ti->y + y_pcp_offsets[PCPpos] + y_ppp_offsets[PPPpos];
-		AddSortableSpriteToDraw(pylon_sprites[PPPpos], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, height, HASBIT(_transparent_opt, TO_BUILDINGS), -1, -1);
+		AddSortableSpriteToDraw(pylon_sprites[PPPpos], PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, height, IsTransparencySet(TO_BUILDINGS), -1, -1);
 	}
 }
 void DrawCatenary(const TileInfo *ti)
 {
 				/* This wire is not visible with the default depot sprites */
 				AddSortableSpriteToDraw(
 					sss->image, PAL_NONE, ti->x + sss->x_offset, ti->y + sss->y_offset,
 					sss->x_size, sss->y_size, sss->z_size,
 					GetTileMaxZ(ti->tile) + sss->z_offset,
-					HASBIT(_transparent_opt, TO_BUILDINGS)
+					IsTransparencySet(TO_BUILDINGS)
 				);
 				return;
 			}
 			break;
 			if (v->type == VEH_TRAIN && v->u.rail.railtype == RAILTYPE_ELECTRIC) {
 				/* this railroad vehicle is now compatible only with elrail,
 				*  so add there also normal rail compatibility */
 				v->u.rail.compatible_railtypes |= (1 << RAILTYPE_RAIL);
 				v->u.rail.railtype = RAILTYPE_RAIL;
-				SETBIT(v->u.rail.flags, VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL);
+				SetBit(v->u.rail.flags, VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL);
 			}
 		}
 	}
 	/* setup total power for trains */

branch	noai
changeset 9722	ebf0ece7d8f6
parent 9703	d2a6acdbd665
child 9723	eee46cb39750