openttd-ottdgrfs: comparison src/town

equal deleted inserted replaced

-:3998f2e73dda
+:6404afe43575
 	MarkWholeScreenDirty();
 	this->xy = 0;
 }
+/**
+* Generate a random town road layout.
+*
+* The layout is based on the TileHash.
+*/
+void Town::InitializeLayout()
+{
+	this->layout = (TownLayout)(TileHash(TileX(this->xy), TileY(this->xy)) % NUM_TLS);
+	/* Set invalid layouts to valid ones */
+	switch (this->layout) {
+		default: break;
+		case TL_RANDOM: this->layout = TL_ORIGINAL; break;
+		case TL_NO_ROADS: this->layout = TL_BETTER_ROADS; break;
+	}
+}
 // Local
 static int _grow_town_result;
 /* Describe the possible states */
 enum TownGrowthResult {
 {
 	AddChildSpriteScreen(SPR_LIFT, PAL_NONE, 14, 60 - GetLiftPosition(ti->tile));
 }
 typedef void TownDrawTileProc(const TileInfo *ti);
-static TownDrawTileProc * const _town_draw_tile_procs[1] = {
+static TownDrawTileProc *const _town_draw_tile_procs[1] = {
 	TownDrawHouseLift
 };
-uint OriginalTileRandomiser(uint x, uint y)
-{
-	uint variant;
-	variant  = x >> 4;
-	variant ^= x >> 6;
-	variant ^= y >> 4;
-	variant -= y >> 6;
-	variant &= 3;
-	return variant;
-}
 /**
 * Return a random direction
 *
 * @return a random direction
 * 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;
 	HouseID house_id = GetHouseType(ti->tile);
 	if (house_id >= NEW_HOUSE_OFFSET) {
 		/* Houses don't necessarily need new graphics. If they don't have a
 		 * spritegroup associated with them, then the sprite for the substitute
 			house_id = GetHouseSpecs(house_id)->substitute_id;
 		}
 	}
 	/* Retrieve pointer to the draw town tile struct */
-	dcts = &_town_draw_tile_data[house_id << 4 | OriginalTileRandomiser(ti->x, ti->y) << 2 | GetHouseBuildingStage(ti->tile)];
+	const DrawBuildingsTileStruct *dcts = &_town_draw_tile_data[house_id << 4 | TileHash2Bit(ti->x, ti->y) << 2 | GetHouseBuildingStage(ti->tile)];
 	if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
-	image = dcts->ground.sprite;
+	DrawGroundSprite(dcts->ground.sprite, dcts->ground.pal);
-	pal   = dcts->ground.pal;
-	DrawGroundSprite(image, pal);
+	/* If houses are invisible, do not draw the upper part */
+	if (IsInvisibilitySet(TO_HOUSES)) return;
 	/* Add a house on top of the ground? */
-	image = dcts->building.sprite;
+	SpriteID image = dcts->building.sprite;
 	if (image != 0) {
 		AddSortableSpriteToDraw(image, dcts->building.pal,
 			ti->x + dcts->subtile_x,
 			ti->y + dcts->subtile_y,
 			dcts->width,
 * 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) {
 		AnimateNewHouseTile(tile);
 		return;
 	}
 		DeleteAnimatedTile(tile);
 		return;
 	}
 	if (!LiftHasDestination(tile)) {
-		int i;
+		uint i;
-		/*  Building has 6 floors, number 0 .. 6, where 1 is illegal.
+		/* Building has 6 floors, number 0 .. 6, where 1 is illegal.
-		 *  This is due to the fact that the first floor is, in the graphics,
+		 * This is due to the fact that the first floor is, in the graphics,
 		 *  the height of 2 'normal' floors.
-		 *  Furthermore, there are 6 lift positions from floor N (incl) to floor N + 1 (excl) */
+		 * Furthermore, there are 6 lift positions from floor N (incl) to floor N + 1 (excl) */
 		do {
-			i = (Random() & 7) - 1;
+			i = RandomRange(7);
-		} while (i < 0 || i == 1 || i * 6 == GetLiftPosition(tile));
+		} while (i == 1 || i * 6 == GetLiftPosition(tile));
 		SetLiftDestination(tile, i);
 	}
-	pos = GetLiftPosition(tile);
+	int pos = GetLiftPosition(tile);
-	dest = GetLiftDestination(tile) * 6;
+	int dest = GetLiftDestination(tile) * 6;
 	pos += (pos < dest) ? 1 : -1;
 	SetLiftPosition(tile, pos);
 	if (pos == dest) HaltLift(tile);
 * @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;
+	const Town *t;
 	FOR_ALL_TOWNS(t) {
 		if (DistanceManhattan(tile, t->xy) < dist) return true;
 	}
 	return false;
 * population (creation or growth or else)
 * @param t Town to update
 */
 void UpdateTownVirtCoord(Town *t)
 {
-	Point pt;
 	MarkTownSignDirty(t);
-	pt = RemapCoords2(TileX(t->xy) * TILE_SIZE, TileY(t->xy) * TILE_SIZE);
+	Point pt = RemapCoords2(TileX(t->xy) * TILE_SIZE, TileY(t->xy) * TILE_SIZE);
 	SetDParam(0, t->index);
 	SetDParam(1, t->population);
 	UpdateViewportSignPos(&t->sign, pt.x, pt.y - 24,
 		_patches.population_in_label ? STR_TOWN_LABEL_POP : STR_TOWN_LABEL);
 	MarkTownSignDirty(t);
 * Basically, count population of all towns, one by one
 * @return uint32 the calculated population of the world
 */
 uint32 GetWorldPopulation()
 {
-	uint32 pop;
+	uint32 pop = 0;
-	const Town* t;
+	const Town *t;
-	pop = 0;
 	FOR_ALL_TOWNS(t) pop += t->population;
 	return pop;
 }
 /**
 * 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);
-	HouseSpec *hs = GetHouseSpecs(house_id);
 	/* NewHouseTileLoop returns false if Callback 21 succeeded, i.e. the house
 	 * doesn't exist any more, so don't continue here. */
 	if (house_id >= NEW_HOUSE_OFFSET && !NewHouseTileLoop(tile)) return;
 		/* Construction is not completed. See if we can go further in construction*/
 		MakeTownHouseBigger(tile);
 		return;
 	}
+	const HouseSpec *hs = GetHouseSpecs(house_id);
 	/* 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))
+			Chance16(1, 2)) {
 		AddAnimatedTile(tile);
+	}
-	t = GetTownByTile(tile);
+	Town *t = GetTownByTile(tile);
-	r = Random();
+	uint32 r = Random();
 	if (HasBit(hs->callback_mask, CBM_HOUSE_PRODUCE_CARGO)) {
 		for (uint i = 0; i < 256; i++) {
 			uint16 callback = GetHouseCallback(CBID_HOUSE_PRODUCE_CARGO, i, r, house_id, t, tile);
 			}
 		}
 	} else {
 		if (GB(r, 0, 8) < hs->population) {
 			uint amt = GB(r, 0, 8) / 8 + 1;
-			uint moved;
 			if (_economy.fluct <= 0) amt = (amt + 1) >> 1;
 			t->new_max_pass += amt;
-			moved = MoveGoodsToStation(tile, 1, 1, CT_PASSENGERS, amt);
+			t->new_act_pass += MoveGoodsToStation(tile, 1, 1, CT_PASSENGERS, amt);
-			t->new_act_pass += moved;
 		}
 		if (GB(r, 8, 8) < hs->mail_generation) {
 			uint amt = GB(r, 8, 8) / 8 + 1;
-			uint moved;
 			if (_economy.fluct <= 0) amt = (amt + 1) >> 1;
 			t->new_max_mail += amt;
-			moved = MoveGoodsToStation(tile, 1, 1, CT_MAIL, amt);
+			t->new_act_mail += MoveGoodsToStation(tile, 1, 1, CT_MAIL, amt);
-			t->new_act_mail += moved;
 		}
 	}
 	_current_player = OWNER_TOWN;
 	/* not used */
 }
 static CommandCost ClearTile_Town(TileIndex tile, byte flags)
 {
-	int rating;
-	CommandCost cost(EXPENSES_CONSTRUCTION);
-	Town *t;
-	HouseSpec *hs = GetHouseSpecs(GetHouseType(tile));
 	if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);
 	if (!CanDeleteHouse(tile)) return CMD_ERROR;
+	const HouseSpec *hs = GetHouseSpecs(GetHouseType(tile));
+	CommandCost cost(EXPENSES_CONSTRUCTION);
 	cost.AddCost(_price.remove_house * hs->removal_cost >> 8);
-	rating = hs->remove_rating_decrease;
+	int rating = hs->remove_rating_decrease;
 	_cleared_town_rating += rating;
-	_cleared_town = t = GetTownByTile(tile);
+	Town *t = _cleared_town = GetTownByTile(tile);
 	if (IsValidPlayer(_current_player)) {
 		if (rating > t->ratings[_current_player] && !(flags & DC_NO_TOWN_RATING) && !_cheats.magic_bulldozer.value) {
 			SetDParam(0, t->index);
 			return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);
 	}
 	return cost;
 }
+static void GetProducedCargo_Town(TileIndex tile, CargoID *b)
+{
+	HouseID house_id = GetHouseType(tile);
+	const HouseSpec *hs = GetHouseSpecs(house_id);
+	Town *t = GetTownByTile(tile);
+	if (HasBit(hs->callback_mask, CBM_HOUSE_PRODUCE_CARGO)) {
+		for (uint i = 0; i < 256; i++) {
+			uint16 callback = GetHouseCallback(CBID_HOUSE_PRODUCE_CARGO, i, 0, house_id, t, tile);
+			if (callback == CALLBACK_FAILED || callback == CALLBACK_HOUSEPRODCARGO_END) break;
+			CargoID cargo = GetCargoTranslation(GB(callback, 8, 7), hs->grffile);
+			if (cargo == CT_INVALID) continue;
+			*(b++) = cargo;
+		}
+	} else {
+		if (hs->population > 0) {
+			*(b++) = CT_PASSENGERS;
+		}
+		if (hs->mail_generation > 0) {
+			*(b++) = CT_MAIL;
+		}
+	}
+}
 static void GetAcceptedCargo_Town(TileIndex tile, AcceptedCargo ac)
 {
-	HouseSpec *hs = GetHouseSpecs(GetHouseType(tile));
+	const HouseSpec *hs = GetHouseSpecs(GetHouseType(tile));
 	CargoID accepts[3];
 	/* Set the initial accepted cargo types */
 	for (uint8 i = 0; i < lengthof(accepts); i++) {
 		accepts[i] = hs->accepts_cargo[i];
 }
 /**
 * Check if a Road is allowed on a given tile
 *
+* @param t The current town
 * @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)
+static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
 {
 	if (TileX(tile) < 2 || TileX(tile) >= MapMaxX() || TileY(tile) < 2 || TileY(tile) >= MapMaxY()) return false;
 	Slope cur_slope, desired_slope;
 		cur_slope = GetTileSlope(tile, NULL);
 		if (cur_slope == SLOPE_FLAT) {
 no_slope:
 			/* Tile has no slope */
-			switch (_patches.town_layout) {
+			switch (t->GetActiveLayout()) {
 				default: NOT_REACHED();
 				case TL_ORIGINAL: // Disallow the road if any neighboring tile has a road (distance: 1)
 					return !IsNeighborRoadTile(tile, dir, 1);
 	}
 }
 static bool TerraformTownTile(TileIndex tile, int edges, int dir)
 {
-	CommandCost r;
 	TILE_ASSERT(tile);
-	r = DoCommand(tile, edges, dir, DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
+	CommandCost r = DoCommand(tile, edges, dir, DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
-	if (CmdFailed(r) || r.GetCost() >= 126 * 16) return false;
+	if (CmdFailed(r) || r.GetCost() >= (_price.terraform + 2) * 8) return false;
 	DoCommand(tile, edges, dir, DC_AUTO | DC_NO_WATER | DC_EXEC, CMD_TERRAFORM_LAND);
 	return true;
 }
 static void LevelTownLand(TileIndex tile)
 {
-	Slope tileh;
 	TILE_ASSERT(tile);
 	/* Don't terraform if land is plain or if there's a house there. */
 	if (IsTileType(tile, MP_HOUSE)) return;
-	tileh = GetTileSlope(tile, NULL);
+	Slope tileh = GetTileSlope(tile, NULL);
 	if (tileh == SLOPE_FLAT) return;
 	/* First try up, then down */
 	if (!TerraformTownTile(tile, ~tileh & SLOPE_ELEVATED, 1)) {
 		TerraformTownTile(tile, tileh & SLOPE_ELEVATED, 0);
 * @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, DiagDirection dir)
+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;
-	switch (_patches.town_layout) {
+	switch (t->GetActiveLayout()) {
 		default: NOT_REACHED();
 		case TL_2X2_GRID:
 			if ((grid_pos.x % 3) == 0) rcmd |= ROAD_Y;
 			if ((grid_pos.y % 3) == 0) rcmd |= ROAD_X;
 		/* Remove hills etc */
 		LevelTownLand(tile);
 		/* Is a road allowed here? */
-		switch (_patches.town_layout) {
+		switch (t1->GetActiveLayout()) {
 			default: NOT_REACHED();
 			case TL_NO_ROADS: /* Disallow Roads */
 				return;
 				if (rcmd == ROAD_NONE) return;
 				break;
 			case TL_BETTER_ROADS:
 			case TL_ORIGINAL:
-				if (!IsRoadAllowedHere(tile, target_dir)) return;
+				if (!IsRoadAllowedHere(t1, tile, target_dir)) 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);
 				}
-				if (!IsRoadAllowedHere(TileAddByDiagDir(tile, target_dir), target_dir)) {
+				if (!IsRoadAllowedHere(t1, 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 */
 		/* Continue building on a partial road.
 		 * Should be allways OK, so we only generate
 		 * the fitting RoadBits */
 		_grow_town_result = GROWTH_SEARCH_STOPPED;
-		switch (_patches.town_layout) {
+		switch (t1->GetActiveLayout()) {
 			default: NOT_REACHED();
 			case TL_NO_ROADS: /* Disallow Roads */
 				return;
 		TileIndex house_tile = TileAddByDiagDir(tile, target_dir); // position of a possible house
 		/* Don't walk into water. */
 		if (IsWaterTile(house_tile)) return;
-		switch (_patches.town_layout) {
+		switch (t1->GetActiveLayout()) {
 			default: NOT_REACHED();
 			case TL_NO_ROADS:
 				allow_house = true;
 				break;
 			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(house_tile, target_dir) || Chance16(6, 10));
+				allow_house = (!IsRoadAllowedHere(t1, house_tile, target_dir) || Chance16(6, 10));
 				break;
 		}
 		if (allow_house) {
 			/* Build a house, but not if there already is a house there. */
 	TILE_ASSERT(tile);
 	/* Number of times to search.
 	 * Better roads, 2X2 and 3X3 grid grow quite fast so we give
 	 * them a little handicap. */
-	switch (_patches.town_layout) {
+	switch (t->GetActiveLayout()) {
 		case TL_BETTER_ROADS:
 			_grow_town_result = 10 + t->num_houses * 2 / 9;
 			break;
 		case TL_3X3_GRID:
 	if (a == b) b ^= 2;
 	return (RoadBits)((ROAD_NW << a) + (ROAD_NW << b));
 }
 /** Grow the town
-* @Return true if a house was built, or no if the build failed. */
+* @param t town to grow
+* @return true iff a house was built
+*/
 static bool GrowTown(Town *t)
 {
 	/* 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;
 		{-2,  2},
 		{ 2,  2},
 		{ 2, -2},
 		{ 0,  0}
 	};
-	const TileIndexDiffC *ptr;
 	/* 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
 	/* Find a road that we can base the construction on. */
+	const TileIndexDiffC *ptr;
 	for (ptr = _town_coord_mod; ptr != endof(_town_coord_mod); ++ptr) {
 		if (GetTownRoadBits(tile) != ROAD_NONE) {
 			int r = GrowTownAtRoad(t, tile);
 			_current_player = old_player;
 			return r != 0;
 	int tries = 1000;
 	bool grf = (_opt.town_name >= _nb_orig_names);
 	uint32 grfid = grf ? GetGRFTownNameId(_opt.town_name - _nb_orig_names) : 0;
 	uint16 townnametype = grf ? GetGRFTownNameType(_opt.town_name - _nb_orig_names) : SPECSTR_TOWNNAME_START + _opt.town_name;
-	assert(townnameparts);
+	assert(townnameparts != NULL);
 	for (;;) {
 restart:
 		r = Random();
 * @param size Parameter for size determination
 */
 static void DoCreateTown(Town *t, TileIndex tile, uint32 townnameparts, TownSizeMode size_mode, uint size)
 {
 	extern int _nb_orig_names;
-	int x, i;
 	t->xy = tile;
 	t->num_houses = 0;
 	t->time_until_rebuild = 10;
 	UpdateTownRadius(t);
 	t->new_act_food = 0;
 	t->new_act_water = 0;
 	t->act_food = 0;
 	t->act_water = 0;
-	for (i = 0; i != MAX_PLAYERS; i++)
+	for (uint i = 0; i != MAX_PLAYERS; i++) t->ratings[i] = RATING_INITIAL;
-		t->ratings[i] = 500;
 	t->have_ratings = 0;
 	t->exclusivity = INVALID_PLAYER;
 	t->exclusive_counter = 0;
 	t->statues = 0;
 	t->townnameparts = townnameparts;
 	UpdateTownVirtCoord(t);
 	_town_sort_dirty = true;
+	t->InitializeLayout();
 	/* Random town size. */
-	x = (Random() & 0xF) + 8;
+	int x = (Random() & 0xF) + 8;
 	switch (size_mode) {
 		default: NOT_REACHED();
 		case TSM_RANDOM:
 	}
 	t->num_houses += x;
 	UpdateTownRadius(t);
-	i = x * 4;
+	int i = x * 4;
 	do {
 		GrowTown(t);
 	} while (--i);
 	t->num_houses -= x;
 * @param p1 size of the town (0 = small, 1 = medium, 2 = large)
 * @param p2 size mode (@see TownSizeMode)
 */
 CommandCost CmdBuildTown(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	uint32 townnameparts;
 	/* Only in the scenario editor */
 	if (_game_mode != GM_EDITOR) return CMD_ERROR;
 	if (p2 > TSM_CITY) return CMD_ERROR;
 	/* Check if too close to the edge of map */
 	}
 	/* Check distance to all other towns. */
 	if (IsCloseToTown(tile, 20))
 		return_cmd_error(STR_0238_TOO_CLOSE_TO_ANOTHER_TOWN);
+	uint32 townnameparts;
 	/* Get a unique name for the town. */
 	if (!CreateTownName(&townnameparts))
 		return_cmd_error(STR_023A_TOO_MANY_TOWNS);
 	return CommandCost();
 }
 Town *CreateRandomTown(uint attempts, TownSizeMode mode, uint size)
 {
-	TileIndex tile;
-	Town *t;
-	uint32 townnameparts;
 	do {
 		/* Generate a tile index not too close from the edge */
-		tile = RandomTile();
+		TileIndex tile = RandomTile();
 		if (DistanceFromEdge(tile) < 20) continue;
 		/* Make sure the tile is plain */
 		if (!IsTileType(tile, MP_CLEAR) || GetTileSlope(tile, NULL) != SLOPE_FLAT) continue;
 		/* Check not too close to a town */
 		if (IsCloseToTown(tile, 20)) continue;
+		uint32 townnameparts;
 		/* Get a unique name for the town. */
 		if (!CreateTownName(&townnameparts)) break;
 		/* Allocate a town struct */
-		t = new Town(tile);
+		Town *t = new Town(tile);
 		if (t == NULL) break;
 		DoCreateTown(t, tile, townnameparts, mode, size);
 		return t;
-	} while (--attempts);
+	} while (--attempts != 0);
 	return NULL;
 }
 static const byte _num_initial_towns[4] = {5, 11, 23, 46};
 /** Returns the bit corresponding to the town zone of the specified tile
 * @param t Town on which radius is to be found
 * @param tile TileIndex where radius needs to be found
 * @return the bit position of the given zone, as defined in HouseZones
 */
-HouseZonesBits GetTownRadiusGroup(const Town* t, TileIndex tile)
+HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
 {
 	uint dist = DistanceSquare(tile, t->xy);
-	HouseZonesBits smallest;
-	uint i;
 	if (t->fund_buildings_months && dist <= 25) return HZB_TOWN_CENTRE;
-	smallest = HZB_TOWN_EDGE;
+	HouseZonesBits smallest = HZB_TOWN_EDGE;
-	for (i = 0; i != lengthof(t->radius); i++) {
+	for (HouseZonesBits i = HZB_BEGIN; i < HZB_END; i++) {
-		if (dist < t->radius[i]) smallest = (HouseZonesBits)i;
+		if (dist < t->radius[i]) smallest = i;
 	}
 	return smallest;
 }
 */
 static inline bool TownLayoutAllowsHouseHere(Town *t, TileIndex tile)
 {
 	TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile);
-	switch (_patches.town_layout) {
+	switch (t->GetActiveLayout()) {
 		case TL_2X2_GRID:
 			if ((grid_pos.x % 3) == 0 || (grid_pos.y % 3) == 0) return false;
 			break;
 		case TL_3X3_GRID:
 	/* MapSize() is sure dividable by both MapSizeX() and MapSizeY(),
 	 * so to do only one memory access, use MapSize() */
 	uint dx = MapSize() + TileX(t->xy) - TileX(tile);
 	uint dy = MapSize() + TileY(t->xy) - TileY(tile);
-	switch (_patches.town_layout) {
+	switch (t->GetActiveLayout()) {
 		case TL_2X2_GRID:
 			if ((dx % 3) != 0 || (dy % 3) != 0) return false;
 			break;
 		case TL_3X3_GRID:
 	uint probs[HOUSE_MAX];
 	uint probability_max = 0;
 	/* Generate a list of all possible houses that can be built. */
 	for (uint i = 0; i < HOUSE_MAX; i++) {
-		HouseSpec *hs = GetHouseSpecs(i);
+		const HouseSpec *hs = GetHouseSpecs(i);
 		/* Verify that the candidate house spec matches the current tile status */
 		if ((~hs->building_availability & bitmask) == 0 && hs->enabled) {
 			/* Without NewHouses, all houses have probability '1' */
 			uint cur_prob = (_loaded_newgrf_features.has_newhouses ? hs->probability : 1);
 			probability_max += cur_prob;
 		/* remove tested house from the set */
 		num--;
 		houses[i] = houses[num];
 		probs[i] = probs[num];
-		HouseSpec *hs = GetHouseSpecs(house);
+		const HouseSpec *hs = GetHouseSpecs(house);
 		if (_loaded_newgrf_features.has_newhouses) {
 			if (hs->override != 0) {
 				house = hs->override;
 				hs = GetHouseSpecs(house);
 	DeleteAnimatedTile(tile);
 }
 void ClearTownHouse(Town *t, TileIndex tile)
 {
+	assert(IsTileType(tile, MP_HOUSE));
 	HouseID house = GetHouseType(tile);
-	uint eflags;
-	HouseSpec *hs;
-	assert(IsTileType(tile, MP_HOUSE));
 	/* need to align the tile to point to the upper left corner of the house */
 	if (house >= 3) { // house id 0,1,2 MUST be single tile houses, or this code breaks.
 		if (GetHouseSpecs(house-1)->building_flags & TILE_SIZE_2x1) {
 			house--;
 			house-=3;
 			tile += TileDiffXY(-1, -1);
 		}
 	}
-	hs = GetHouseSpecs(house);
+	const HouseSpec *hs = GetHouseSpecs(house);
 	/* Remove population from the town if the house is finished. */
 	if (IsHouseCompleted(tile)) {
 		ChangePopulation(t, -hs->population);
 	}
 	} else if (hs->building_flags & BUILDING_IS_STADIUM) {
 		ClrBit(t->flags12, TOWN_HAS_STADIUM);
 	}
 	/* Do the actual clearing of tiles */
-	eflags = hs->building_flags;
+	uint eflags = hs->building_flags;
 	DoClearTownHouseHelper(tile);
 	if (eflags & BUILDING_2_TILES_X)   DoClearTownHouseHelper(tile + TileDiffXY(1, 0));
 	if (eflags & BUILDING_2_TILES_Y)   DoClearTownHouseHelper(tile + TileDiffXY(0, 1));
 	if (eflags & BUILDING_HAS_4_TILES) DoClearTownHouseHelper(tile + TileDiffXY(1, 1));
 }
 * @param p1 town ID to rename
 * @param p2 unused
 */
 CommandCost CmdRenameTown(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	Town *t;
 	if (!IsValidTownID(p1) || StrEmpty(_cmd_text)) return CMD_ERROR;
-	t = GetTown(p1);
 	if (!IsUniqueTownName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE);
 	if (flags & DC_EXEC) {
+		Town *t = GetTown(p1);
 		free(t->name);
 		t->name = strdup(_cmd_text);
 		UpdateTownVirtCoord(t);
 		_town_sort_dirty = true;
 }
 /** Called from GUI */
 void ExpandTown(Town *t)
 {
-	uint amount, n;
 	_generating_world = true;
 	/* The more houses, the faster we grow */
-	amount = RandomRange(ClampToU16(t->num_houses / 10)) + 3;
+	uint amount = RandomRange(ClampToU16(t->num_houses / 10)) + 3;
 	t->num_houses += amount;
 	UpdateTownRadius(t);
-	n = amount * 10;
+	uint n = amount * 10;
 	do GrowTown(t); while (--n);
 	t->num_houses -= amount;
 	UpdateTownRadius(t);
 extern const byte _town_action_costs[8] = {
 	2, 4, 9, 35, 48, 53, 117, 175
 };
-static void TownActionAdvertiseSmall(Town* t)
+static void TownActionAdvertiseSmall(Town *t)
 {
 	ModifyStationRatingAround(t->xy, _current_player, 0x40, 10);
 }
-static void TownActionAdvertiseMedium(Town* t)
+static void TownActionAdvertiseMedium(Town *t)
 {
 	ModifyStationRatingAround(t->xy, _current_player, 0x70, 15);
 }
-static void TownActionAdvertiseLarge(Town* t)
+static void TownActionAdvertiseLarge(Town *t)
 {
 	ModifyStationRatingAround(t->xy, _current_player, 0xA0, 20);
 }
-static void TownActionRoadRebuild(Town* t)
+static void TownActionRoadRebuild(Town *t)
 {
 	t->road_build_months = 6;
 	SetDParam(0, t->index);
 	SetDParam(1, _current_player);
 		NM_NORMAL, NF_TILE, NT_GENERAL, DNC_NONE, t->xy, 0);
 }
 static bool DoBuildStatueOfCompany(TileIndex tile, TownID town_id)
 {
-	PlayerID old;
-	CommandCost r;
 	/* 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;
 	}
-	old = _current_player;
+	PlayerID old = _current_player;
 	_current_player = OWNER_NONE;
-	r = DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
+	CommandCost r = DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
 	_current_player = old;
 	if (CmdFailed(r)) return false;
 	MakeStatue(tile, _current_player, town_id);
 /**
 * Perform a 9x9 tiles circular search from the center of the town
 * in order to find a free tile to place a statue
 * @param t town to search in
 */
-static void TownActionBuildStatue(Town* t)
+static void TownActionBuildStatue(Town *t)
 {
 	TileIndex tile = t->xy;
-	if (CircularTileSearch(tile, 9, SearchTileForStatue, t->index))
+	if (CircularTileSearch(tile, 9, SearchTileForStatue, t->index)) {
 		SetBit(t->statues, _current_player); // Once found and built, "inform" the Town
-}
+	}
+}
-static void TownActionFundBuildings(Town* t)
+static void TownActionFundBuildings(Town *t)
 {
 	/* Build next tick */
 	t->grow_counter = 1;
 	/* If we were not already growing */
 	SetBit(t->flags12, TOWN_IS_FUNDED);
 	/* And grow for 3 months */
 	t->fund_buildings_months = 3;
 }
-static void TownActionBuyRights(Town* t)
+static void TownActionBuyRights(Town *t)
 {
 	/* Check if it's allowed to by the rights */
 	if (!_patches.exclusive_rights) return;
 	t->exclusive_counter = 12;
 	t->exclusivity = _current_player;
 	ModifyStationRatingAround(t->xy, _current_player, 130, 17);
 }
-static void TownActionBribe(Town* t)
+static void TownActionBribe(Town *t)
 {
-	if (!RandomRange(15)) {
+	if (Chance16(1, 14)) {
-		Station *st;
 		/* set as unwanted for 6 months */
 		t->unwanted[_current_player] = 6;
 		/* set all close by station ratings to 0 */
+		Station *st;
 		FOR_ALL_STATIONS(st) {
 			if (st->town == t && st->owner == _current_player) {
 				for (CargoID i = 0; i < NUM_CARGO; i++) st->goods[i].rating = 0;
 			}
 		}
 	} else {
 		ChangeTownRating(t, RATING_BRIBE_UP_STEP, RATING_BRIBE_MAXIMUM);
 	}
 }
-typedef void TownActionProc(Town* t);
+typedef void TownActionProc(Town *t);
-static TownActionProc * const _town_action_proc[] = {
+static TownActionProc *const _town_action_proc[] = {
 	TownActionAdvertiseSmall,
 	TownActionAdvertiseMedium,
 	TownActionAdvertiseLarge,
 	TownActionRoadRebuild,
 	TownActionBuildStatue,
 * @param p1 town to do the action at
 * @param p2 action to perform, @see _town_action_proc for the list of available actions
 */
 CommandCost CmdDoTownAction(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	Town *t;
 	if (!IsValidTownID(p1) || p2 > lengthof(_town_action_proc)) return CMD_ERROR;
-	t = GetTown(p1);
+	Town *t = GetTown(p1);
 	if (!HasBit(GetMaskOfTownActions(NULL, _current_player, t), p2)) return CMD_ERROR;
 	CommandCost cost(EXPENSES_OTHER, (_price.build_industry >> 8) * _town_action_costs[p2]);
 	return cost;
 }
 static void UpdateTownGrowRate(Town *t)
 {
-	int n;
+	/* Increase player ratings if they're low */
-	Station *st;
+	const Player *p;
-	uint16 m;
-	Player *p;
-	/* Reset player ratings if they're low */
 	FOR_ALL_PLAYERS(p) {
-		if (p->is_active && t->ratings[p->index] <= 200) {
+		if (p->is_active) {
-			t->ratings[p->index] += 5;
+			t->ratings[p->index] = min((int)RATING_GROWTH_MAXIMUM, t->ratings[p->index] + RATING_GROWTH_UP_STEP);
 		}
 	}
-	n = 0;
+	int n = 0;
+	const Station *st;
 	FOR_ALL_STATIONS(st) {
 		if (DistanceSquare(st->xy, t->xy) <= t->radius[0]) {
 			if (st->time_since_load <= 20 || st->time_since_unload <= 20) {
 				n++;
-				if (IsValidPlayer(st->owner) && t->ratings[st->owner] <= 1000-12)
+				if (IsValidPlayer(st->owner)) {
-					t->ratings[st->owner] += 12;
+					int new_rating = t->ratings[st->owner] + RATING_STATION_UP_STEP;
+					t->ratings[st->owner] = min(new_rating, INT16_MAX); // do not let it overflow
+				}
 			} else {
-				if (IsValidPlayer(st->owner) && t->ratings[st->owner] >= -1000+15)
+				if (IsValidPlayer(st->owner)) {
-					t->ratings[st->owner] -= 15;
+					int new_rating = t->ratings[st->owner] + RATING_STATION_DOWN_STEP;
+					t->ratings[st->owner] = max(new_rating, INT16_MIN);
+				}
 			}
 		}
+	}
+	/* clamp all ratings to valid values */
+	for (uint i = 0; i < MAX_PLAYERS; i++) {
+		t->ratings[i] = Clamp(t->ratings[i], RATING_MINIMUM, RATING_MAXIMUM);
 	}
 	ClrBit(t->flags12, TOWN_IS_FUNDED);
 	if (_patches.town_growth_rate == 0 && t->fund_buildings_months == 0) return;
 	static const uint16 _grow_count_values[2][6] = {
 		{ 120, 120, 120, 100,  80,  60 }, // Fund new buildings has been activated
 		{ 320, 420, 300, 220, 160, 100 }  // Normal values
 	};
+	uint16 m;
 	if (t->fund_buildings_months != 0) {
 		m = _grow_count_values[0][min(n, 5)];
 		t->fund_buildings_months--;
 	} else {
 		m = _grow_count_values[1][min(n, 5)];
 	InvalidateWindow(WC_TOWN_VIEW, t->index);
 }
 static void UpdateTownUnwanted(Town *t)
 {
-	const Player* p;
+	const Player *p;
 	FOR_ALL_PLAYERS(p) {
 		if (t->unwanted[p->index] > 0) t->unwanted[p->index]--;
 	}
 }
 bool CheckIfAuthorityAllows(TileIndex tile)
 {
-	Town *t;
 	if (!IsValidPlayer(_current_player)) return true;
-	t = ClosestTownFromTile(tile, _patches.dist_local_authority);
+	Town *t = ClosestTownFromTile(tile, _patches.dist_local_authority);
 	if (t == NULL) return true;
-	if (t->ratings[_current_player] > -200) return true;
+	if (t->ratings[_current_player] > RATING_VERYPOOR) return true;
 	_error_message = STR_2009_LOCAL_AUTHORITY_REFUSES;
 	SetDParam(0, t->index);
 	return false;
 }
-Town* CalcClosestTownFromTile(TileIndex tile, uint threshold)
+Town *CalcClosestTownFromTile(TileIndex tile, uint threshold)
 {
 	Town *t;
-	uint dist, best = threshold;
+	uint best = threshold;
 	Town *best_town = NULL;
 	FOR_ALL_TOWNS(t) {
-		dist = DistanceManhattan(tile, t->xy);
+		uint dist = DistanceManhattan(tile, t->xy);
 		if (dist < best) {
 			best = dist;
 			best_town = t;
 		}
 	}
 	_town_rating_test = !(ref_count == 0);
 }
 void ChangeTownRating(Town *t, int add, int max)
 {
-	int rating;
 	/* if magic_bulldozer cheat is active, town doesn't penaltize for removing stuff */
 	if (t == NULL ||
 			!IsValidPlayer(_current_player) ||
 			(_cheats.magic_bulldozer.value && add < 0)) {
 		return;
 	}
 	SetBit(t->have_ratings, _current_player);
-	rating = _town_rating_test ? t->test_rating : t->ratings[_current_player];
+	int rating = _town_rating_test ? t->test_rating : t->ratings[_current_player];
 	if (add < 0) {
 		if (rating > max) {
 			rating += add;
 			if (rating < max) rating = max;
 	{ 96, 384, 768}, // Hostile
 };
 bool CheckforTownRating(uint32 flags, Town *t, byte type)
 {
-	int modemod;
 	/* if magic_bulldozer cheat is active, town doesn't restrict your destructive actions */
 	if (t == NULL || !IsValidPlayer(_current_player) || _cheats.magic_bulldozer.value)
 		return true;
 	/* check if you're allowed to remove the street/bridge/tunnel/industry
 	 * owned by a town no removal if rating is lower than ... depends now on
 	 * difficulty setting. Minimum town rating selected by difficulty level
 	 */
-	modemod = _default_rating_settings[_opt.diff.town_council_tolerance][type];
+	int modemod = _default_rating_settings[_opt.diff.town_council_tolerance][type];
 	if ((_town_rating_test ? t->test_rating : t->ratings[_current_player]) < 16 + modemod && !(flags & DC_NO_TOWN_RATING)) {
 		SetDParam(0, t->index);
 		_error_message = STR_2009_LOCAL_AUTHORITY_REFUSES;
 		return false;
 	}
 }
 void InitializeTowns()
 {
-	Subsidy *s;
 	/* Clean the town pool and create 1 block in it */
 	_Town_pool.CleanPool();
 	_Town_pool.AddBlockToPool();
 	memset(_subsidies, 0, sizeof(_subsidies));
-	for (s=_subsidies; s != endof(_subsidies); s++)
+	for (Subsidy *s = _subsidies; s != endof(_subsidies); s++) {
 		s->cargo_type = CT_INVALID;
+	}
 	_cur_town_ctr = 0;
 	_cur_town_iter = 0;
 	_total_towns = 0;
 	_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);
+		const 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 CommandCost(EXPENSES_CONSTRUCTION, _price.terraform);
 	}
 	GetTileTrackStatus_Town, /* get_tile_track_status_proc */
 	ClickTile_Town,          /* click_tile_proc */
 	AnimateTile_Town,        /* animate_tile_proc */
 	TileLoop_Town,           /* tile_loop_clear */
 	ChangeTileOwner_Town,    /* change_tile_owner_clear */
-	NULL,                    /* get_produced_cargo_proc */
+	GetProducedCargo_Town,   /* get_produced_cargo_proc */
 	NULL,                    /* vehicle_enter_tile_proc */
 	GetFoundation_Town,      /* get_foundation_proc */
 	TerraformTile_Town,      /* terraform_tile_proc */
 };
 }
 void AfterLoadTown()
 {
 	_town_sort_dirty = true;
+	Town *t;
+	FOR_ALL_TOWNS(t) t->InitializeLayout();
 }
 extern const ChunkHandler _town_chunk_handlers[] = {
 	{ 'HIDS', Save_HOUSEIDS, Load_HOUSEIDS, CH_ARRAY },
 	{ 'CITY', Save_TOWN,     Load_TOWN,     CH_ARRAY | CH_LAST},

branch	noai
changeset 9869	6404afe43575
parent 9837	c9ec4f82e0d0
child 10142	56ee7da4ad56