openttd-ottdgrfs: comparison src/town

equal deleted inserted replaced

-:d1a4486be2fd
+:67a9579abd74
 {
 	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
 * @param ti TileInfo of the tile to draw
 */
 static void DrawTile_Town(TileInfo *ti)
 * @return true if one of the neighboring tiles at the
 *  given distance is a road tile else false
 */
 static bool IsNeighborRoadTile(TileIndex tile, DiagDirection dir, uint dist_multi)
 {
-	static TileIndexDiff tid_lt[3]; ///< lookup table for the used diff values
+	static TileIndexDiff tid_lt[3]; // lookup table for the used diff values
 	tid_lt[0] = TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90RIGHT));
 	tid_lt[1] = TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90LEFT));
 	tid_lt[2] = TileOffsByDiagDir(ReverseDiagDir(dir));
 	/* We add 1 to the distance because we want to get 1 for
 		 * 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
+		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;
 }
 *  the selected town layout
 */
 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
+	TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile); // Vector from downtown to the tile
 	RoadBits rcmd = ROAD_NONE;
 	switch (_patches.town_layout) {
 		default: NOT_REACHED();
 	return rcmd;
 }
 /**
-* Check there are enough neighbor house tiles next to the current tile
+* Grows the town with an extra house.
+*  Check if there are enough neighbor house tiles
+*  next to the current tile. If there are enough
+*  add another house.
 *
-* @param tile current tile
+* @param t The current town
-* @return true if there are more than 2 house tiles next
+* @param tile The target tile for the extra house
-*  to the current one
+* @return true if an extra house has been added
 */
-static bool AreNeighborsHouseTiles(TileIndex tile)
+static bool GrowTownWithExtraHouse(Town *t, TileIndex tile)
 {
-	uint counter = 0; ///< counts the house neighbor tiles
 	/* We can't look further than that. */
-	if (TileX(tile) < 1 || TileY(tile) < 1) {
+	if (TileX(tile) < 2 || TileY(tile) < 2 || MapMaxX() <= TileX(tile) || MapMaxY() <= TileY(tile)) return false;
-		return false;
-	}
+	uint counter = 0; // counts the house neighbor tiles
-	/* Check the tiles E,N,W and S of the current tile. */
+	/* Check the tiles E,N,W and S of the current tile for houses */
-	for (DiagDirection i = DIAGDIR_BEGIN; i < DIAGDIR_END; i++) {
+	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
-		if (IsTileType(AddDiagDirToTileIndex(tile, i), MP_HOUSE)) {
-			counter++;
+		if (IsTileType(TileAddByDiagDir(tile, dir), MP_HOUSE)) counter++;
-		}
+		/* If there are enough neighbors stop here */
-		/* If there are enougth neighbor's stop it here */
 		if (counter >= 3) {
+			if (BuildTownHouse(t, tile)) {
+				_grow_town_result = -1;
+				return true;
+			}
+			return false;
+		}
+	}
+	return false;
+}
+/**
+* Grows the town with a road piece.
+*
+* @param t The current town
+* @param tile The current tile
+* @param rcmd The RoadBits we want to build on the tile
+* @return true if the RoadBits have been added else false
+*/
+static bool GrowTownWithRoad(const Town *t, TileIndex tile, RoadBits rcmd)
+{
+	if (CmdSucceeded(DoCommand(tile, rcmd, t->index, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD))) {
+		_grow_town_result = -1;
+		return true;
+	}
+	return false;
+}
+/**
+* Grows the town with a bridge.
+*  At first we check if a bridge is reasonable.
+*  If so we check if we are able to build it.
+*
+* @param t The current town
+* @param tile The current tile
+* @param rcmd The RoadBits which are possible on this tile
+* @return true if a bridge has been build else false
+*/
+static bool GrowTownWithBridge(const Town *t, TileIndex tile, RoadBits rcmd)
+{
+	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: bridge_dir = DIAGDIR_NE; break;
+		case SLOPE_SE: bridge_dir = DIAGDIR_NW; break;
+		case SLOPE_NW: bridge_dir = DIAGDIR_SE; break;
+		case SLOPE_NE: bridge_dir = DIAGDIR_SW; break;
+		default: return false;
+	}
+	/* Check if the bridge will be compatible to the RoadBits */
+	if (!(rcmd & DiagDirToRoadBits(ReverseDiagDir(bridge_dir)))) return false;
+	/* We are in the right direction */
+	uint32 bridge_length = 0;     // This value stores the length of the possible bridge
+	TileIndex bridge_tile = tile; // Used to store the other waterside
+	do {
+		if (bridge_length++ >= 11) {
+			/* Max 11 tile long bridges */
+			return false;
+		}
+		bridge_tile = TILE_MASK(bridge_tile + TileOffsByDiagDir(bridge_dir));
+	} while (IsClearWaterTile(bridge_tile));
+	/* no water tiles in between? */
+	if (bridge_length == 1) return false;
+	for (uint8 times = 0; times <= 22; times++) {
+		byte bridge_type = RandomRange(MAX_BRIDGES - 1);
+		/* Can we actually build the bridge? */
+		if (CmdSucceeded(DoCommand(tile, bridge_tile, bridge_type | ((0x80 | ROADTYPES_ROAD) << 8), DC_AUTO, CMD_BUILD_BRIDGE))) {
+			DoCommand(tile, bridge_tile, bridge_type | ((0x80 | ROADTYPES_ROAD) << 8), DC_EXEC | DC_AUTO, CMD_BUILD_BRIDGE);
+			_grow_town_result--;
 			return true;
 		}
 	}
+	/* Quit if it selecting an appropiate bridge type fails a large number of times. */
 	return false;
 }
 /**
 * Grows the given town.
 * There are at the moment 3 possible way's for
 * the town expansion:
-* @li Generate a random tile and check if there is a road allowed
+*  @li Generate a random tile and check if there is a road allowed
-* 	@li TL_ORIGINAL
+*  @li TL_ORIGINAL
-* 	@li TL_BETTER_ROADS
+*  @li TL_BETTER_ROADS
-* @li Check if the town geometry allows a road and which one
+*  @li Check if the town geometry allows a road and which one
-* 	@li TL_2X2_GRID
+*  @li TL_2X2_GRID
-* 	@li TL_3X3_GRID
+*  @li TL_3X3_GRID
-* @li Forbid roads, only build houses
+*  @li Forbid roads, only build houses
-* 	@li TL_NO_ROADS
+*  @li TL_NO_ROADS
 *
 * @param tile_ptr The current tile
 * @param cur_rb The current tiles RoadBits
 * @param target_dir The target road dir
 * @param t1 The current town
 */
-static void GrowTownInTile(TileIndex* tile_ptr, RoadBits cur_rb, DiagDirection target_dir, Town* t1)
+static void GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, DiagDirection target_dir, Town *t1)
 {
-	RoadBits rcmd = ROAD_NONE;  ///< RoadBits for the road construction command
+	RoadBits rcmd = ROAD_NONE;  // RoadBits for the road construction command
-	TileIndex tmptile;          ///< Dummy tile for various things
+	TileIndex tile = *tile_ptr; // The main tile on which we base our growth
-	TileIndex tile = *tile_ptr; ///< The main tile on which we base our growth
 	TILE_ASSERT(tile);
 	if (cur_rb == ROAD_NONE) {
 		/* Tile has no road. First reset the status counter
 				if (CHANCE16(1, 4)) {
 					/* Randomize a new target dir */
 					do target_dir = RandomDiagDir(); while (target_dir == source_dir);
 				}
-				if (!IsRoadAllowedHere(AddDiagDirToTileIndex(tile, target_dir), target_dir)) {
+				if (!IsRoadAllowedHere(TileAddByDiagDir(tile, target_dir), target_dir)) {
 					/* A road is not allowed to continue the randomized road,
 					 *  return if the road we're trying to build is curved. */
 					if (target_dir != ReverseDiagDir(source_dir)) return;
 					/* Return if neither side of the new road is a house */
-					if (!IsTileType(AddDiagDirToTileIndex(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90RIGHT)), MP_HOUSE) &&
+					if (!IsTileType(TileAddByDiagDir(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90RIGHT)), MP_HOUSE) &&
-							!IsTileType(AddDiagDirToTileIndex(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90LEFT)), MP_HOUSE)) {
+							!IsTileType(TileAddByDiagDir(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 = DiagDirToRoadBits(target_dir) | DiagDirToRoadBits(source_dir);
 				break;
 		}
-	} else if (target_dir < (DiagDirection)5 && !(cur_rb & DiagDirToRoadBits(ReverseDiagDir(target_dir)))) {
+	} else if (target_dir < DIAGDIR_END && !(cur_rb & DiagDirToRoadBits(ReverseDiagDir(target_dir)))) {
 		/* Continue building on a partial road.
 		 * Should be allways OK, so we only generate
 		 * the fitting RoadBits */
 		_grow_town_result = 0;
 			case TL_ORIGINAL:
 				rcmd = DiagDirToRoadBits(ReverseDiagDir(target_dir));
 				break;
 		}
 	} else {
-		bool allow_house = false; ///< Value which decides if we want to construct a house
+		bool allow_house = false; // Value which decides if we want to construct a house
-		TileIndex tmptile2;       ///< Yet another dummy tile
 		/* 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);
 		 * Randomize a direction and if it has a road, bail out. */
 		target_dir = RandomDiagDir();
 		if (cur_rb & DiagDirToRoadBits(target_dir)) return;
 		/* This is the tile we will reach if we extend to this direction. */
-		tmptile = AddDiagDirToTileIndex(tile, target_dir);
+		TileIndex house_tile = TileAddByDiagDir(tile, target_dir); // position of a possible house
 		/* Don't walk into water. */
-		if (IsClearWaterTile(tmptile)) return;
+		if (IsClearWaterTile(house_tile)) return;
 		switch (_patches.town_layout) {
 			default: NOT_REACHED();
 			case TL_NO_ROADS:
 				allow_house = true;
 				break;
 			case TL_3X3_GRID: /* Use 2x2 grid afterwards! */
-				/* Fill gap if house has enougth neighbors */
+				GrowTownWithExtraHouse(t1, TileAddByDiagDir(house_tile, target_dir));
-				tmptile2 = AddDiagDirToTileIndex(tmptile, target_dir);
+				/* FALL THROUGH */
-				if (AreNeighborsHouseTiles(tmptile2) && BuildTownHouse(t1, tmptile2)) {
-					_grow_town_result = -1;
-				}
 			case TL_2X2_GRID:
-				rcmd = GetTownRoadGridElement(t1, tmptile, target_dir);
+				rcmd = GetTownRoadGridElement(t1, house_tile, target_dir);
 				allow_house = (rcmd == ROAD_NONE);
 				break;
 			case TL_BETTER_ROADS: /* Use original afterwards! */
-				/* Fill gap if house has enougth neighbors */
+				GrowTownWithExtraHouse(t1, TileAddByDiagDir(house_tile, target_dir));
-				tmptile2 = AddDiagDirToTileIndex(tmptile, target_dir);
+				/* FALL THROUGH */
-				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. */
 				rcmd = DiagDirToRoadBits(target_dir);
-				allow_house = (!IsRoadAllowedHere(tmptile, target_dir) || CHANCE16(6, 10));
+				allow_house = (!IsRoadAllowedHere(house_tile, 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)) {
+			if (!IsTileType(house_tile, MP_HOUSE)) {
 				/* Level the land if possible */
-				LevelTownLand(tmptile);
+				LevelTownLand(house_tile);
 				/* And build a house.
 				 * Set result to -1 if we managed to build it. */
-				if (BuildTownHouse(t1, tmptile)) {
+				if (BuildTownHouse(t1, house_tile)) {
 					_grow_town_result = -1;
 				}
 			}
 			return;
 		}
 	}
 	/* Return if a water tile */
 	if (IsClearWaterTile(tile)) return;
-	DiagDirection bridge_dir; ///< The direction of a bridge we maybe want to build
+	/* Make the roads look nicer */
-	/* Determine direction of slope,
+	rcmd = CleanUpRoadBits(tile, rcmd);
-	 *  and build a road if not a special slope. */
+	if (rcmd == ROAD_NONE) return;
-	switch (GetTileSlope(tile, NULL)) {
-		case SLOPE_SW: bridge_dir = DIAGDIR_NE; break;
+	if (GrowTownWithBridge(t1, tile, rcmd)) return;
-		case SLOPE_SE: bridge_dir = DIAGDIR_NW; break;
-		case SLOPE_NW: bridge_dir = DIAGDIR_SE; break;
+	GrowTownWithRoad(t1, tile, rcmd);
-		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 & DiagDirToRoadBits(bridge_dir))) 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
-	do {
-		if (bridge_length++ >= 11) {
-			/* Max 11 tile long bridges */
-			goto build_road_and_exit;
-		}
-		tmptile = TILE_MASK(tmptile + TileOffsByDiagDir(bridge_dir));
-	} while (IsClearWaterTile(tmptile));
-	/* no water tiles in between? */
-	if (bridge_length == 1) goto build_road_and_exit;
-	for (uint times = 0; times <= 22; times++) {
-		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;
-			return;
-		}
-	}
-	/* 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
 static int GrowTownAtRoad(Town *t, TileIndex tile)
 {
 	/* Special case.
 	 * @see GrowTownInTile Check the else if
 	 */
-	DiagDirection target_dir = (DiagDirection)5; ///< The direction in which we want to extend the town
+	DiagDirection target_dir = DIAGDIR_END; // 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 {
-		RoadBits cur_rb = GetTownRoadBits(tile); ///< The RoadBits of the current tile
+		RoadBits cur_rb = GetTownRoadBits(tile); // The RoadBits of the current tile
 		/* Try to grow the town from this point */
 		GrowTownInTile(&tile, cur_rb, target_dir, t);
 		/* Exclude the source position from the bitmask
 			return _grow_town_result;
 		/* Select a random bit from the blockmask, walk a step
 		 * and continue the search from there. */
 		do target_dir = RandomDiagDir(); while (!(cur_rb & DiagDirToRoadBits(target_dir)));
-		tile = AddDiagDirToTileIndex(tile, target_dir);
+		tile = TileAddByDiagDir(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;
 	/* Current player is a town */
 	PlayerID old_player = _current_player;
 	_current_player = OWNER_TOWN;
-	TileIndex tile = t->xy; ///< The tile we are working with ATM
+	TileIndex tile = t->xy; // The tile we are working with ATM
 	/* Find a road that we can base the construction on. */
 	for (ptr = _town_coord_mod; ptr != endof(_town_coord_mod); ++ptr) {
 		if (GetTownRoadBits(tile) != ROAD_NONE) {
 			int r = GrowTownAtRoad(t, tile);
 	if (_patches.town_growth_rate == 0 && t->fund_buildings_months == 0) return;
 	/** Towns are processed every TOWN_GROWTH_FREQUENCY ticks, and this is the
 	 * number of times towns are processed before a new building is built. */
 	static const uint16 _grow_count_values[2][6] = {
-		{ 120, 120, 120, 100,  80,  60 }, ///< Fund new buildings has been activated
+		{ 120, 120, 120, 100,  80,  60 }, // Fund new buildings has been activated
-		{ 320, 420, 300, 220, 160, 100 }  ///< Normal values
+		{ 320, 420, 300, 220, 160, 100 }  // Normal values
 	};
 	if (t->fund_buildings_months != 0) {
 		m = _grow_count_values[0][min(n, 5)];
 		t->fund_buildings_months--;
 }
 /* penalty for removing town-owned stuff */
 static const int _default_rating_settings [3][3] = {
 	/* ROAD_REMOVE, TUNNELBRIDGE_REMOVE, INDUSTRY_REMOVE */
-	{  0, 128, 384}, ///< Permissive
+	{  0, 128, 384}, // Permissive
-	{ 48, 192, 480}, ///< Neutral
+	{ 48, 192, 480}, // Neutral
-	{ 96, 384, 768}, ///< Hostile
+	{ 96, 384, 768}, // Hostile
 };
 bool CheckforTownRating(uint32 flags, Town *t, byte type)
 {
 	int modemod;

changeset 8137	67a9579abd74
parent 8099	fab936821b10
child 8138	7dc73953c47e