openttd-ottdgrfs: comparison road

equal deleted inserted replaced

-:6cb1b1c2ae6d
+:4c1320da876d
 					if (flags & DC_EXEC) {
 						ChangeTownRating(t, -road_remove_cost[(byte)edge_road], RATING_ROAD_MINIMUM);
 						_m[tile].m5 ^= c;
-						if (GB(_m[tile].m5, 0, 4) == 0) {
+						if (GetRoadBits(tile) == 0) {
 							DoClearSquare(tile);
 						} else {
 							MarkTileDirtyByTile(tile);
 						}
 					}
 			return_cmd_error(INVALID_STRING_ID);
 	}
 }
-static const byte _valid_tileh_slopes_road[3][15] = {
+static const RoadBits _valid_tileh_slopes_road[3][15] = {
 	// set of normal ones
 	{
 		ROAD_ALL, 0, 0,
-		ROAD_SW | ROAD_NE, 0, 0,  // 3, 4, 5
+		ROAD_X,   0, 0,  // 3, 4, 5
-		ROAD_NW | ROAD_SE, 0, 0,
+		ROAD_Y,   0, 0,
-		ROAD_NW | ROAD_SE, 0, 0,  // 9, 10, 11
+		ROAD_Y,   0, 0,  // 9, 10, 11
-		ROAD_SW | ROAD_NE, 0, 0
+		ROAD_X,   0, 0
 	},
 	// allowed road for an evenly raised platform
 	{
 		0,
 		ROAD_SW | ROAD_NW,
 		ROAD_SW | ROAD_SE,
-		ROAD_NW | ROAD_SE | ROAD_SW,
+		ROAD_Y  | ROAD_SW,
 		ROAD_SE | ROAD_NE, // 4
 		ROAD_ALL,
-		ROAD_SW | ROAD_NE | ROAD_SE,
+		ROAD_X  | ROAD_SE,
 		ROAD_ALL,
 		ROAD_NW | ROAD_NE, // 8
-		ROAD_SW | ROAD_NE | ROAD_NW,
+		ROAD_X  | ROAD_NW,
 		ROAD_ALL,
 		ROAD_ALL,
-		ROAD_NW | ROAD_SE | ROAD_NE, // 12
+		ROAD_Y  | ROAD_NE, // 12
 		ROAD_ALL,
 		ROAD_ALL
 	},
 	// valid railway crossings on slopes
 	{
 	cost = 0;
 	tile = start_tile;
 	// Start tile is the small number.
 	for (;;) {
-		uint bits = HASBIT(p2, 2) ? ROAD_SE | ROAD_NW : ROAD_SW | ROAD_NE;
+		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;
 		ret = DoCommandByTile(tile, bits, 0, flags, CMD_BUILD_ROAD);
 		if (CmdFailed(ret)) {
 	cost = 0;
 	tile = start_tile;
 	// Start tile is the small number.
 	for (;;) {
-		uint bits = HASBIT(p2, 2) ? ROAD_SE | ROAD_NW : ROAD_SW | ROAD_NE;
+		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) {
+		if (bits != 0) {
 			ret = DoCommandByTile(tile, bits, 0, flags, CMD_REMOVE_ROAD);
 			if (!CmdFailed(ret)) cost += ret;
 		}
 		if (tile == end_tile) break;
 		dep->town_index = ClosestTownFromTile(tile, (uint)-1)->index;
 		ModifyTile(tile,
 			MP_SETTYPE(MP_STREET) |
 			MP_MAPOWNER_CURRENT | MP_MAP5,
-			(p1 | 0x20) /* map5 */
+			(ROAD_DEPOT << 4) | p1 /* map5 */
 		);
 	}
 	return cost + _price.build_road_depot;
 }
 } DrawRoadSeqStruct;
 #include "table/road_land.h"
-uint GetRoadFoundation(uint tileh, uint bits)
+uint GetRoadFoundation(uint tileh, RoadBits bits)
 {
 	int i;
 	// normal level sloped building
 	if ((~_valid_tileh_slopes_road[1][tileh] & bits) == 0) return tileh;
 				(i  = 0, tileh == 1) ||
 				(i += 2, tileh == 2) ||
 				(i += 2, tileh == 4) ||
 				(i += 2, tileh == 8)
 			) && (
-				(     bits == (ROAD_SW | ROAD_NE)) ||
+				(     bits == ROAD_X) ||
-				(i++, bits == (ROAD_NW | ROAD_SE))
+				(i++, bits == ROAD_Y)
 			)) {
 		return i + 15;
 	}
 	return 0;
 * @param road RoadBits to draw
 * @param ground_type Ground type
 * @param snow Draw snow
 * @param flat Draw foundation
 */
-static void DrawRoadBits(TileInfo *ti, byte road, byte ground_type, bool snow, bool flat)
+static void DrawRoadBits(TileInfo* ti, RoadBits road, byte ground_type, bool snow, bool flat)
 {
 	const DrawRoadTileStruct *drts;
 	PalSpriteID image = 0;
 	if (ti->tileh != 0) {
 	// Return if full detail is disabled, or we are zoomed fully out.
 	if (!(_display_opt & DO_FULL_DETAIL) || _cur_dpi->zoom == 2) return;
 	if (ground_type >= 6) {
 		// Road works
-		DrawGroundSprite(HASBIT(road, 3) ? SPR_EXCAVATION_X : SPR_EXCAVATION_Y);
+		DrawGroundSprite(road & ROAD_X ? SPR_EXCAVATION_X : SPR_EXCAVATION_Y);
 		return;
 	}
 	// Draw extra details.
 	for (drts = _road_display_table[ground_type][road]; drts->image != 0; drts++) {
 static void DrawTile_Road(TileInfo *ti)
 {
 	PalSpriteID image;
 	uint16 m2;
-	switch (GB(ti->map5, 4, 4)) {
+	switch (GetRoadType(ti->tile)) {
-		case 0: // normal road
+		case ROAD_NORMAL:
-			DrawRoadBits(ti, GB(ti->map5, 0, 4), GB(_m[ti->tile].m4, 4, 3), HASBIT(_m[ti->tile].m4, 7), false);
+			DrawRoadBits(ti, GetRoadBits(ti->tile), GB(_m[ti->tile].m4, 4, 3), HASBIT(_m[ti->tile].m4, 7), false);
 			break;
-		case 1: { // level crossing
+		case ROAD_CROSSING: {
 			if (ti->tileh != 0) DrawFoundation(ti, ti->tileh);
 			image = GetRailTypeInfo(GB(_m[ti->tile].m4, 0, 4))->base_sprites.crossing;
 			if (GB(ti->map5, 3, 1) == 0) image++; /* direction */
 			DrawGroundSprite(image);
 			break;
 		}
-		default: { // depot
+		default:
+		case ROAD_DEPOT: {
 			uint32 ormod;
 			PlayerID player;
 			const DrawRoadSeqStruct* drss;
 			if (ti->tileh != 0) DrawFoundation(ti, ti->tileh);
 	uint z = ti->z;
 	int th = ti->tileh;
 	// check if it's a foundation
 	if (ti->tileh != 0) {
-		switch (GB(ti->map5, 4, 4)) {
+		switch (GetRoadType(ti->tile)) {
-			case 0: { // normal road
+			case ROAD_NORMAL: {
-				uint f = GetRoadFoundation(ti->tileh, GB(ti->map5, 0, 4));
+				uint f = GetRoadFoundation(ti->tileh, GetRoadBits(ti->tile));
 				if (f != 0) {
 					if (f < 15) {
 						// leveled foundation
 						return z + 8;
 					}
 				}
 				break;
 			}
 			// if these are on a slope then there's a level foundation
-			case 1: // level crossing
+			case ROAD_DEPOT:
-			case 2: // depot
+			case ROAD_CROSSING:
 				return z + 8;
 			default: break;
 		}
 		return GetPartialZ(ti->x&0xF, ti->y&0xF, th) + z;
 static uint GetSlopeTileh_Road(const TileInfo *ti)
 {
 	// check if it's a foundation
 	if (ti->tileh != 0) {
-		switch (GB(ti->map5, 4, 4)) {
+		switch (GetRoadType(ti->tile)) {
-			case 0: { // normal road
+			case ROAD_NORMAL: {
-				uint f = GetRoadFoundation(ti->tileh, GB(ti->map5, 0, 4));
+				uint f = GetRoadFoundation(ti->tileh, GetRoadBits(ti->tile));
 				if (f != 0) {
 					if (f < 15) {
 						// leveled foundation
 						return 0;
 					}
 				}
 				break;
 			}
 			// if these are on a slope then there's a level foundation
-			case 1: // level crossing
+			case ROAD_CROSSING:
-			case 2: // depot
+			case ROAD_DEPOT:
 				return 0;
 			default: break;
 		}
 	}
 			case ROAD_CROSSING:
 				SetTileOwner(tile, _m[tile].m3);
 				_m[tile].m3 = 0;
 				_m[tile].m4 &= 0x80;
-				_m[tile].m5 = GetCrossingRoadBits(tile);
+				_m[tile].m5 = (ROAD_NORMAL << 4) | GetCrossingRoadBits(tile);
 				break;
 			default:
 			case ROAD_DEPOT:
 				DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);

changeset 3098	4c1320da876d
parent 3097	6cb1b1c2ae6d
child 3099	374e275300e3