openttd-ottdgrfs: comparison src/town

equal deleted inserted replaced

-:0b2aebc8283e
+:0b8b245a2391
 #include "genworld.h"
 #include "economy_new.h"
 #include "newgrf.h"
 #include "newgrf_callbacks.h"
 #include "newgrf_house.h"
+#include "newgrf_commons.h"
 /**
 * Called if a new block is added to the town-pool
 */
 static void TownPoolNewBlock(uint start_item)
 }
 /* Initialize the town-pool */
 DEFINE_OLD_POOL(Town, Town, TownPoolNewBlock, NULL)
+/**
+* Removes a specific town as well as all industries
+* under its "juridiction"
+* @param t Town to remove
+*/
 void DestroyTown(Town *t)
 {
 	Industry *i;
 	TileIndex tile;
 	variant -= y >> 6;
 	variant &= 3;
 	return variant;
 }
+/**
+* House Tile drawing handler.
+* Part of the tile loop process
+* @param ti TileInfo of the tile to draw
+*/
 static void DrawTile_Town(TileInfo *ti)
 {
 	const DrawBuildingsTileStruct *dcts;
 	SpriteID image;
 	SpriteID pal;
 static Slope GetSlopeTileh_Town(TileIndex tile, Slope tileh)
 {
 	return SLOPE_FLAT;
 }
+/**
+* Animate a tile for a town
+* Only certain houses can be animated
+* The newhouses animation superseeds regular ones
+* @param tile TileIndex of the house to animate
+*/
 static void AnimateTile_Town(TileIndex tile)
 {
 	int pos, dest;
 	if (GetHouseType(tile) >= NEW_HOUSE_OFFSET) {
 	MarkTileDirtyByTile(tile);
 }
 static void UpdateTownRadius(Town *t);
+/**
+* Determines if a town is close to a tile
+* @param tile TileIndex of the tile to query
+* @param dist maximum distance to be accepted
+* @returns true if the tile correspond to the distance criteria
+*/
 static bool IsCloseToTown(TileIndex tile, uint dist)
 {
 	const Town* t;
 	FOR_ALL_TOWNS(t) {
 		if (DistanceManhattan(tile, t->xy) < dist) return true;
 	}
 	return false;
 }
+/**
+* Marks the town sign as needing a repaint
+* @param t Town requesting repaint
+*/
 static void MarkTownSignDirty(Town *t)
 {
 	MarkAllViewportsDirty(
 		t->sign.left - 6,
 		t->sign.top - 3,
 		t->sign.left + t->sign.width_1 * 4 + 12,
 		t->sign.top + 45
 	);
 }
+/**
+* Resize the sign(label) of the town after changes in
+* population (creation or growth or else)
+* @param t Town to update
+*/
 void UpdateTownVirtCoord(Town *t)
 {
 	Point pt;
 	MarkTownSignDirty(t);
 	UpdateViewportSignPos(&t->sign, pt.x, pt.y - 24,
 		_patches.population_in_label ? STR_TOWN_LABEL_POP : STR_TOWN_LABEL);
 	MarkTownSignDirty(t);
 }
+/**
+* Change the towns population
+* @param t Town which polulation has changed
+* @param mod polulation change (can be positive or negative)
+*/
 static void ChangePopulation(Town *t, int mod)
 {
 	t->population += mod;
 	InvalidateWindow(WC_TOWN_VIEW, t->index);
 	UpdateTownVirtCoord(t);
 	if (_town_sort_order & 2) _town_sort_dirty = true;
 }
+/**
+* Determines the world population
+* Basically, count population of all towns, one by one
+* @return uint32 the calculated population of the world
+*/
 uint32 GetWorldPopulation()
 {
 	uint32 pop;
 	const Town* t;
 	pop = 0;
 	FOR_ALL_TOWNS(t) pop += t->population;
 	return pop;
 }
+/**
+* Helper function for house completion stages progression
+* @param tile TileIndex of the house (or parts of it) to "grow"
+*/
 static void MakeSingleHouseBigger(TileIndex tile)
 {
 	assert(IsTileType(tile, MP_HOUSE));
+	/* means it is completed, get out. */
 	if (LiftHasDestination(tile)) return;
+	/* progress in construction stages */
 	IncHouseConstructionTick(tile);
 	if (GetHouseConstructionTick(tile) != 0) return;
+	/* Check and/or  */
 	if (HASBIT(GetHouseSpecs(GetHouseType(tile))->callback_mask, CBM_CONSTRUCTION_STATE_CHANGE)) {
-		uint16 callback_res = GetHouseCallback(CBID_CONSTRUCTION_STATE_CHANGE, 0, GetHouseType(tile), GetTownByTile(tile), tile);
+		uint16 callback_res = GetHouseCallback(CBID_CONSTRUCTION_STATE_CHANGE, 0, 0, GetHouseType(tile), GetTownByTile(tile), tile);
 		if (callback_res != CALLBACK_FAILED) ChangeHouseAnimationFrame(tile, callback_res);
 	}
 	if (IsHouseCompleted(tile)) {
 		/* Now that construction is complete, we can add the population of the
 		ChangePopulation(GetTownByTile(tile), GetHouseSpecs(GetHouseType(tile))->population);
 	}
 	MarkTileDirtyByTile(tile);
 }
+/** Make the house advances in its construction stages until completion
+* @param tile TileIndex of house
+*/
 static void MakeTownHouseBigger(TileIndex tile)
 {
 	uint flags = GetHouseSpecs(GetHouseType(tile))->building_flags;
 	if (flags & BUILDING_HAS_1_TILE)  MakeSingleHouseBigger(TILE_ADDXY(tile, 0, 0));
 	if (flags & BUILDING_2_TILES_Y)   MakeSingleHouseBigger(TILE_ADDXY(tile, 0, 1));
 	if (flags & BUILDING_2_TILES_X)   MakeSingleHouseBigger(TILE_ADDXY(tile, 1, 0));
 	if (flags & BUILDING_HAS_4_TILES) MakeSingleHouseBigger(TILE_ADDXY(tile, 1, 1));
 }
+/**
+* Periodic tic handler for houses and town
+* @param tile been asked to do its stuff
+*/
 static void TileLoop_Town(TileIndex tile)
 {
 	Town *t;
 	uint32 r;
 	HouseID house_id = GetHouseType(tile);
 		MakeTownHouseBigger(tile);
 		return;
 	}
 	/* If the lift has a destination, it is already an animated tile. */
-	if ((hs->building_flags & BUILDING_IS_ANIMATED) && house_id < NEW_HOUSE_OFFSET && !LiftHasDestination(tile) && CHANCE16(1, 2)) AddAnimatedTile(tile);
+	if ((hs->building_flags & BUILDING_IS_ANIMATED) &&
+			house_id < NEW_HOUSE_OFFSET &&
+			!LiftHasDestination(tile) &&
+			CHANCE16(1, 2))
+		AddAnimatedTile(tile);
 	t = GetTownByTile(tile);
 	r = Random();
-	if (GB(r, 0, 8) < (t->GetActivity() * _eco->GetActivity() * 8)) {
+	if (HASBIT(hs->callback_mask, CBM_HOUSE_PRODUCE_CARGO)) {
-		int amt = hs->population / 8 + 1;
+		/** @todo Implement economic activity here as well */
-		t->new_max_pass += amt;
+		for (uint i = 0; i < 256; i++) {
-		int moved = MoveGoodsToStation(tile, 1, 1, CT_PASSENGERS, amt);
+			uint16 callback = GetHouseCallback(CBID_HOUSE_PRODUCE_CARGO, i, r, house_id, t, tile);
-		t->new_act_pass += moved;
-	}
+			if (callback == CALLBACK_FAILED) break;
+			if (callback == 0x20FF) break;
-	if (GB(r, 8, 8) < (t->GetActivity() * _eco->GetActivity() * 8)) {
-		int amt = hs->mail_generation / 8 + 1;
+			CargoID cargo = GetCargoTranslation(GB(callback, 8, 7), hs->grffile);
-		t->new_max_pass += amt;
+			if (cargo == CT_INVALID) continue;
-		int moved = MoveGoodsToStation(tile, 1, 1, CT_PASSENGERS, amt);
-		t->new_act_pass += moved;
+			uint amt = GB(callback, 0, 8);
+			uint moved = MoveGoodsToStation(tile, 1, 1, cargo, amt);
+			const CargoSpec *cs = GetCargo(cargo);
+			switch (cs->town_effect) {
+				case TE_PASSENGERS:
+					t->new_max_pass += amt;
+					t->new_act_pass += moved;
+					break;
+				case TE_MAIL:
+					t->new_max_mail += amt;
+					t->new_act_mail += moved;
+					break;
+				default:
+					break;
+			}
+		}
+	} else {
+		if (GB(r, 0, 8) < (t->GetActivity() * _eco->GetActivity() * 8)) {
+			int amt = hs->population / 8 + 1;
+			t->new_max_pass += amt;
+			int moved = MoveGoodsToStation(tile, 1, 1, CT_PASSENGERS, amt);
+			t->new_act_pass += moved;
+		}
+		if (GB(r, 8, 8) < (t->GetActivity() * _eco->GetActivity() * 8)) {
+			int amt = hs->mail_generation / 8 + 1;
+			t->new_max_pass += amt;
+			int moved = MoveGoodsToStation(tile, 1, 1, CT_PASSENGERS, amt);
+			t->new_act_pass += moved;
+		}
 	}
 	_current_player = OWNER_TOWN;
-	if (hs->building_flags & BUILDING_HAS_1_TILE && HASBIT(t->flags12, TOWN_IS_FUNDED) && CanDeleteHouse(tile) && --t->time_until_rebuild == 0) {
+	if (hs->building_flags & BUILDING_HAS_1_TILE &&
+			HASBIT(t->flags12, TOWN_IS_FUNDED) &&
+			CanDeleteHouse(tile) &&
+			max(_cur_year - GetHouseConstructionYear(tile), 0) >= hs->minimum_life &&
+			--t->time_until_rebuild == 0) {
 		t->time_until_rebuild = GB(r, 16, 8) + 192;
 		ClearTownHouse(t, tile);
 		/* Rebuild with another house? */
 	}
 	_current_player = OWNER_NONE;
 }
+/**
+* Unused handler
+* @param tile unused
+*/
 static void ClickTile_Town(TileIndex tile)
 {
 	/* not used */
 }
 }
 static void GetAcceptedCargo_Town(TileIndex tile, AcceptedCargo ac)
 {
 	HouseSpec *hs = GetHouseSpecs(GetHouseType(tile));
+	CargoID accepts[3];
-	for (uint8 i = 0; i < 3; i++) ac[hs->accepts_cargo[i]] = hs->cargo_acceptance[i];
+	/* Set the initial accepted cargo types */
+	for (uint8 i = 0; i < lengthof(accepts); i++) {
+		accepts[i] = hs->accepts_cargo[i];
+	}
+	/* Check for custom accepted cargo types */
+	if (HASBIT(hs->callback_mask, CBM_HOUSE_ACCEPT_CARGO)) {
+		uint16 callback = GetHouseCallback(CBID_HOUSE_ACCEPT_CARGO, 0, 0, GetHouseType(tile), GetTownByTile(tile), tile);
+		if (callback != CALLBACK_FAILED) {
+			/* Replace accepted cargo types with translated values from callback */
+			accepts[0] = GetCargoTranslation(GB(callback,  0, 5), hs->grffile);
+			accepts[1] = GetCargoTranslation(GB(callback,  5, 5), hs->grffile);
+			accepts[2] = GetCargoTranslation(GB(callback, 10, 5), hs->grffile);
+		}
+	}
+	/* Check for custom cargo acceptance */
+	if (HASBIT(hs->callback_mask, CBM_CARGO_ACCEPTANCE)) {
+		uint16 callback = GetHouseCallback(CBID_HOUSE_CARGO_ACCEPTANCE, 0, 0, GetHouseType(tile), GetTownByTile(tile), tile);
+		if (callback != CALLBACK_FAILED) {
+			if (accepts[0] != CT_INVALID) ac[accepts[0]] = GB(callback, 0, 4);
+			if (accepts[1] != CT_INVALID) ac[accepts[1]] = GB(callback, 4, 4);
+			if (_opt.landscape != LT_TEMPERATE && HASBIT(callback, 12)) {
+				/* The 'S' bit indicates food instead of goods */
+				ac[CT_FOOD] = GB(callback, 8, 4);
+			} else {
+				if (accepts[2] != CT_INVALID) ac[accepts[2]] = GB(callback, 8, 4);
+			}
+			return;
+		}
+	}
+	/* No custom acceptance, so fill in with the default values */
+	for (uint8 i = 0; i < lengthof(accepts); i++) {
+		if (accepts[i] != CT_INVALID) ac[accepts[i]] = hs->cargo_acceptance[i];
+	}
 }
 static void GetTileDesc_Town(TileIndex tile, TileDesc *td)
 {
 	td->str = GetHouseSpecs(GetHouseType(tile))->building_name;
 	{ 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)
 {
 	}
 }
 static RoadBits GetTownRoadMask(TileIndex tile)
 {
-	TrackBits b = GetAnyRoadTrackBits(tile);
+	TrackBits b = GetAnyRoadTrackBits(tile, ROADTYPE_ROAD);
 	RoadBits r = ROAD_NONE;
 	if (b & TRACK_BIT_X)     r |= ROAD_X;
 	if (b & TRACK_BIT_Y)     r |= ROAD_Y;
 	if (b & TRACK_BIT_UPPER) r |= ROAD_NE | ROAD_NW;
 	if (b & TRACK_BIT_LEFT)  r |= ROAD_NW | ROAD_SW;
 	if (b & TRACK_BIT_RIGHT) r |= ROAD_NE | ROAD_SE;
 	return r;
 }
+/**
+* Check if a neighboring tile has a road
+*
+* @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
+*/
+static bool NeighborIsRoadTile(TileIndex tile, int dir, RoadBlockTitleDistance dist_multi)
+{
+	return (HASBIT(GetTownRoadMask(TILE_ADD(tile, dist_multi * ToTileIndexDiff(_roadblock_tileadd[dir + 1]))), dir ^ 2) ||
+			HASBIT(GetTownRoadMask(TILE_ADD(tile, dist_multi * ToTileIndexDiff(_roadblock_tileadd[dir + 3]))), dir ^ 2) ||
+			HASBIT(GetTownRoadMask(TILE_ADD(tile, dist_multi * (ToTileIndexDiff(_roadblock_tileadd[dir + 1]) + ToTileIndexDiff(_roadblock_tileadd[dir + 2])))), dir) ||
+			HASBIT(GetTownRoadMask(TILE_ADD(tile, dist_multi * (ToTileIndexDiff(_roadblock_tileadd[dir + 3]) + ToTileIndexDiff(_roadblock_tileadd[dir + 2])))), dir));
+}
 static bool IsRoadAllowedHere(TileIndex tile, int dir)
 {
 	Slope k;
 	Slope slope;
 	 *  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) == 0) {
+		if (GetAnyRoadTrackBits(tile, ROADTYPE_ROAD) == 0) {
 			/* 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 & 1 ? ROAD_X : ROAD_Y), 0, DC_AUTO, CMD_BUILD_ROAD)) &&
 					CmdFailed(DoCommand(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR)))
 		}
 		slope = GetTileSlope(tile, NULL);
 		if (slope == SLOPE_FLAT) {
 no_slope:
-			/* Tile has no slope
+			/* Tile has no slope */
-			 * Disallow the road if any neighboring tile has a road. */
+			switch (_patches.town_layout) {
-			if (HASBIT(GetTownRoadMask(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[dir + 1]))), dir ^ 2) ||
+				default: NOT_REACHED();
-					HASBIT(GetTownRoadMask(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[dir + 3]))), dir ^ 2) ||
-					HASBIT(GetTownRoadMask(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[dir + 1]) + ToTileIndexDiff(_roadblock_tileadd[dir + 2]))), dir) ||
+				case TL_ORIGINAL: /* Disallow the road if any neighboring tile has a road (distance: 1) */
-					HASBIT(GetTownRoadMask(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[dir + 3]) + ToTileIndexDiff(_roadblock_tileadd[dir + 2]))), dir))
+					return !NeighborIsRoadTile(tile, dir, RB_TILE_DIST1);
-				return false;
+				case TL_BETTER_ROADS: /* Disallow the road if any neighboring tile has a road (distance: 1 and 2). */
-			/* Otherwise allow */
+					return !(NeighborIsRoadTile(tile, dir, RB_TILE_DIST1) ||
-			return true;
+							NeighborIsRoadTile(tile, dir, RB_TILE_DIST2));
+			}
 		}
 		/* If the tile is not a slope in the right direction, then
 		 * maybe terraform some. */
 		k = (dir & 1) ? SLOPE_NE : SLOPE_NW;
 	if (!TerraformTownTile(tile, ~tileh & 0xF, 1)) {
 		TerraformTownTile(tile, tileh & 0xF, 0);
 	}
 }
+/**
+* Generate the RoadBits of a grid tile
+*
+* @param t current town
+* @param tile tile in reference to the town
+* @return the RoadBit of the current tile regarding
+*  the selected town layout
+*/
+static RoadBits GetTownRoadGridElement(Town* t, TileIndex tile)
+{
+	/* align the grid to the downtown */
+	TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile); ///< Vector from downtown to the tile
+	/* 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);
+			ly = ((grid_pos.y % 3) == 0);
+			break;
+		case TL_3X3_GRID:
+			lx = ((grid_pos.x % 4) == 0);
+			ly = ((grid_pos.y % 4) == 0);
+			break;
+	}
+	/* generate the basic grid structure */
+	if (!lx && !ly) {         ///< It is a house tile
+		return ROAD_NONE;
+	} else if (lx && !ly) {   ///< It is a Y-dir road tile
+		return ROAD_Y;
+	} else if (!lx && ly) {   ///< It is a X-dir road tile
+		return ROAD_X;
+	} else {                  ///< It is a crossing tile
+		/* Presets for junctions on slopes
+		 * not nice :( */
+		switch (GetTileSlope(tile, NULL)) {
+			case SLOPE_W:
+				return ROAD_NW | ROAD_SW;
+			case SLOPE_S:
+				return ROAD_SE | ROAD_SW;
+			case SLOPE_SW:
+				return ROAD_Y | ROAD_SW;
+			case SLOPE_E:
+				return ROAD_NE | ROAD_SE;
+			case SLOPE_SE:
+				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;
+			default:
+				return ROAD_ALL;
+		}
+	}
+}
+/**
+* Check there are enougth 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
+*/
+static bool NeighborsAreHouseTiles(TileIndex tile)
+{
+	uint counter = 0; ///< counts the house neighbor tiles
+	/* We can't look further than that. */
+	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++) {
+		if (IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[i])), MP_HOUSE)) {
+			counter++;
+		}
+		/* If there are enougth neighbor's stop it here */
+		if (counter >= 3) {
+			return true;
+		}
+	}
+	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 TL_ORIGINAL
+* 	@li TL_BETTER_ROADS
+* @li Check if the town geometry allows a road and which one
+* 	@li TL_2X2_GRID
+* 	@li TL_3X3_GRID
+* @li Forbid roads, only build houses
+* 	@li TL_NO_ROADS
+*
+* @param tile_ptr current tile
+* @param mask current tiles RoadBits
+* @param block road block
+* @param t1 current town
+*/
 static void GrowTownInTile(TileIndex* tile_ptr, RoadBits mask, int block, Town* t1)
 {
 	RoadBits rcmd;
 	TileIndex tmptile;
 	DiagDirection i;
 		/* Remove hills etc */
 		LevelTownLand(tile);
 		/* Is a road allowed here? */
-		if (!IsRoadAllowedHere(tile, block)) return;
+		switch (_patches.town_layout) {
+			default: NOT_REACHED();
-		/* Randomize new road block numbers */
-		a = block;
+			case TL_NO_ROADS: /* Disallow Roads */
-		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. */
-			if (a != (b ^ 2)) return;
-			/* Return if neither side of the new road is a house */
-			if (!IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a + 1])), MP_HOUSE) &&
-					!IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a + 3])), MP_HOUSE))
 				return;
-			/* That means that the road is only allowed if there is a house
+			case TL_3X3_GRID:
-			 *  at any side of the new road. */
+			case TL_2X2_GRID:
-		}
+				rcmd = GetTownRoadGridElement(t1, tile);
-		rcmd = (RoadBits)((1 << a) + (1 << b));
+				if (rcmd == ROAD_NONE) {
+					return;
+				}
+				break;
+			case TL_BETTER_ROADS:
+			case TL_ORIGINAL:
+				if (!IsRoadAllowedHere(tile, block)) {
+					return;
+				}
+				/* Randomize new road block numbers */
+				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. */
+					if (a != (b ^ 2)) {
+						return;
+					}
+					/* Return if neither side of the new road is a house */
+					if (!IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a + 1])), MP_HOUSE) &&
+							!IsTileType(TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[a + 3])), 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)((1 << a) + (1 << b));
+				break;
+		}
 	} else if (block < 5 && !HASBIT(mask, block ^ 2)) {
 		/* Continue building on a partial road.
 		 * Always OK. */
 		_grow_town_result = 0;
-		rcmd = (RoadBits)(1 << (block ^ 2));
+		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);
+				break;
+			case TL_BETTER_ROADS:
+			case TL_ORIGINAL:
+				rcmd = (RoadBits)(1 << (block ^ 2));
+				break;
+		}
 	} else {
 		int i;
+		bool allow_house = false;
+		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);
 		tmptile = TILE_ADD(tile, ToTileIndexDiff(_roadblock_tileadd[i]));
 		/* Don't do it if it reaches to water. */
 		if (IsClearWaterTile(tmptile)) return;
-		/* Build a house at the edge. 60% chance or
+		switch (_patches.town_layout) {
-		 *  always ok if no road allowed. */
+			default: NOT_REACHED();
-		if (!IsRoadAllowedHere(tmptile, i) || CHANCE16(6, 10)) {
-			/* But not if there already is a house there. */
+			case TL_NO_ROADS:
+				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]));
+				if (NeighborsAreHouseTiles(tmptile2) && BuildTownHouse(t1, tmptile2)) {
+					_grow_town_result = -1;
+				}
+			case TL_2X2_GRID:
+				rcmd = GetTownRoadGridElement(t1, tmptile);
+				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]));
+				if (NeighborsAreHouseTiles(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));
+				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 */
 				LevelTownLand(tmptile);
 				/* And build a house.
 				 * Set result to -1 if we managed to build it. */
-				if (BuildTownHouse(t1, tmptile)) _grow_town_result = -1;
+				if (BuildTownHouse(t1, tmptile)) {
+					_grow_town_result = -1;
+				}
 			}
 			return;
 		}
 		_grow_town_result = 0;
 build_road_and_exit:
 			if (!CmdFailed(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)) ||
+			(rcmd == ROAD_Y && (i == DIAGDIR_NE || i == DIAGDIR_SW))) {
+		goto build_road_and_exit;
 	}
 	tmptile = tile;
 	/* Now it contains the direction of the slope */
 {
 	int block = 5; // special case
 	TILE_ASSERT(tile);
-	/* Number of times to search. */
+	/* Number of times to search.
-	_grow_town_result = 10 + t->num_houses * 4 / 9;
+	 * Better roads, 2X2 and 3X3 grid grow quite fast so we give
+	 * them a little handicap. */
+	switch (_patches.town_layout) {
+		case TL_BETTER_ROADS:
+			_grow_town_result = 10 + t->num_houses * 2 / 9;
+			break;
+		case TL_3X3_GRID:
+		case TL_2X2_GRID:
+			_grow_town_result = 10 + t->num_houses * 1 / 9;
+			break;
+		default:
+			_grow_town_result = 10 + t->num_houses * 4 / 9;
+			break;
+	}
 	do {
 		/* Get a bitmask of the road blocks on a tile */
 		RoadBits mask = GetTownRoadMask(tile);
 		{ 2,  2},
 		{ 2, -2},
 		{ 0,  0}
 	};
+	/* 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;
 	_current_player = OWNER_TOWN;
 	/* 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) != 0) {
+		if (GetAnyRoadTrackBits(tile, ROADTYPE_ROAD) != 0) {
 			int r = GrowTownAtRoad(t, tile);
 			_current_player = old_player;
 			return r != 0;
 		}
 		tile = TILE_ADD(tile, ToTileIndexDiff(*ptr));
 	 * clearing some land and then building a road there. */
 	tile = t->xy;
 	for (ptr = _town_coord_mod; ptr != endof(_town_coord_mod); ++ptr) {
 		/* Only work with plain land that not already has a house */
 		if (!IsTileType(tile, MP_HOUSE) && GetTileSlope(tile, NULL) == SLOPE_FLAT) {
-			if (!CmdFailed(DoCommand(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR))) {
+			if (!CmdFailed(DoCommand(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR))) {
 				DoCommand(tile, GenRandomRoadBits(), t->index, DC_EXEC | DC_AUTO, CMD_BUILD_ROAD);
 				_current_player = old_player;
 				return true;
 			}
 		}
 		return t;
 	} while (--attempts);
 	return NULL;
 }
-static const byte _num_initial_towns[3] = {11, 23, 46};
+static const byte _num_initial_towns[4] = {5, 11, 23, 46};
 bool GenerateTowns()
 {
 	uint num = 0;
 	uint n = ScaleByMapSize(_num_initial_towns[_opt.diff.number_towns] + (Random() & 7));
 				if (hs->override != 0) hs = GetHouseSpecs(hs->override);
 				if ((hs->extra_flags & BUILDING_IS_HISTORICAL) && !_generating_world) continue;
 				if (HASBIT(hs->callback_mask, CBM_HOUSE_ALLOW_CONSTRUCTION)) {
-					uint16 callback_res = GetHouseCallback(CBID_HOUSE_ALLOW_CONSTRUCTION, 0, house, t, tile);
+					uint16 callback_res = GetHouseCallback(CBID_HOUSE_ALLOW_CONSTRUCTION, 0, 0, house, t, tile);
 					if (callback_res != CALLBACK_FAILED && callback_res == 0) continue;
 				}
 			}
 			if (_cur_year < hs->min_date || _cur_year > hs->max_date) continue;
 Town *ClosestTownFromTile(TileIndex tile, uint threshold)
 {
 	if (IsTileType(tile, MP_HOUSE) || (
 				IsTileType(tile, MP_STREET) &&
-				(IsLevelCrossing(tile) ? GetCrossingRoadOwner(tile) : GetTileOwner(tile)) == OWNER_TOWN
+				GetRoadOwner(tile, ROADTYPE_ROAD) == OWNER_TOWN
 			)) {
 		return GetTownByTile(tile);
 	} else {
 		return CalcClosestTownFromTile(tile, threshold);
 	}
 };
 /* Save and load the mapping between the house id on the map, and the grf file
 * it came from. */
 static const SaveLoad _house_id_mapping_desc[] = {
-	SLE_VAR(HouseIDMapping, grfid,         SLE_UINT32),
+	SLE_VAR(EntityIDMapping, grfid,         SLE_UINT32),
-	SLE_VAR(HouseIDMapping, house_id,      SLE_UINT8),
+	SLE_VAR(EntityIDMapping, entity_id,     SLE_UINT8),
-	SLE_VAR(HouseIDMapping, substitute_id, SLE_UINT8),
+	SLE_VAR(EntityIDMapping, substitute_id, SLE_UINT8),
 	SLE_END()
 };
 static void Save_HOUSEIDS()
 {
-	uint i;
+	uint j = _house_mngr.GetMaxMapping();
-	for (i = 0; i != lengthof(_house_id_mapping); i++) {
+	for (uint i = 0; i < j; i++) {
 		SlSetArrayIndex(i);
-		SlObject(&_house_id_mapping[i], _house_id_mapping_desc);
+		SlObject(&_house_mngr.mapping_ID[i], _house_id_mapping_desc);
 	}
 }
 static void Load_HOUSEIDS()
 {
 	int index;
-	ResetHouseIDMapping();
+	_house_mngr.ResetMapping();
+	uint max_id = _house_mngr.GetMaxMapping();
 	while ((index = SlIterateArray()) != -1) {
-		if ((uint)index >= lengthof(_house_id_mapping)) break;
+		if ((uint)index >= max_id) break;
-		SlObject(&_house_id_mapping[index], _house_id_mapping_desc);
+		SlObject(&_house_mngr.mapping_ID[index], _house_id_mapping_desc);
 	}
 }
 static void Save_TOWN()
 {

branch	gamebalance
changeset 9911	0b8b245a2391
parent 9910	0b2aebc8283e
child 9912	1ac8aac92385