openttd-mini: comparison src/pathfind.cpp

equal deleted inserted replaced

-:2d4126d81ebb
+:167d9a91ef02
 	0x16,
 	0x25,
 	0x2A,
 };
-static const byte _tpf_new_direction[14] = {
+static const DiagDirection _tpf_new_direction[14] = {
-	0, 1, 0, 1, 2, 1,
+	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE,
-	0, 0,
+	INVALID_DIAGDIR, INVALID_DIAGDIR,
-	2, 3, 3, 2, 3, 0,
+	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE,
 };
-static const byte _tpf_prev_direction[14] = {
+static const DiagDirection _tpf_prev_direction[14] = {
-	0, 1, 1, 0, 1, 2,
+	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW,
-	0, 0,
+	INVALID_DIAGDIR, INVALID_DIAGDIR,
-	2, 3, 2, 3, 0, 3,
+	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE, DIAGDIR_NW,
 };
 static const byte _otherdir_mask[4] = {
 	0x10,
 			}
 			tpf->rd.pft_var6 = (byte)i;
 		}
 continue_here:;
-		tpf->the_dir = 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]);
 		}
 		if (!tpf->disable_tile_hash || (tpf->rd.cur_length <= 64 && (KILL_FIRST_BIT(bits) == 0 || ++tpf->rd.depth <= 7))) {
 			do {
 				i = FIND_FIRST_BIT(bits);
 				bits = KILL_FIRST_BIT(bits);
-				tpf->the_dir = (_otherdir_mask[direction] & (byte)(1 << i)) ? (i+8) : i;
+				tpf->the_dir = (Trackdir)((_otherdir_mask[direction] & (byte)(1 << i)) ? (i+8) : i);
 				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) ) {
 					TPFMode1(tpf, tile, _tpf_new_direction[tpf->the_dir]);
 	do {
 		i = FIND_FIRST_BIT(bits);
 		bits = KILL_FIRST_BIT(bits);
-		tpf->the_dir = (_otherdir_mask[direction] & (byte)(1 << i)) ? (i+8) : i;
+		tpf->the_dir = (Trackdir)((_otherdir_mask[direction] & (byte)(1 << i)) ? (i+8) : i);
 		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) ) {
 			TPFMode1(tpf, tile, _tpf_new_direction[tpf->the_dir]);
 		}
 	tpf.disable_tile_hash = HASBIT(flags, 12);  /* 0x1000 */
 	tpf.hasbit_13         = HASBIT(flags, 13);  /* 0x2000 */
-	tpf.tracktype = (byte)flags;
+	tpf.tracktype = (TransportType)(flags & 0xFF);
 	if (HASBIT(flags, 11)) {
 		tpf.rd.pft_var6 = 0xFF;
-		tpf.enum_proc(tile, data, 0, 0, 0);
+		tpf.enum_proc(tile, data, INVALID_TRACKDIR, 0, 0);
 		TPFMode2(&tpf, tile, direction);
 	} else {
 		/* clear the hash_heads */
 		memset(tpf.hash_head, 0, sizeof(tpf.hash_head));
 		TPFMode1(&tpf, tile, direction);
 typedef struct {
 	TileIndex tile;
 	uint16 cur_length; // This is the current length to this tile.
 	uint16 priority; // This is the current length + estimated length to the goal.
-	byte track;
+	TrackdirByte track;
 	byte depth;
 	byte state;
 	byte first_track;
 } StackedItem;
-static const byte _new_track[6][4] = {
+static const Trackdir _new_trackdir[6][4] = {
-{0,    0xff, 8,    0xff,},
+{TRACKDIR_X_NE,    INVALID_TRACKDIR, TRACKDIR_X_SW,    INVALID_TRACKDIR,},
-{0xff, 1,    0xff, 9,},
+{INVALID_TRACKDIR, TRACKDIR_Y_SE,    INVALID_TRACKDIR, TRACKDIR_Y_NW,},
-{0xff, 2,    10,   0xff,},
+{INVALID_TRACKDIR, TRACKDIR_UPPER_E, TRACKDIR_UPPER_W, INVALID_TRACKDIR,},
-{3,    0xff, 0xff, 11,},
+{TRACKDIR_LOWER_E, INVALID_TRACKDIR, INVALID_TRACKDIR, TRACKDIR_LOWER_W,},
-{12,   4,    0xff, 0xff,},
+{TRACKDIR_LEFT_N,  TRACKDIR_LEFT_S,  INVALID_TRACKDIR, INVALID_TRACKDIR,},
-{0xff, 0xff, 5,    13,},
+{INVALID_TRACKDIR, INVALID_TRACKDIR, TRACKDIR_RIGHT_S, TRACKDIR_RIGHT_N,},
 };
 typedef struct HashLink {
 	TileIndex tile;
 	uint16 typelength;
 		tpf->hash_head[hash] = dir | (length << 2);
 		return true;
 	}
 	if (head != 0xffff) {
-		if (tile == tpf->hash_tile[hash] && (head & 0x3) == dir) {
+		if (tile == tpf->hash_tile[hash] && (head & 0x3) == (uint)dir) {
 			// longer length
 			if (length >= (head >> 2)) return false;
 			tpf->hash_head[hash] = dir | (length << 2);
 		// otherwise make a new link
 		uint offs = tpf->hash_tile[hash];
 		do {
 			link = NTP_GET_LINK_PTR(tpf, offs);
-			if (tile == link->tile && (link->typelength & 0x3U) == dir) {
+			if (tile == link->tile && (link->typelength & 0x3U) == (uint)dir) {
 				if (length >= (uint)(link->typelength >> 2)) return false;
 				link->typelength = dir | (length << 2);
 				return true;
 			}
 		} while ((offs = link->next) != 0xFFFF);
 	0, //14
 };
 static uint DistanceMoo(TileIndex t0, TileIndex t1)
 {
-	const uint dx = abs(TileX(t0) - TileX(t1));
+	const uint dx = delta(TileX(t0), TileX(t1));
-	const uint dy = abs(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:
 // direction is the tile the train is moving towards.
 static void NTPEnum(NewTrackPathFinder* tpf, TileIndex tile, DiagDirection direction)
 {
 	TrackBits bits, allbits;
-	uint track;
+	Trackdir track;
 	TileIndex tile_org;
 	StackedItem si;
 	int estimation;
 							GetTunnelTransportType(tile) != tpf->tracktype) {
 						// We are not driving into the tunnel, or it is an invalid tunnel
 						continue;
 					}
 					if (!HASBIT(tpf->railtypes, GetRailType(tile))) {
-						bits = 0;
+						bits = TRACK_BIT_NONE;
 						break;
 					}
 					flotr = FindLengthOfTunnel(tile, direction);
 					si.cur_length += flotr.length * DIAG_FACTOR;
 					tile = flotr.tile;
 			tile += TileOffsByDiagDir(direction);
 			// too long search length? bail out.
 			if (si.cur_length >= tpf->maxlength) {
 				DEBUG(ntp, 1, "Cur_length too big");
-				bits = 0;
+				bits = TRACK_BIT_NONE;
 				break;
 			}
 			// Not a regular rail tile?
 			// Then we can't use the code below, but revert to more general code.
 			if (!IsTileType(tile, MP_RAILWAY) || !IsPlainRailTile(tile)) {
 				// We found a tile which is not a normal railway tile.
 				// Determine which tracks that exist on this tile.
-				bits = GetTileTrackStatus(tile, TRANSPORT_RAIL) & _tpfmode1_and[direction];
+				uint32 ts = GetTileTrackStatus(tile, TRANSPORT_RAIL) & _tpfmode1_and[direction];
-				bits = (bits | (bits >> 8)) & 0x3F;
+				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 (!HASBIT(tpf->railtypes, IsTileType(tile, MP_STREET) ? GetRailTypeCrossing(tile) : GetRailType(tile))) {
-					bits = 0;
+					bits = TRACK_BIT_NONE;
 					break;
 				}
 				///////////////////
 				// If we reach here, the tile has exactly one track.
 				//   tile - index to a tile that is not rail tile, but still straight (with optional signals)
 				//   bits - bitmask of which track that exist on the tile (exactly one bit is set)
 				//   direction - which direction are we moving in?
 				///////////////////
-				si.track = _new_track[FIND_FIRST_BIT(bits)][direction];
+				si.track = _new_trackdir[FIND_FIRST_BIT(bits)][direction];
 				si.cur_length += _length_of_track[si.track];
 				goto callback_and_continue;
 			}
 			/* Regular rail tile, determine which tracks exist. */
 			bits = allbits & DiagdirReachesTracks(direction);
 			/* 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 == 0 || TracksOverlap(allbits)) break;
+			if (bits == TRACK_BIT_NONE || TracksOverlap(allbits)) break;
 			if (!HASBIT(tpf->railtypes, GetRailType(tile))) {
-				bits = 0;
+				bits = TRACK_BIT_NONE;
 				break;
 			}
 			/* If we reach here, the tile has exactly one track, and this
 			 track is reachable => Rail segment continues */
-			track = _new_track[FIND_FIRST_BIT(bits)][direction];
+			track = _new_trackdir[FIND_FIRST_BIT(bits)][direction];
-			assert(track != 0xff);
+			assert(track != INVALID_TRACKDIR);
 			si.cur_length += _length_of_track[track];
 			// Check if this rail is an upwards slope. If it is, then add a penalty.
 			// Small optimization here.. if (track&7)>1 then it can't be a slope so we avoid calling GetTileSlope
 			// railway tile with signals..?
 			if (HasSignals(tile)) {
 				if (!HasSignalOnTrackdir(tile, track)) {
 					// if one way signal not pointing towards us, stop going in this direction => End of rail segment.
 					if (HasSignalOnTrackdir(tile, ReverseTrackdir(track))) {
-						bits = 0;
+						bits = TRACK_BIT_NONE;
 						break;
 					}
 				} else if (GetSignalStateByTrackdir(tile, track) == SIGNAL_STATE_GREEN) {
 					// green signal in our direction. either one way or two way.
 					si.state |= 3;
 					if (HasSignalOnTrackdir(tile, ReverseTrackdir(track))) {
 						// two way red signal. unless we passed another green signal on the way,
 						// stop going in this direction => End of rail segment.
 						// this is to prevent us from going into a full platform.
 						if (!(si.state&1)) {
-							bits = 0;
+							bits = TRACK_BIT_NONE;
 							break;
 						}
 					}
 					if (!(si.state & 2)) {
 						// Is this the first signal we see? And it's red... add penalty
 			// continue with the next track
 			direction = _tpf_new_direction[track];
 			// safety check if we're running around chasing our tail... (infinite loop)
 			if (tile == tile_org) {
-				bits = 0;
+				bits = TRACK_BIT_NONE;
 				break;
 			}
 		}
 		// There are no tracks to choose between.
 		// Stop searching in this direction
-		if (bits == 0)
+		if (bits == TRACK_BIT_NONE)
 			continue;
 		////////////////
 		// We got multiple tracks to choose between (intersection).
 		// Branch the search space into several branches.
 		si.depth++;
 		if (si.depth == 0)
 			continue; /* We overflowed our depth. No more searching in this direction. */
 		si.tile = tile;
-		do {
+		while (bits != TRACK_BIT_NONE) {
-			si.track = _new_track[FIND_FIRST_BIT(bits)][direction];
+			Track track = RemoveFirstTrack(bits);
+			si.track = _new_trackdir[track][direction];
 			assert(si.track != 0xFF);
 			si.priority = si.cur_length + estimation;
 			// out of stack items, bail out?
 			if (tpf->nstack >= lengthof(tpf->stack)) {
 				break;
 			}
 			tpf->stack[tpf->nstack] = si;
 			HeapifyUp(tpf);
-		} while ((bits = KILL_FIRST_BIT(bits)) != 0);
+		};
 		// If this is the first intersection, we need to fill the first_track member.
 		// so the code outside knows which path is better.
 		// also randomize the order in which we search through them.
 		if (si.depth == 1) {
 			assert(tpf->nstack == 1 || tpf->nstack == 2 || tpf->nstack == 3);
 			if (tpf->nstack != 1) {
 				uint32 r = Random();
-				if (r&1) swap_byte(&tpf->stack[0].track, &tpf->stack[1].track);
+				if (r&1) SwapT(&tpf->stack[0].track, &tpf->stack[1].track);
 				if (tpf->nstack != 2) {
-					byte t = tpf->stack[2].track;
+					TrackdirByte t = tpf->stack[2].track;
-					if (r&2) swap_byte(&tpf->stack[0].track, &t);
+					if (r&2) SwapT(&tpf->stack[0].track, &t);
-					if (r&4) swap_byte(&tpf->stack[1].track, &t);
+					if (r&4) SwapT(&tpf->stack[1].track, &t);
 					tpf->stack[2].first_track = tpf->stack[2].track = t;
 				}
 				tpf->stack[0].first_track = tpf->stack[0].track;
 				tpf->stack[1].first_track = tpf->stack[1].track;
 			}

changeset 5587	167d9a91ef02
parent 5584	1111b4d36e35
child 5598	2fadbd43709d