openttd-ottdgrfs: comparison src/town

equal deleted inserted replaced

-:ebf0ece7d8f6
+:eee46cb39750
 /** @file town_cmd.cpp */
 #include "stdafx.h"
 #include "openttd.h"
-#include "functions.h"
+#include "tile_cmd.h"
 #include "debug.h"
-#include "strings.h"
 #include "road_map.h"
+#include "road_internal.h" /* Cleaning up road bits */
 #include "table/strings.h"
 #include "table/sprites.h"
-#include "map.h"
 #include "landscape.h"
-#include "tile.h"
 #include "town_map.h"
 #include "tunnel_map.h"
-#include "viewport.h"
+#include "viewport_func.h"
 #include "town.h"
-#include "command.h"
+#include "command_func.h"
-#include "gfx.h"
 #include "industry.h"
 #include "station.h"
-#include "vehicle.h"
 #include "player.h"
 #include "news.h"
 #include "saveload.h"
-#include "economy.h"
 #include "gui.h"
 #include "unmovable_map.h"
 #include "water_map.h"
 #include "variables.h"
 #include "bridge.h"
 #include "bridge_map.h"
-#include "date.h"
 #include "table/town_land.h"
 #include "genworld.h"
 #include "newgrf.h"
 #include "newgrf_callbacks.h"
 #include "newgrf_house.h"
 #include "newgrf_townname.h"
 #include "misc/autoptr.hpp"
 #include "autoslope.h"
 #include "waypoint.h"
 #include "transparency.h"
+#include "tunnelbridge_map.h"
+#include "strings_func.h"
+#include "window_func.h"
+#include "string_func.h"
 /* Initialize the town-pool */
 DEFINE_OLD_POOL_GENERIC(Town, Town)
 Town::Town(TileIndex tile)
 	UpdateViewportSignPos(&t->sign, pt.x, pt.y - 24,
 		_patches.population_in_label ? STR_TOWN_LABEL_POP : STR_TOWN_LABEL);
 	MarkTownSignDirty(t);
 }
+/** Update the virtual coords needed to draw the town sign for all towns. */
+void UpdateAllTownVirtCoords()
+{
+	Town *t;
+	FOR_ALL_TOWNS(t) {
+		UpdateTownVirtCoord(t);
+	}
+}
 /**
 * Change the towns population
 * @param t Town which polulation has changed
 * @param mod polulation change (can be positive or negative)
 */
 	/* 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);
 	r = Random();
 }
 static CommandCost ClearTile_Town(TileIndex tile, byte flags)
 {
 	int rating;
-	CommandCost cost;
+	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;
 			SetDParam(0, t->index);
 			return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);
 		}
 	}
+	ChangeTownRating(t, -rating, RATING_HOUSE_MINIMUM);
 	if (flags & DC_EXEC) {
-		ChangeTownRating(t, -rating, RATING_HOUSE_MINIMUM);
 		ClearTownHouse(t, tile);
 	}
 	return cost;
 }
 		/* If the tile is not a slope in the right direction, then
 		 * maybe terraform some. */
 		desired_slope = (dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? SLOPE_NW : SLOPE_NE;
 		if (desired_slope != cur_slope && ComplementSlope(desired_slope) != cur_slope) {
-			if (CHANCE16(1, 8)) {
+			if (Chance16(1, 8)) {
 				CommandCost res = CMD_ERROR;
-				if (!_generating_world && CHANCE16(1, 10)) {
+				if (!_generating_world && Chance16(1, 10)) {
 					/* Note: Do not replace " ^ 0xF" with ComplementSlope(). The slope might be steep. */
-					res = DoCommand(tile, CHANCE16(1, 16) ? cur_slope : cur_slope ^ 0xF, 0,
+					res = DoCommand(tile, Chance16(1, 16) ? cur_slope : cur_slope ^ 0xF, 0,
 							DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
 				}
-				if (CmdFailed(res) && CHANCE16(1, 3)) {
+				if (CmdFailed(res) && Chance16(1, 3)) {
 					/* We can consider building on the slope, though. */
 					goto no_slope;
 				}
 			}
 			return false;
 			case TL_ORIGINAL:
 				if (!IsRoadAllowedHere(tile, target_dir)) return;
 				DiagDirection source_dir = ReverseDiagDir(target_dir);
-				if (CHANCE16(1, 4)) {
+				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)) {
 	} else {
 		bool allow_house = false; // Value which decides if we want to construct a house
 		/* Reached a tunnel/bridge? Then continue at the other side of it. */
 		if (IsTileType(tile, MP_TUNNELBRIDGE)) {
-			if (IsTunnel(tile) && GetTunnelTransportType(tile) == TRANSPORT_ROAD) {
+			if (GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD) {
-				*tile_ptr = GetOtherTunnelEnd(tile);
+				*tile_ptr = GetOtherTunnelBridgeEnd(tile);
-			} else if (IsBridge(tile) && GetBridgeTransportType(tile) == TRANSPORT_ROAD) {
-				*tile_ptr = GetOtherBridgeEnd(tile);
 			}
 			return;
 		}
 		/* Possibly extend the road in a direction.
 			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(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(house_tile, MP_HOUSE)) {
 				/* Level the land if possible */
-				if (CHANCE16(1, 6)) LevelTownLand(house_tile);
+				if (Chance16(1, 6)) LevelTownLand(house_tile);
 				/* And build a house.
 				 * Set result to -1 if we managed to build it. */
 				if (BuildTownHouse(t1, house_tile)) {
 					_grow_town_result = GROWTH_SUCCEED;
 	/* Only in the scenario editor */
 	if (_game_mode != GM_EDITOR) return CMD_ERROR;
 	if (p2 > TSM_CITY) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_OTHER);
 	/* Check if too close to the edge of map */
 	if (DistanceFromEdge(tile) < 12)
 		return_cmd_error(STR_0237_TOO_CLOSE_TO_EDGE_OF_MAP);
 	/* Can only build on clear flat areas, possibly with trees. */
 		if (_generating_world) {
 			uint32 r = Random();
 			construction_stage = TOWN_HOUSE_COMPLETED;
-			if (CHANCE16(1, 7)) construction_stage = GB(r, 0, 2);
+			if (Chance16(1, 7)) construction_stage = GB(r, 0, 2);
 			if (construction_stage == TOWN_HOUSE_COMPLETED) {
 				ChangePopulation(t, hs->population);
 			} else {
 				construction_counter = GB(r, 2, 2);
 			}
 		}
-		MakeTownHouse(tile, t->index, construction_counter, construction_stage, house, VehicleRandomBits());
+		MakeTownHouse(tile, t->index, construction_counter, construction_stage, house, Random());
 	}
 }
 static bool BuildTownHouse(Town *t, TileIndex tile)
 {
 * @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)
 {
-	CommandCost cost;
 	Town *t;
 	if (!IsValidTownID(p1) || p2 > lengthof(_town_action_proc)) return CMD_ERROR;
 	t = GetTown(p1);
 	if (!HasBit(GetMaskOfTownActions(NULL, _current_player, t), p2)) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_OTHER);
+	CommandCost cost(EXPENSES_OTHER, (_price.build_industry >> 8) * _town_action_costs[p2]);
-	cost.AddCost((_price.build_industry >> 8) * _town_action_costs[p2]);
 	if (flags & DC_EXEC) {
 		_town_action_proc[p2](t);
 		InvalidateWindow(WC_TOWN_AUTHORITY, p1);
 	}
 	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)];
-		if (n == 0 && !CHANCE16(1, 12)) return;
+		if (n == 0 && !Chance16(1, 12)) return;
 	}
 	if (_opt.landscape == LT_ARCTIC) {
 		if (TilePixelHeight(t->xy) >= GetSnowLine() && t->act_food == 0 && t->population > 90)
 			return;
 	} else {
 		return CalcClosestTownFromTile(tile, threshold);
 	}
 }
+static bool _town_rating_test = false;
+void SetTownRatingTestMode(bool mode)
+{
+	static int ref_count = 0;
+	if (mode) {
+		if (ref_count == 0) {
+			Town *t;
+			FOR_ALL_TOWNS(t) t->test_rating = t->ratings[_current_player];
+		}
+		ref_count++;
+	} else {
+		assert(ref_count > 0);
+		ref_count--;
+	}
+	_town_rating_test = !(ref_count == 0);
+}
 void ChangeTownRating(Town *t, int add, int max)
 {
 	int rating;
 		return;
 	}
 	SetBit(t->have_ratings, _current_player);
-	rating = t->ratings[_current_player];
+	rating = _town_rating_test ? t->test_rating : t->ratings[_current_player];
 	if (add < 0) {
 		if (rating > max) {
 			rating += add;
 			if (rating < max) rating = max;
 		if (rating < max) {
 			rating += add;
 			if (rating > max) rating = max;
 		}
 	}
-	t->ratings[_current_player] = rating;
+	if (_town_rating_test) {
+		t->test_rating = rating;
+	} else {
+		t->ratings[_current_player] = rating;
+	}
 }
 /* penalty for removing town-owned stuff */
 static const int _default_rating_settings [3][3] = {
 	/* ROAD_REMOVE, TUNNELBRIDGE_REMOVE, INDUSTRY_REMOVE */
 	 * 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];
-	if (t->ratings[_current_player] < 16 + modemod && !(flags & DC_NO_TOWN_RATING)) {
+	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;
 	}
 		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;
+			(GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) return CommandCost(EXPENSES_CONSTRUCTION, _price.terraform);
 	}
 	return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 }
 void AfterLoadTown()
 {
 	Town *t;
 	FOR_ALL_TOWNS(t) {
 		UpdateTownRadius(t);
-		UpdateTownVirtCoord(t);
 	}
 	_town_sort_dirty = true;
 }
 extern const ChunkHandler _town_chunk_handlers[] = {

branch	noai
changeset 9723	eee46cb39750
parent 9722	ebf0ece7d8f6
child 9724	b39bc69bb2f2