4 * This file is part of OpenTTD.
5 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
10 /** @file town.h Base of the town class. */
15 #include "viewport_type.h"
17 #include "subsidy_type.h"
18 #include "newgrf_storage.h"
19 #include "cargotype.h"
20 #include "tilematrix_type.hpp"
24 struct BuildingCounts
{
25 T id_count
[NUM_HOUSES
];
26 T class_count
[HOUSE_CLASS_MAX
];
29 typedef TileMatrix
<uint32
, 4> AcceptanceMatrix
;
31 static const uint CUSTOM_TOWN_NUMBER_DIFFICULTY
= 4; ///< value for custom town number in difficulty settings
32 static const uint CUSTOM_TOWN_MAX_NUMBER
= 5000; ///< this is the maximum number of towns a user can specify in customisation
34 static const uint INVALID_TOWN
= 0xFFFF;
36 static const uint TOWN_GROWTH_WINTER
= 0xFFFFFFFE; ///< The town only needs this cargo in the winter (any amount)
37 static const uint TOWN_GROWTH_DESERT
= 0xFFFFFFFF; ///< The town needs the cargo for growth when on desert (any amount)
38 static const uint16 TOWN_GROW_RATE_CUSTOM
= 0x8000; ///< If this mask is applied to Town::grow_counter, the grow_counter will not be calculated by the system (but assumed to be set by scripts)
40 typedef Pool
<Town
, TownID
, 64, 64000> TownPool
;
41 extern TownPool _town_pool
;
43 /** Data structure with cached data of towns. */
45 uint32 num_houses
; ///< Amount of houses
46 uint32 population
; ///< Current population of people
47 ViewportSign sign
; ///< Location of name sign, UpdateVirtCoord updates this
48 PartOfSubsidyByte part_of_subsidy
; ///< Is this town a source/destination of a subsidy?
49 uint32 squared_town_zone_radius
[HZB_END
]; ///< UpdateTownRadius updates this given the house count
50 BuildingCounts
<uint16
> building_counts
; ///< The number of each type of building in the town
53 /** Town data structure. */
54 struct Town
: TownPool::PoolItem
<&_town_pool
> {
55 TileIndex xy
; ///< town center tile
57 TownCache cache
; ///< Container for all cacheable data.
63 char *name
; ///< Custom town name. If NULL, the town was not renamed and uses the generated name.
65 byte flags
; ///< See #TownFlags.
67 uint16 noise_reached
; ///< level of noise that all the airports are generating
69 CompanyMask statues
; ///< which companies have a statue?
71 /* Company ratings. */
72 CompanyMask have_ratings
; ///< which companies have a rating
73 uint8 unwanted
[MAX_COMPANIES
]; ///< how many months companies aren't wanted by towns (bribe)
74 CompanyByte exclusivity
; ///< which company has exclusivity
75 uint8 exclusive_counter
; ///< months till the exclusivity expires
76 int16 ratings
[MAX_COMPANIES
]; ///< ratings of each company for this town
78 TransportedCargoStat
<uint32
> supplied
[NUM_CARGO
]; ///< Cargo statistics about supplied cargo.
79 TransportedCargoStat
<uint16
> received
[NUM_TE
]; ///< Cargo statistics about received cargotypes.
80 uint32 goal
[NUM_TE
]; ///< Amount of cargo required for the town to grow.
82 char *text
; ///< General text with additional information.
84 inline byte
GetPercentTransported(CargoID cid
) const { return this->supplied
[cid
].old_act
* 256 / (this->supplied
[cid
].old_max
+ 1); }
86 /* Cargo production and acceptance stats. */
87 uint32 cargo_produced
; ///< Bitmap of all cargoes produced by houses in this town.
88 AcceptanceMatrix cargo_accepted
; ///< Bitmap of cargoes accepted by houses for each 4*4 map square of the town.
89 uint32 cargo_accepted_total
; ///< NOSAVE: Bitmap of all cargoes accepted by houses in this town.
91 uint16 time_until_rebuild
; ///< time until we rebuild a house
93 uint16 grow_counter
; ///< counter to count when to grow
94 uint16 growth_rate
; ///< town growth rate
96 byte fund_buildings_months
; ///< fund buildings program in action?
97 byte road_build_months
; ///< fund road reconstruction in action?
99 bool larger_town
; ///< if this is a larger town and should grow more quickly
100 TownLayoutByte layout
; ///< town specific road layout
102 std::list
<PersistentStorage
*> psa_list
;
105 * Creates a new town.
106 * @param tile center tile of the town
108 Town(TileIndex tile
= INVALID_TILE
) : xy(tile
) { }
110 /** Destroy the town. */
113 void InitializeLayout(TownLayout layout
);
116 * Calculate the max town noise.
117 * The value is counted using the population divided by the content of the
118 * entry in town_noise_population corresponding to the town's tolerance.
119 * @return the maximum noise level the town will tolerate.
121 inline uint16
MaxTownNoise() const
123 if (this->cache
.population
== 0) return 0; // no population? no noise
125 /* 3 is added (the noise of the lowest airport), so the user can at least build a small airfield. */
126 return (this->cache
.population
/ _settings_game
.economy
.town_noise_population
[_settings_game
.difficulty
.town_council_tolerance
]) + 3;
129 void UpdateVirtCoord();
131 static inline Town
*GetByTile(TileIndex tile
)
133 return Town::Get(GetTownIndex(tile
));
136 static Town
*GetRandom();
137 static void PostDestructor(size_t index
);
140 uint32
GetWorldPopulation();
142 void UpdateAllTownVirtCoords();
143 void ShowTownViewWindow(TownID town
);
144 void ExpandTown(Town
*t
);
147 * Action types that a company must ask permission for to a town authority.
148 * @see CheckforTownRating
150 enum TownRatingCheckType
{
151 ROAD_REMOVE
= 0, ///< Removal of a road owned by the town.
152 TUNNELBRIDGE_REMOVE
= 1, ///< Removal of a tunnel or bridge owned by the towb.
153 TOWN_RATING_CHECK_TYPE_COUNT
, ///< Number of town checking action types.
157 * This enum is used in conjunction with town->flags.
158 * IT simply states what bit is used for.
159 * It is pretty unrealistic (IMHO) to only have one church/stadium
160 * per town, NO MATTER the population of it.
161 * And there are 5 more bits available on flags...
164 TOWN_IS_GROWING
= 0, ///< Conditions for town growth are met. Grow according to Town::growth_rate.
165 TOWN_HAS_CHURCH
= 1, ///< There can be only one church by town.
166 TOWN_HAS_STADIUM
= 2, ///< There can be only one stadium by town.
169 CommandCost
CheckforTownRating(DoCommandFlag flags
, Town
*t
, TownRatingCheckType type
);
172 TileIndexDiff
GetHouseNorthPart(HouseID
&house
);
174 Town
*CalcClosestTownFromTile(TileIndex tile
, uint threshold
= UINT_MAX
);
176 static inline TownID
CalcClosestTownIDFromTile(TileIndex tile
)
178 const Town
*town
= CalcClosestTownFromTile(tile
);
179 return (town
!= NULL
) ? town
->index
: (TownID
)INVALID_TOWN
;
182 #define FOR_ALL_TOWNS_FROM(var, start) FOR_ALL_ITEMS_FROM(Town, town_index, var, start)
183 #define FOR_ALL_TOWNS(var) FOR_ALL_TOWNS_FROM(var, 0)
187 void ClearTownHouse(Town
*t
, TileIndex tile
);
188 void UpdateTownMaxPass(Town
*t
);
189 void UpdateTownRadius(Town
*t
);
190 void UpdateTownCargoes(Town
*t
);
191 void UpdateTownCargoTotal(Town
*t
);
192 void UpdateTownCargoBitmap();
193 CommandCost
CheckIfAuthorityAllowsNewStation(TileIndex tile
, DoCommandFlag flags
);
194 Town
*ClosestTownFromTile(TileIndex tile
, uint threshold
);
195 void ChangeTownRating(Town
*t
, int add
, int max
, DoCommandFlag flags
);
196 HouseZonesBits
GetTownRadiusGroup(const Town
*t
, TileIndex tile
);
197 void SetTownRatingTestMode(bool mode
);
198 uint
GetMaskOfTownActions(int *nump
, CompanyID cid
, const Town
*t
);
199 bool GenerateTowns(TownLayout layout
);
200 const CargoSpec
*FindFirstCargoWithTownEffect(TownEffect effect
);
203 /** Town actions of a company. */
205 TACT_NONE
= 0x00, ///< Empty action set.
207 TACT_ADVERTISE_SMALL
= 0x01, ///< Small advertising campaign.
208 TACT_ADVERTISE_MEDIUM
= 0x02, ///< Medium advertising campaign.
209 TACT_ADVERTISE_LARGE
= 0x04, ///< Large advertising campaign.
210 TACT_ROAD_REBUILD
= 0x08, ///< Rebuild the roads.
211 TACT_BUILD_STATUE
= 0x10, ///< Build a statue.
212 TACT_FUND_BUILDINGS
= 0x20, ///< Fund new buildings.
213 TACT_BUY_RIGHTS
= 0x40, ///< Buy exclusive transport rights.
214 TACT_BRIBE
= 0x80, ///< Try to bribe the council.
216 TACT_COUNT
= 8, ///< Number of available town actions.
218 TACT_ADVERTISE
= TACT_ADVERTISE_SMALL
| TACT_ADVERTISE_MEDIUM
| TACT_ADVERTISE_LARGE
, ///< All possible advertising actions.
219 TACT_CONSTRUCTION
= TACT_ROAD_REBUILD
| TACT_BUILD_STATUE
| TACT_FUND_BUILDINGS
, ///< All possible construction actions.
220 TACT_FUNDS
= TACT_BUY_RIGHTS
| TACT_BRIBE
, ///< All possible funding actions.
221 TACT_ALL
= TACT_ADVERTISE
| TACT_CONSTRUCTION
| TACT_FUNDS
, ///< All possible actions.
223 DECLARE_ENUM_AS_BIT_SET(TownActions
)
225 extern const byte _town_action_costs
[TACT_COUNT
];
226 extern TownID _new_town_id
;
229 * Set the default name for a depot/waypoint
230 * @tparam T The type/class to make a default name for
231 * @param obj The object/instance we want to find the name for
234 void MakeDefaultName(T
*obj
)
236 /* We only want to set names if it hasn't been set before, or when we're calling from afterload. */
237 assert(obj
->name
== NULL
|| obj
->town_cn
== UINT16_MAX
);
239 obj
->town
= ClosestTownFromTile(obj
->xy
, UINT_MAX
);
241 /* Find first unused number belonging to this town. This can never fail,
242 * as long as there can be at most 65535 waypoints/depots in total.
244 * This does 'n * m' search, but with 32bit 'used' bitmap, it needs at
245 * most 'n * (1 + ceil(m / 32))' steps (n - number of waypoints in pool,
246 * m - number of waypoints near this town).
247 * Usually, it needs only 'n' steps.
249 * If it wasn't using 'used' and 'idx', it would just search for increasing 'next',
250 * but this way it is faster */
252 uint32 used
= 0; // bitmap of used waypoint numbers, sliding window with 'next' as base
253 uint32 next
= 0; // first number in the bitmap
254 uint32 idx
= 0; // index where we will stop
255 uint32 cid
= 0; // current index, goes to T::GetPoolSize()-1, then wraps to 0
258 T
*lobj
= T::GetIfValid(cid
);
260 /* check only valid waypoints... */
261 if (lobj
!= NULL
&& obj
!= lobj
) {
262 /* only objects within the same city and with the same type */
263 if (lobj
->town
== obj
->town
&& lobj
->IsOfType(obj
)) {
264 /* if lobj->town_cn < next, uint will overflow to '+inf' */
265 uint i
= (uint
)lobj
->town_cn
- next
;
268 SetBit(used
, i
); // update bitmap
270 /* shift bitmap while the lowest bit is '1';
271 * increase the base of the bitmap too */
275 } while (HasBit(used
, 0));
276 /* when we are at 'idx' again at end of the loop and
277 * 'next' hasn't changed, then no object had town_cn == next,
278 * so we can safely use it */
286 if (cid
== T::GetPoolSize()) cid
= 0; // wrap to zero...
287 } while (cid
!= idx
);
289 obj
->town_cn
= (uint16
)next
; // set index...
292 extern uint32 _town_cargoes_accepted
;