openttd-ottdgrfs: comparison src/town

equal deleted inserted replaced

-:e782b59f1f6a
+:d2a6acdbd665
 #include "newgrf_callbacks.h"
 #include "newgrf_house.h"
 #include "newgrf_commons.h"
 #include "newgrf_townname.h"
 #include "misc/autoptr.hpp"
+#include "autoslope.h"
 /* Initialize the town-pool */
 DEFINE_OLD_POOL_GENERIC(Town, Town)
 Town::Town(TileIndex tile)
 	variant ^= x >> 6;
 	variant ^= y >> 4;
 	variant -= y >> 6;
 	variant &= 3;
 	return variant;
+}
+/**
+* Return a random direction
+*
+* @return a random direction
+*/
+static inline DiagDirection RandomDiagDir()
+{
+	return (DiagDirection)(3 & Random());
+}
+/**
+* Move a TileIndex into a diagonal direction.
+*
+* @param tile The current tile
+* @param dir The direction in which we want to step
+* @return the moved tile
+*/
+static inline TileIndex AddDiagDirToTileIndex(TileIndex tile, DiagDirection dir)
+{
+	return TILE_ADD(tile, TileOffsByDiagDir(dir));
 }
 /**
 * House Tile drawing handler.
 * Part of the tile loop process
 	image = dcts->building.sprite;
 	if (image != 0) {
 		AddSortableSpriteToDraw(image, dcts->building.pal,
 			ti->x + dcts->subtile_x,
 			ti->y + dcts->subtile_y,
-			dcts->width + 1,
+			dcts->width,
-			dcts->height + 1,
+			dcts->height,
 			dcts->dz,
 			ti->z,
 			HASBIT(_transparent_opt, TO_HOUSES)
 		);
 	}
 	return false;
 }
 /**
-* Marks the town sign as needing a repaint
+* Marks the town sign as needing a repaint.
-* @param t Town requesting repaint
+*
+* This function marks the area of the sign of a town as dirty for repaint.
+*
+* @param t Town requesting town sign for repaint
+* @ingroup dirty
 */
 static void MarkTownSignDirty(Town *t)
 {
 	MarkAllViewportsDirty(
 		t->sign.left - 6,
 static void ChangeTileOwner_Town(TileIndex tile, PlayerID old_player, PlayerID new_player)
 {
 	/* not used */
 }
-static const TileIndexDiffC _roadblock_tileadd[] = {
-	{ 0, -1},
-	{ 1,  0},
-	{ 0,  1},
-	{-1,  0},
-	/* Store the first 3 elements again.
-	 * Lets us rotate without using &3. */
-	{ 0, -1},
-	{ 1,  0},
-	{ 0,  1}
-};
-/**
-* Distance multiplyer
-* Defines the possible distances between 2 road tiles
-*/
-enum RoadBlockTitleDistance {
-	RB_TILE_DIST1 = 1, ///< 1 tile between
-	RB_TILE_DIST2,     ///< 2 tiles between
-};
 static bool GrowTown(Town *t);
 static void TownTickHandler(Town *t)
 {
 	if (HASBIT(t->flags12, TOWN_IS_FUNDED)) {
 		if (IsValidTownID(i)) TownTickHandler(GetTown(i));
 	}
 }
-static RoadBits GetTownRoadMask(TileIndex tile)
+/**
+* Return the RoadBits of a tile
+*
+* @note There are many other functions doing things like that.
+* @note Needs to be checked for needlessness.
+* @param tile The tile we want to analyse
+* @return The roadbits of the given tile
+*/
+static RoadBits GetTownRoadBits(TileIndex tile)
 {
 	TrackBits b = GetAnyRoadTrackBits(tile, ROADTYPE_ROAD);
 	RoadBits r = ROAD_NONE;
 	if (b == TRACK_BIT_NONE) return r;
 *
 * @param tile curent tile
 * @param dir target direction
 * @param dist_multi distance multiplyer
 * @return true if one of the neighboring tiles at the
-*  given distance is a road tile else
+*  given distance is a road tile else false
 */
-static bool IsNeighborRoadTile(TileIndex tile, int dir, RoadBlockTitleDistance dist_multi)
+static bool IsNeighborRoadTile(TileIndex tile, DiagDirection dir, uint dist_multi)
 {
-	return (HASBIT(GetTownRoadMask(TILE_ADD(tile, dist_multi * ToTileIndexDiff(_roadblock_tileadd[dir + 1]))), dir ^ 2) ||
+	static TileIndexDiff tid_lt[3]; ///< lookup table for the used diff values
-			HASBIT(GetTownRoadMask(TILE_ADD(tile, dist_multi * ToTileIndexDiff(_roadblock_tileadd[dir + 3]))), dir ^ 2) ||
+	tid_lt[0] = TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90RIGHT));
-			HASBIT(GetTownRoadMask(TILE_ADD(tile, dist_multi * (ToTileIndexDiff(_roadblock_tileadd[dir + 1]) + ToTileIndexDiff(_roadblock_tileadd[dir + 2])))), dir) ||
+	tid_lt[1] = TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90LEFT));
-			HASBIT(GetTownRoadMask(TILE_ADD(tile, dist_multi * (ToTileIndexDiff(_roadblock_tileadd[dir + 3]) + ToTileIndexDiff(_roadblock_tileadd[dir + 2])))), dir));
+	tid_lt[2] = TileOffsByDiagDir(ReverseDiagDir(dir));
-}
+	/* We add 1 to the distance because we want to get 1 for
-static bool IsRoadAllowedHere(TileIndex tile, int dir)
+	 * the min distance multiplyer and not 0.
+	 * Therefore we start at 4. The 4 is used because
+	 * there are 4 tiles per distance step to check.
+	 */
+	dist_multi = (dist_multi + 1) * 4;
+	for (uint pos = 4; pos < dist_multi; pos++) {
+		TileIndexDiff cur = 0;
+		/* For each even value of pos add the right TileIndexDiff
+		 * for each uneven value the left TileIndexDiff
+		 * for each with 2nd bit set (2,3,6,7,..) add the reversed TileIndexDiff
+		 */
+		cur += tid_lt[(pos & 1) ? 0 : 1];
+		if (pos & 2) cur += tid_lt[2];
+		cur = (uint)(pos / 4) * cur; ///< Multiply for the fitting distance
+		if (GetTownRoadBits(TILE_ADD(tile, cur)) & DiagDirToRoadBits((pos & 2) ? dir : ReverseDiagDir(dir))) return true;
+	}
+	return false;
+}
+/**
+* Check if a Road is allowed on a given tile
+*
+* @param tile The target tile
+* @param dir The direction in which we want to extend the town
+* @return true if it is allowed else false
+*/
+static bool IsRoadAllowedHere(TileIndex tile, DiagDirection dir)
 {
 	if (TileX(tile) < 2 || TileY(tile) < 2 || MapMaxX() <= TileX(tile) || MapMaxY() <= TileY(tile)) return false;
-	Slope k;
+	Slope cur_slope, desired_slope;
-	Slope slope;
 	/* If this assertion fails, it might be because the world contains
 	 *  land at the edges. This is not ok. */
 	TILE_ASSERT(tile);
 	for (;;) {
 		/* Check if there already is a road at this point? */
-		if (GetAnyRoadTrackBits(tile, ROADTYPE_ROAD) == 0) {
+		if (GetTownRoadBits(tile) == ROAD_NONE) {
 			/* No, try to build one in the direction.
 			 * if that fails clear the land, and if that fails exit.
 			 * This is to make sure that we can build a road here later. */
-			if (CmdFailed(DoCommand(tile, (dir & ROAD_NW ? ROAD_X : ROAD_Y), 0, DC_AUTO, CMD_BUILD_ROAD)) &&
+			if (CmdFailed(DoCommand(tile, ((dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? ROAD_X : ROAD_Y), 0, DC_AUTO, CMD_BUILD_ROAD)) &&
 					CmdFailed(DoCommand(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR)))
 				return false;
 		}
-		slope = GetTileSlope(tile, NULL);
+		cur_slope = GetTileSlope(tile, NULL);
-		if (slope == SLOPE_FLAT) {
+		if (cur_slope == SLOPE_FLAT) {
 no_slope:
 			/* Tile has no slope */
 			switch (_patches.town_layout) {
 				default: NOT_REACHED();
 				case TL_ORIGINAL: /* Disallow the road if any neighboring tile has a road (distance: 1) */
-					return !IsNeighborRoadTile(tile, dir, RB_TILE_DIST1);
+					return !IsNeighborRoadTile(tile, dir, 1);
 				case TL_BETTER_ROADS: /* Disallow the road if any neighboring tile has a road (distance: 1 and 2). */
-					return !(IsNeighborRoadTile(tile, dir, RB_TILE_DIST1) ||
+					return !IsNeighborRoadTile(tile, dir, 2);
-							IsNeighborRoadTile(tile, dir, RB_TILE_DIST2));
 			}
 		}
 		/* If the tile is not a slope in the right direction, then
 		 * maybe terraform some. */
-		k = (dir & ROAD_NW) ? SLOPE_NE : SLOPE_NW;
+		desired_slope = (dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? SLOPE_NE : SLOPE_NW;
-		if (k != slope && ComplementSlope(k) != slope) {
+		if (desired_slope != cur_slope && ComplementSlope(desired_slope) != cur_slope) {
 			uint32 r = Random();
 			if (CHANCE16I(1, 8, r) && !_generating_world) {
 				CommandCost res;
 				if (CHANCE16I(1, 16, r)) {
-					res = DoCommand(tile, slope, 0, DC_EXEC | DC_AUTO | DC_NO_WATER,
+					res = DoCommand(tile, cur_slope, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
-					                      CMD_TERRAFORM_LAND);
 				} else {
 					/* Note: Do not replace " ^ 0xF" with ComplementSlope(). The slope might be steep. */
-					res = DoCommand(tile, slope ^ 0xF, 1, DC_EXEC | DC_AUTO | DC_NO_WATER,
+					res = DoCommand(tile, cur_slope ^ 0xF, 1, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
-					                      CMD_TERRAFORM_LAND);
 				}
 				if (CmdFailed(res) && CHANCE16I(1, 3, r)) {
 					/* We can consider building on the slope, though. */
 					goto no_slope;
 				}
 /**
 * Generate the RoadBits of a grid tile
 *
 * @param t current town
 * @param tile tile in reference to the town
+* @param dir The direction to which we are growing ATM
 * @return the RoadBit of the current tile regarding
 *  the selected town layout
 */
-static RoadBits GetTownRoadGridElement(Town* t, TileIndex tile)
+static RoadBits GetTownRoadGridElement(Town* t, TileIndex tile, DiagDirection dir)
 {
 	/* align the grid to the downtown */
 	TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile); ///< Vector from downtown to the tile
+	RoadBits rcmd = ROAD_NONE;
-	/* lx, ly description:
-	 * @li lx and ly are true  if the tile is a crossing tile.
-	 * @li lx xor ly are true  if the tile is a straight road tile.
-	 * @li lx and ly are false if the tile is a house tile.
-	 */
-	bool lx, ly;
 	switch (_patches.town_layout) {
 		default: NOT_REACHED();
 		case TL_2X2_GRID:
-			lx = ((grid_pos.x % 3) == 0);
+			if ((grid_pos.x % 3) == 0) rcmd |= ROAD_Y;
-			ly = ((grid_pos.y % 3) == 0);
+			if ((grid_pos.y % 3) == 0) rcmd |= ROAD_X;
 			break;
 		case TL_3X3_GRID:
-			lx = ((grid_pos.x % 4) == 0);
+			if ((grid_pos.x % 4) == 0) rcmd |= ROAD_Y;
-			ly = ((grid_pos.y % 4) == 0);
+			if ((grid_pos.y % 4) == 0) rcmd |= ROAD_X;
 			break;
 	}
-	/* generate the basic grid structure */
+	/* Stop if the tile is not a part of the grid lines */
-	if (!lx && !ly) {         ///< It is a house tile
+	if (rcmd == ROAD_NONE) return rcmd;
-		return ROAD_NONE;
-	} else if (lx && !ly) {   ///< It is a Y-dir road tile
+	/* Optimise only X-junctions */
-		return ROAD_Y;
+	if (COUNTBITS(rcmd) != 2) {
-	} else if (!lx && ly) {   ///< It is a X-dir road tile
+		RoadBits rb_template;
-		return ROAD_X;
-	} else {                  ///< It is a crossing tile
-		/* Presets for junctions on slopes
-		 * not nice :( */
 		switch (GetTileSlope(tile, NULL)) {
-			case SLOPE_W:
+			default:       rb_template = ROAD_ALL; break;
-				return ROAD_NW | ROAD_SW;
+			case SLOPE_W:  rb_template = ROAD_NW | ROAD_SW; break;
-			case SLOPE_S:
+			case SLOPE_SW: rb_template = ROAD_Y  | ROAD_SW; break;
-				return ROAD_SE | ROAD_SW;
+			case SLOPE_S:  rb_template = ROAD_SW | ROAD_SE; break;
-			case SLOPE_SW:
+			case SLOPE_SE: rb_template = ROAD_X  | ROAD_SE; break;
-				return ROAD_Y | ROAD_SW;
+			case SLOPE_E:  rb_template = ROAD_SE | ROAD_NE; break;
-			case SLOPE_E:
+			case SLOPE_NE: rb_template = ROAD_Y  | ROAD_NE; break;
-				return ROAD_NE | ROAD_SE;
+			case SLOPE_N:  rb_template = ROAD_NE | ROAD_NW; break;
-			case SLOPE_SE:
+			case SLOPE_NW: rb_template = ROAD_X  | ROAD_NW; break;
-				return ROAD_X | ROAD_SE;
-			case SLOPE_N:
-				return ROAD_NW | ROAD_NE;
-			case SLOPE_NW:
-				return ROAD_X | ROAD_NW;
-			case SLOPE_NE:
-				return ROAD_Y | ROAD_NE;
 			case SLOPE_STEEP_W:
-			case SLOPE_STEEP_N:
-				return ROAD_X;
 			case SLOPE_STEEP_S:
 			case SLOPE_STEEP_E:
-				return ROAD_Y;
+			case SLOPE_STEEP_N:
-			default:
+				rb_template = ROAD_NONE;
-				return ROAD_ALL;
+				break;
 		}
-	}
+		/* Stop if the template is compatible to the growth dir */
+		if (DiagDirToRoadBits(ReverseDiagDir(dir)) & rb_template) return rb_template;
+		/* If not generate a straight road in the direction of the growth */
+		return DiagDirToRoadBits(dir) | DiagDirToRoadBits(ReverseDiagDir(dir));
+	}
+	return rcmd;
 }
 /**
-* Check there are enougth neighbor house tiles next to the current tile
+* Check there are enough neighbor house tiles next to the current tile
 *
 * @param tile current tile
 * @return true if there are more than 2 house tiles next
 *  to the current one
 */
 	if (TileX(tile) < 1 || TileY(tile) < 1) {
 		return false;
 	}
 	/* Check the tiles E,N,W and S of the current tile. */
-	for (uint i = 0; i < 4; i++) {
+	for (DiagDirection i = DIAGDIR_BEGIN; i < DIAGDIR_END; i++) {
-		if (IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[i])), MP_HOUSE)) {
+		if (IsTileType(AddDiagDirToTileIndex(tile, i), MP_HOUSE)) {
 			counter++;
 		}
 		/* If there are enougth neighbor's stop it here */
 		if (counter >= 3) {
 * 	@li TL_2X2_GRID
 * 	@li TL_3X3_GRID
 * @li Forbid roads, only build houses
 * 	@li TL_NO_ROADS
 *
-* @param tile_ptr current tile
+* @param tile_ptr The current tile
-* @param mask current tiles RoadBits
+* @param cur_rb The current tiles RoadBits
-* @param block road block
+* @param target_dir The target road dir
-* @param t1 current town
+* @param t1 The current town
 */
-static void GrowTownInTile(TileIndex* tile_ptr, RoadBits mask, int block, Town* t1)
+static void GrowTownInTile(TileIndex* tile_ptr, RoadBits cur_rb, DiagDirection target_dir, Town* t1)
 {
-	RoadBits rcmd;
+	RoadBits rcmd = ROAD_NONE;  ///< RoadBits for the road construction command
-	TileIndex tmptile;
+	TileIndex tmptile;          ///< Dummy tile for various things
-	DiagDirection i;
+	TileIndex tile = *tile_ptr; ///< The main tile on which we base our growth
-	int j;
-	TileIndex tile = *tile_ptr;
 	TILE_ASSERT(tile);
-	if (mask == 0) {
+	if (cur_rb == ROAD_NONE) {
-		int a;
-		int b;
 		/* Tile has no road. First reset the status counter
 		 * to say that this is the last iteration. */
 		_grow_town_result = 0;
 		/* Remove hills etc */
 			case TL_NO_ROADS: /* Disallow Roads */
 				return;
 			case TL_3X3_GRID:
 			case TL_2X2_GRID:
-				rcmd = GetTownRoadGridElement(t1, tile);
+				rcmd = GetTownRoadGridElement(t1, tile, target_dir);
-				if (rcmd == ROAD_NONE) {
+				if (rcmd == ROAD_NONE) return;
-					return;
-				}
 				break;
 			case TL_BETTER_ROADS:
 			case TL_ORIGINAL:
-				if (!IsRoadAllowedHere(tile, block)) {
+				if (!IsRoadAllowedHere(tile, target_dir)) return;
-					return;
+				DiagDirection source_dir = ReverseDiagDir(target_dir);
+				if (CHANCE16(1, 4)) {
+					/* Randomize a new target dir */
+					do target_dir = RandomDiagDir(); while (target_dir == source_dir);
 				}
-				/* Randomize new road block numbers */
+				if (!IsRoadAllowedHere(AddDiagDirToTileIndex(tile, target_dir), target_dir)) {
-				a = block;
-				b = block ^ 2;
-				if (CHANCE16(1, 4)) {
-					do {
-						a = GB(Random(), 0, 2);
-					} while (a == b);
-				}
-				if (!IsRoadAllowedHere(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a])), a)) {
 					/* A road is not allowed to continue the randomized road,
-					 *   return if the road we're trying to build is curved. */
+					 *  return if the road we're trying to build is curved. */
-					if (a != (b ^ 2)) {
+					if (target_dir != ReverseDiagDir(source_dir)) return;
-						return;
-					}
 					/* Return if neither side of the new road is a house */
-					if (!IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a + 1])), MP_HOUSE) &&
+					if (!IsTileType(AddDiagDirToTileIndex(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90RIGHT)), MP_HOUSE) &&
-							!IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a + 3])), MP_HOUSE)) {
+							!IsTileType(AddDiagDirToTileIndex(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90LEFT)), MP_HOUSE)) {
 						return;
 					}
 					/* That means that the road is only allowed if there is a house
 					 *  at any side of the new road. */
 				}
-				rcmd = (RoadBits)((ROAD_NW << a) + (ROAD_NW << b));
+				rcmd = DiagDirToRoadBits(target_dir) | DiagDirToRoadBits(source_dir);
 				break;
 		}
-	} else if (block < 5 && !HASBIT(mask, block ^ 2)) {
+	} else if (target_dir < (DiagDirection)5 && !(cur_rb & DiagDirToRoadBits(ReverseDiagDir(target_dir)))) {
 		/* Continue building on a partial road.
-		 * Always OK. */
+		 * Should be allways OK, so we only generate
+		 * the fitting RoadBits */
 		_grow_town_result = 0;
 		switch (_patches.town_layout) {
 			default: NOT_REACHED();
 			case TL_NO_ROADS: /* Disallow Roads */
 				return;
 			case TL_3X3_GRID:
 			case TL_2X2_GRID:
-			 	rcmd = GetTownRoadGridElement(t1, tile);
+			 	rcmd = GetTownRoadGridElement(t1, tile, target_dir);
 				break;
 			case TL_BETTER_ROADS:
 			case TL_ORIGINAL:
-				rcmd = (RoadBits)(ROAD_NW << (block ^ 2));
+				rcmd = DiagDirToRoadBits(ReverseDiagDir(target_dir));
 				break;
 		}
 	} else {
-		int i;
+		bool allow_house = false; ///< Value which decides if we want to construct a house
-		bool allow_house = false;
+		TileIndex tmptile2;       ///< Yet another dummy tile
-		TileIndex tmptile2;
 		/* Reached a tunnel/bridge? Then continue at the other side of it. */
 		if (IsTileType(tile, MP_TUNNELBRIDGE)) {
 			if (IsTunnel(tile) && GetTunnelTransportType(tile) == TRANSPORT_ROAD) {
 				*tile_ptr = GetOtherTunnelEnd(tile);
 			return;
 		}
 		/* Possibly extend the road in a direction.
 		 * Randomize a direction and if it has a road, bail out. */
-		i = GB(Random(), 0, 2);
+		target_dir = RandomDiagDir();
-		if (HASBIT(mask, i)) return;
+		if (cur_rb & DiagDirToRoadBits(target_dir)) return;
 		/* This is the tile we will reach if we extend to this direction. */
-		tmptile = TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[i]));
+		tmptile = AddDiagDirToTileIndex(tile, target_dir);
-		/* Don't do it if it reaches to water. */
+		/* Don't walk into water. */
 		if (IsClearWaterTile(tmptile)) return;
 		switch (_patches.town_layout) {
 			default: NOT_REACHED();
 				allow_house = true;
 				break;
 			case TL_3X3_GRID: /* Use 2x2 grid afterwards! */
 				/* Fill gap if house has enougth neighbors */
-				tmptile2 = TILE_ADD(tmptile, ToTileIndexDiff(_roadblock_tileadd[i]));
+				tmptile2 = AddDiagDirToTileIndex(tmptile, target_dir);
 				if (AreNeighborsHouseTiles(tmptile2) && BuildTownHouse(t1, tmptile2)) {
 					_grow_town_result = -1;
 				}
 			case TL_2X2_GRID:
-				rcmd = GetTownRoadGridElement(t1, tmptile);
+				rcmd = GetTownRoadGridElement(t1, tmptile, target_dir);
 				allow_house = (rcmd == ROAD_NONE);
 				break;
 			case TL_BETTER_ROADS: /* Use original afterwards! */
 				/* Fill gap if house has enougth neighbors */
-				tmptile2 = TILE_ADD(tmptile, ToTileIndexDiff(_roadblock_tileadd[i]));
+				tmptile2 = AddDiagDirToTileIndex(tmptile, target_dir);
 				if (AreNeighborsHouseTiles(tmptile2) && BuildTownHouse(t1, tmptile2)) {
 					_grow_town_result = -1;
 				}
 			case TL_ORIGINAL:
 				 /* Allow a house at the edge. 60% chance or
 				  * always ok if no road allowed. */
-				allow_house = (!IsRoadAllowedHere(tmptile, i) || CHANCE16(6, 10));
+				rcmd = DiagDirToRoadBits(target_dir);
+				allow_house = (!IsRoadAllowedHere(tmptile, target_dir) || CHANCE16(6, 10));
 				break;
 		}
 		if (allow_house) {
 			/* Build a house, but not if there already is a house there. */
 			if (!IsTileType(tmptile, MP_HOUSE)) {
 				/* Level the land if possible */
 			}
 			return;
 		}
 		_grow_town_result = 0;
-		rcmd = (RoadBits)(ROAD_NW << i);
 	}
 	/* Return if a water tile */
 	if (IsClearWaterTile(tile)) return;
+	DiagDirection bridge_dir; ///< The direction of a bridge we maybe want to build
 	/* Determine direction of slope,
 	 *  and build a road if not a special slope. */
 	switch (GetTileSlope(tile, NULL)) {
-		case SLOPE_SW: i = DIAGDIR_NE; break;
+		case SLOPE_SW: bridge_dir = DIAGDIR_NE; break;
-		case SLOPE_SE: i = DIAGDIR_NW; break;
+		case SLOPE_SE: bridge_dir = DIAGDIR_NW; break;
-		case SLOPE_NW: i = DIAGDIR_SE; break;
+		case SLOPE_NW: bridge_dir = DIAGDIR_SE; break;
-		case SLOPE_NE: i = DIAGDIR_SW; break;
+		case SLOPE_NE: bridge_dir = DIAGDIR_SW; break;
 		default:
 build_road_and_exit:
 			if (CmdSucceeded(DoCommand(tile, rcmd, t1->index, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD))) {
 				_grow_town_result = -1;
 			}
 			return;
 	}
 	/* Check if the bridge is in the right direction */
-	if ((rcmd == ROAD_X && (i == DIAGDIR_NW || i == DIAGDIR_SE)) ||
+	if (!(rcmd & DiagDirToRoadBits(bridge_dir))) goto build_road_and_exit;
-			(rcmd == ROAD_Y && (i == DIAGDIR_NE || i == DIAGDIR_SW))) {
-		goto build_road_and_exit;
+	/* We are in the right direction */
-	}
+	uint32 bridge_length = 0; ///< This value stores the length of the possible bridge
+	tmptile = tile;           ///< Now we use this dummy to store the other waterside
-	tmptile = tile;
-	/* Now it contains the direction of the slope */
-	j = -11; // max 11 tile long bridges
 	do {
-		if (++j == 0)
+		if (bridge_length++ >= 11) {
+			/* Max 11 tile long bridges */
 			goto build_road_and_exit;
-		tmptile = TILE_MASK(tmptile + TileOffsByDiagDir(i));
+		}
+		tmptile = TILE_MASK(tmptile + TileOffsByDiagDir(bridge_dir));
 	} while (IsClearWaterTile(tmptile));
 	/* no water tiles in between? */
-	if (j == -10)
+	if (bridge_length == 1) goto build_road_and_exit;
-		goto build_road_and_exit;
+	for (uint times = 0; times <= 22; times++) {
-	/* Quit if it selecting an appropiate bridge type fails a large number of times. */
-	j = 22;
-	do {
 		byte bridge_type = RandomRange(MAX_BRIDGES - 1);
 		/* Can we actually build the bridge? */
 		if (CmdSucceeded(DoCommand(tile, tmptile, bridge_type | ((0x80 | ROADTYPES_ROAD) << 8), DC_AUTO, CMD_BUILD_BRIDGE))) {
 			DoCommand(tile, tmptile, bridge_type | ((0x80 | ROADTYPES_ROAD) << 8), DC_EXEC | DC_AUTO, CMD_BUILD_BRIDGE);
-				_grow_town_result = -1;
+			_grow_town_result = -1;
-			/* obviously, if building any bridge would fail, there is no need to try other bridge-types */
 			return;
 		}
-	} while (--j != 0);
+	}
+	/* Quit if it selecting an appropiate bridge type fails a large number of times. */
 }
 /** Returns "growth" if a house was built, or no if the build failed.
 * @param t town to inquiry
 * @param tile to inquiry
 * @return something other than zero(0)if town expansion was possible
 */
 static int GrowTownAtRoad(Town *t, TileIndex tile)
 {
-	int block = 5; // special case
+	/* Special case.
+	 * @see GrowTownInTile Check the else if
+	 */
+	DiagDirection target_dir = (DiagDirection)5; ///< The direction in which we want to extend the town
 	TILE_ASSERT(tile);
 	/* Number of times to search.
 	 * Better roads, 2X2 and 3X3 grid grow quite fast so we give
 			_grow_town_result = 10 + t->num_houses * 4 / 9;
 			break;
 	}
 	do {
-		/* Get a bitmask of the road blocks on a tile */
+		RoadBits cur_rb = GetTownRoadBits(tile); ///< The RoadBits of the current tile
-		RoadBits mask = GetTownRoadMask(tile);
 		/* Try to grow the town from this point */
-		GrowTownInTile(&tile, mask, block, t);
+		GrowTownInTile(&tile, cur_rb, target_dir, t);
 		/* Exclude the source position from the bitmask
 		 * and return if no more road blocks available */
-		ClrBitT(mask, (block ^ 2));
+		cur_rb &= ~DiagDirToRoadBits(ReverseDiagDir(target_dir));
-		if (mask == ROAD_NONE)
+		if (cur_rb == ROAD_NONE)
 			return _grow_town_result;
 		/* Select a random bit from the blockmask, walk a step
 		 * and continue the search from there. */
-		do block = Random() & 3; while (!HASBIT(mask, block));
+		do target_dir = RandomDiagDir(); while (!(cur_rb & DiagDirToRoadBits(target_dir)));
-		tile += ToTileIndexDiff(_roadblock_tileadd[block]);
+		tile = AddDiagDirToTileIndex(tile, target_dir);
 		if (IsTileType(tile, MP_ROAD)) {
 			/* Don't allow building over roads of other cities */
 			if (IsTileOwner(tile, OWNER_TOWN) && GetTownByTile(tile) != t) {
 				_grow_town_result = -1;
 	} while (--_grow_town_result >= 0);
 	return (_grow_town_result == -2);
 }
-/** Generate a random road block
+/**
+* Generate a random road block.
 * The probability of a straight road
-* is somewhat higher than a curved. */
+* is somewhat higher than a curved.
+*
+* @return A RoadBits value with 2 bits set
+*/
 static RoadBits GenRandomRoadBits()
 {
 	uint32 r = Random();
 	uint a = GB(r, 0, 2);
 	uint b = GB(r, 8, 2);
 	if (a == b) b ^= 2;
-	return (RoadBits)((1 << a) + (1 << b));
+	return (RoadBits)((ROAD_NW << a) + (ROAD_NW << b));
 }
 /** Grow the town
 * @Return true if a house was built, or no if the build failed. */
 static bool GrowTown(Town *t)
 {
-	TileIndex tile;
-	const TileIndexDiffC *ptr;
+	/* Let the town be a ghost town
-	PlayerID old_player;
+	 * The player wanted it in such a way. Thus there he has it. ;)
+	 * Never reached in editor mode. */
+	if (_patches.town_layout == TL_NO_ROADS && _generating_world) {
+		return false;
+	}
 	static const TileIndexDiffC _town_coord_mod[] = {
 		{-1,  0},
 		{ 1,  1},
 		{ 1, -1},
 		{-2,  2},
 		{ 2,  2},
 		{ 2, -2},
 		{ 0,  0}
 	};
+	const TileIndexDiffC *ptr;
-	/* Let the town be a ghost town
-	 * The player wanted it in such a way. Thus there he has it. ;)
-	 * Never reached in editor mode. */
-	if (_patches.town_layout == TL_NO_ROADS && _generating_world) {
-		return false;
-	}
 	/* Current player is a town */
-	old_player = _current_player;
+	PlayerID old_player = _current_player;
 	_current_player = OWNER_TOWN;
+	TileIndex tile = t->xy; ///< The tile we are working with ATM
 	/* Find a road that we can base the construction on. */
-	tile = t->xy;
 	for (ptr = _town_coord_mod; ptr != endof(_town_coord_mod); ++ptr) {
-		if (GetAnyRoadTrackBits(tile, ROADTYPE_ROAD) != 0) {
+		if (GetTownRoadBits(tile) != ROAD_NONE) {
 			int r = GrowTownAtRoad(t, tile);
 			_current_player = old_player;
 			return r != 0;
 		}
 		tile = TILE_ADD(tile, ToTileIndexDiff(*ptr));
 static bool DoBuildStatueOfCompany(TileIndex tile, TownID town_id)
 {
 	PlayerID old;
 	CommandCost r;
-	if (GetTileSlope(tile, NULL) != SLOPE_FLAT) return false;
+	/* Statues can be build on slopes, just like houses. Only the steep slopes is a no go. */
+	if (IsSteepSlope(GetTileSlope(tile, NULL))) return false;
 	if (!IsTileType(tile, MP_HOUSE) &&
 			!IsTileType(tile, MP_CLEAR) &&
 			!IsTileType(tile, MP_TREES)) {
 		return false;
 	_town_sort_dirty = true;
 }
 static CommandCost TerraformTile_Town(TileIndex tile, uint32 flags, uint z_new, Slope tileh_new)
 {
+	if (AutoslopeEnabled()) {
+		HouseID house = GetHouseType(tile);
+		HouseSpec *hs = GetHouseSpecs(house);
+		/* Here we differ from TTDP by checking TILE_NOT_SLOPED */
+		if (((hs->building_flags & TILE_NOT_SLOPED) == 0) && !IsSteepSlope(tileh_new) &&
+			(GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) return _price.terraform;
+	}
 	return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 }
 extern const TileTypeProcs _tile_type_town_procs = {
 	DrawTile_Town,           /* draw_tile_proc */

branch	noai
changeset 9703	d2a6acdbd665
parent 9701	d1ac22c62f64
child 9704	197cb8c6ae17