openttd-ottdgrfs: comparison src/pathfind.cpp

equal deleted inserted replaced

-:ca3fd1fbe311
+:5a9dc001e1ad
 };
 static void TPFMode2(TrackPathFinder* tpf, TileIndex tile, DiagDirection direction)
 {
 	uint bits;
-	int i;
 	RememberData rd;
 	assert(tpf->tracktype == TRANSPORT_WATER);
 	/* This addition will sometimes overflow by a single tile.
 	if (bits == 0)
 		return;
 	assert(TileX(tile) != MapMaxX() && TileY(tile) != MapMaxY());
-	if ( (bits & (bits - 1)) == 0 ) {
+	uint i = 0;
-		/* only one direction */
+	/* only one direction */
-		i = 0;
+	if (KillFirstBit(bits) == 0) {
-		while (!(bits & 1))
+		i = FindFirstBit(bits);
-			i++, bits >>= 1;
 		rd = tpf->rd;
 		goto continue_here;
 	}
 	/* several directions */
-	i=0;
 	do {
-		if (!(bits & 1)) continue;
+		i = FindFirstBit(bits);
 		rd = tpf->rd;
 		/* Change direction 4 times only */
 		if ((byte)i != tpf->rd.pft_var6) {
 			if (++tpf->rd.depth > 4) {
 				return;
 			}
 			tpf->rd.pft_var6 = (byte)i;
 		}
-continue_here:;
+continue_here:
-		tpf->the_dir = (Trackdir)(i + (HASBIT(_otherdir_mask[direction], i) ? 8 : 0));
+		tpf->the_dir = (Trackdir)(i + (HasBit(_otherdir_mask[direction], i) ? 8 : 0));
 		if (!tpf->enum_proc(tile, tpf->userdata, tpf->the_dir, tpf->rd.cur_length, NULL)) {
 			TPFMode2(tpf, tile, _tpf_new_direction[tpf->the_dir]);
 		}
 		tpf->rd = rd;
-	} while (++i, bits >>= 1);
+	} while (ClrBit(bits, i) != 0);
 }
 /* Returns the end tile and the length of a tunnel. The length does not
 	tpf->rd.cur_length += flotr.length;
 	TPFSetTileBit(tpf, flotr.tile, 14);
 	return flotr.tile;
 }
-const byte _ffb_64[128] = {
-0,  0,  1,  0,  2,  0,  1,  0,
-3,  0,  1,  0,  2,  0,  1,  0,
-4,  0,  1,  0,  2,  0,  1,  0,
-3,  0,  1,  0,  2,  0,  1,  0,
-5,  0,  1,  0,  2,  0,  1,  0,
-3,  0,  1,  0,  2,  0,  1,  0,
-4,  0,  1,  0,  2,  0,  1,  0,
-3,  0,  1,  0,  2,  0,  1,  0,
-0,  0,  0,  2,  0,  4,  4,  6,
-0,  8,  8, 10,  8, 12, 12, 14,
-0, 16, 16, 18, 16, 20, 20, 22,
-16, 24, 24, 26, 24, 28, 28, 30,
-0, 32, 32, 34, 32, 36, 36, 38,
-32, 40, 40, 42, 40, 44, 44, 46,
-32, 48, 48, 50, 48, 52, 52, 54,
-48, 56, 56, 58, 56, 60, 60, 62,
-};
 static void TPFMode1(TrackPathFinder* tpf, TileIndex tile, DiagDirection direction);
 /** Most code of the "Normal" case of TPF Mode 1; for signals special tricks
 * have to be done, but those happen in TPFMode1; this is just to prevent
 * gotos ;). */
 	uint bits = GetTileTrackStatus(tile, tpf->tracktype, tpf->sub_type);
 	if ((byte)bits != tpf->var2) {
 		bits &= _tpfmode1_and[direction];
-		bits = bits | (bits >> 8);
+		bits |= bits >> 8;
 	}
 	bits &= 0xBF;
 	if (bits != 0) {
-		if (!tpf->disable_tile_hash || (tpf->rd.cur_length <= 64 && (KILL_FIRST_BIT(bits) == 0 || ++tpf->rd.depth <= 7))) {
+		if (!tpf->disable_tile_hash || (tpf->rd.cur_length <= 64 && (KillFirstBit(bits) == 0 || ++tpf->rd.depth <= 7))) {
 			do {
 				int i = FIND_FIRST_BIT(bits);
-				bits = KILL_FIRST_BIT(bits);
+				bits = KillFirstBit(bits);
 				tpf->the_dir = (Trackdir)((_otherdir_mask[direction] & (byte)(1 << i)) ? (i + 8) : i);
 				RememberData rd = tpf->rd;
 				if (TPFSetTileBit(tpf, tile, tpf->the_dir) &&
 	if (bits == 0)
 		return;
 	do {
 		uint i = FIND_FIRST_BIT(bits);
-		bits = KILL_FIRST_BIT(bits);
+		bits = KillFirstBit(bits);
 		tpf->the_dir = (Trackdir)((_otherdir_mask[direction] & (byte)(1 << i)) ? (i + 8) : i);
 		RememberData rd = tpf->rd;
 		if (TPFSetTileBit(tpf, tile, tpf->the_dir) &&
 				!tpf->enum_proc(tile, tpf->userdata, tpf->the_dir, tpf->rd.cur_length, &tpf->rd.pft_var6) ) {
 	tpf.rd.cur_length = 0;
 	tpf.rd.depth = 0;
 	tpf.rd.pft_var6 = 0;
-	tpf.var2 = HASBIT(flags, 15) ? 0x43 : 0xFF; // 0x8000
+	tpf.var2 = HasBit(flags, 15) ? 0x43 : 0xFF; // 0x8000
-	tpf.disable_tile_hash = HASBIT(flags, 12);  // 0x1000
+	tpf.disable_tile_hash = HasBit(flags, 12);  // 0x1000
-	tpf.hasbit_13         = HASBIT(flags, 13);  // 0x2000
+	tpf.hasbit_13         = HasBit(flags, 13);  // 0x2000
 	tpf.tracktype = (TransportType)(flags & 0xFF);
 	tpf.sub_type = sub_type;
-	if (HASBIT(flags, 11)) {
+	if (HasBit(flags, 11)) {
 		tpf.rd.pft_var6 = 0xFF;
 		tpf.enum_proc(tile, data, INVALID_TRACKDIR, 0, 0);
 		TPFMode2(&tpf, tile, direction);
 	} else {
 		/* clear the hash_heads */
 	0,                                           ///< 14
 };
 static uint DistanceMoo(TileIndex t0, TileIndex t1)
 {
-	const uint dx = delta(TileX(t0), TileX(t1));
+	const uint dx = Delta(TileX(t0), TileX(t1));
-	const uint dy = delta(TileY(t0), TileY(t1));
+	const uint dy = Delta(TileY(t0), TileY(t1));
 	const uint straightTracks = 2 * min(dx, dy); // The number of straight (not full length) tracks
 	/* OPTIMISATION:
 	 * Original: diagTracks = max(dx, dy) - min(dx,dy);
 	 * Proof:
 					if (GetTunnelDirection(tile) != direction ||
 							GetTunnelTransportType(tile) != tpf->tracktype) {
 						/* We are not driving into the tunnel, or it is an invalid tunnel */
 						continue;
 					}
-					if (!HASBIT(tpf->railtypes, GetRailType(tile))) {
+					if (!HasBit(tpf->railtypes, GetRailType(tile))) {
 						bits = TRACK_BIT_NONE;
 						break;
 					}
 					flotr = FindLengthOfTunnel(tile, direction);
 					si.cur_length += flotr.length * DIAG_FACTOR;
 				 * Determine which tracks that exist on this tile. */
 				uint32 ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, 0) & _tpfmode1_and[direction];
 				bits = TrackdirBitsToTrackBits((TrackdirBits)(ts & TRACKDIR_BIT_MASK));
 				/* Check that the tile contains exactly one track */
-				if (bits == 0 || KILL_FIRST_BIT(bits) != 0) break;
+				if (bits == 0 || KillFirstBit(bits) != 0) break;
-				if (!HASBIT(tpf->railtypes, GetRailType(tile))) {
+				if (!HasBit(tpf->railtypes, GetRailType(tile))) {
 					bits = TRACK_BIT_NONE;
 					break;
 				}
 				/*******************
 			/* The tile has no reachable tracks => End of rail segment
 			 * or Intersection => End of rail segment. We check this agains all the
 			 * bits, not just reachable ones, to prevent infinite loops. */
 			if (bits == TRACK_BIT_NONE || TracksOverlap(allbits)) break;
-			if (!HASBIT(tpf->railtypes, GetRailType(tile))) {
+			if (!HasBit(tpf->railtypes, GetRailType(tile))) {
 				bits = TRACK_BIT_NONE;
 				break;
 			}
 			/* If we reach here, the tile has exactly one track, and this

branch	NewGRF_ports
changeset 6871	5a9dc001e1ad
parent 6720	35756db7e577
child 6872	1c4a4a609f85