src/town.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file town.h Base of the town class. */
   9
  10 #ifndef TOWN_H
  11 #define TOWN_H
  12
  13 #include "viewport_type.h"
  14 #include "timer/timer_game_tick.h"
  15 #include "town_map.h"
  16 #include "subsidy_type.h"
  17 #include "newgrf_storage.h"
  18 #include "cargotype.h"
  19
  20 template <typename T>
  21 struct BuildingCounts {
  22         T id_count[NUM_HOUSES];
  23         T class_count[HOUSE_CLASS_MAX];
  24 };
  25
  26 static const uint CUSTOM_TOWN_NUMBER_DIFFICULTY  = 4; ///< value for custom town number in difficulty settings
  27 static const uint CUSTOM_TOWN_MAX_NUMBER = 5000;  ///< this is the maximum number of towns a user can specify in customisation
  28
  29 static const TownID INVALID_TOWN = 0xFFFF;
  30
  31 static const uint TOWN_GROWTH_WINTER = 0xFFFFFFFE; ///< The town only needs this cargo in the winter (any amount)
  32 static const uint TOWN_GROWTH_DESERT = 0xFFFFFFFF; ///< The town needs the cargo for growth when on desert (any amount)
  33 static const uint16_t TOWN_GROWTH_RATE_NONE = 0xFFFF; ///< Special value for Town::growth_rate to disable town growth.
  34 static const uint16_t MAX_TOWN_GROWTH_TICKS = 930; ///< Max amount of original town ticks that still fit into uint16_t, about equal to UINT16_MAX / TOWN_GROWTH_TICKS but slightly less to simplify calculations
  35
  36 typedef Pool<Town, TownID, 64, 64000> TownPool;
  37 extern TownPool _town_pool;
  38
  39 /** Data structure with cached data of towns. */
  40 struct TownCache {
  41         uint32_t num_houses;                        ///< Amount of houses
  42         uint32_t population;                        ///< Current population of people
  43         TrackedViewportSign sign;                 ///< Location of name sign, UpdateVirtCoord updates this
  44         PartOfSubsidy part_of_subsidy;            ///< Is this town a source/destination of a subsidy?
  45         uint32_t squared_town_zone_radius[HZB_END]; ///< UpdateTownRadius updates this given the house count
  46         BuildingCounts<uint16_t> building_counts;   ///< The number of each type of building in the town
  47 };
  48
  49 /** Town data structure. */
  50 struct Town : TownPool::PoolItem<&_town_pool> {
  51         TileIndex xy;                  ///< town center tile
  52
  53         TownCache cache; ///< Container for all cacheable data.
  54
  55         /* Town name */
  56         uint32_t townnamegrfid;
  57         uint16_t townnametype;
  58         uint32_t townnameparts;
  59         std::string name;                ///< Custom town name. If empty, the town was not renamed and uses the generated name.
  60         mutable std::string cached_name; ///< NOSAVE: Cache of the resolved name of the town, if not using a custom town name
  61
  62         byte flags;                    ///< See #TownFlags.
  63
  64         uint16_t noise_reached;          ///< level of noise that all the airports are generating
  65
  66         CompanyMask statues;           ///< which companies have a statue?
  67
  68         /* Company ratings. */
  69         CompanyMask have_ratings;      ///< which companies have a rating
  70         uint8_t unwanted[MAX_COMPANIES]; ///< how many months companies aren't wanted by towns (bribe)
  71         CompanyID exclusivity;         ///< which company has exclusivity
  72         uint8_t exclusive_counter;       ///< months till the exclusivity expires
  73         int16_t ratings[MAX_COMPANIES];  ///< ratings of each company for this town
  74
  75         TransportedCargoStat<uint32_t> supplied[NUM_CARGO]; ///< Cargo statistics about supplied cargo.
  76         TransportedCargoStat<uint16_t> received[NUM_TAE]; ///< Cargo statistics about received cargotypes.
  77         uint32_t goal[NUM_TAE]; ///< Amount of cargo required for the town to grow.
  78
  79         std::string text; ///< General text with additional information.
  80
  81         inline byte GetPercentTransported(CargoID cid) const
  82         {
  83                 if (!IsValidCargoID(cid)) return 0;
  84                 return this->supplied[cid].old_act * 256 / (this->supplied[cid].old_max + 1);
  85         }
  86
  87         StationList stations_near;       ///< NOSAVE: List of nearby stations.
  88
  89         uint16_t time_until_rebuild;       ///< time until we rebuild a house
  90
  91         uint16_t grow_counter;             ///< counter to count when to grow, value is smaller than or equal to growth_rate
  92         uint16_t growth_rate;              ///< town growth rate
  93
  94         byte fund_buildings_months;      ///< fund buildings program in action?
  95         byte road_build_months;          ///< fund road reconstruction in action?
  96
  97         bool larger_town;                ///< if this is a larger town and should grow more quickly
  98         TownLayout layout;               ///< town specific road layout
  99
 100         bool show_zone;                  ///< NOSAVE: mark town to show the local authority zone in the viewports
 101
 102         std::list<PersistentStorage *> psa_list;
 103
 104         /**
 105          * Creates a new town.
 106          * @param tile center tile of the town
 107          */
 108         Town(TileIndex tile = INVALID_TILE) : xy(tile) { }
 109
 110         /** Destroy the town. */
 111         ~Town();
 112
 113         void InitializeLayout(TownLayout layout);
 114
 115         /**
 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.
 120          */
 121         inline uint16_t MaxTownNoise() const
 122         {
 123                 if (this->cache.population == 0) return 0; // no population? no noise
 124
 125                 /* 3 is added (the noise of the lowest airport), so the  user can at least build a small airfield. */
 126                 return ClampTo<uint16_t>((this->cache.population / _settings_game.economy.town_noise_population[_settings_game.difficulty.town_council_tolerance]) + 3);
 127         }
 128
 129         void UpdateVirtCoord();
 130
 131         inline const std::string &GetCachedName() const
 132         {
 133                 if (!this->name.empty()) return this->name;
 134                 if (this->cached_name.empty()) this->FillCachedName();
 135                 return this->cached_name;
 136         }
 137
 138         static inline Town *GetByTile(TileIndex tile)
 139         {
 140                 return Town::Get(GetTownIndex(tile));
 141         }
 142
 143         static Town *GetRandom();
 144         static void PostDestructor(size_t index);
 145
 146 private:
 147         void FillCachedName() const;
 148 };
 149
 150 uint32_t GetWorldPopulation();
 151
 152 void UpdateAllTownVirtCoords();
 153 void ClearAllTownCachedNames();
 154 void ShowTownViewWindow(TownID town);
 155 void ExpandTown(Town *t);
 156
 157 void RebuildTownKdtree();
 158
 159 /** Settings for town council attitudes. */
 160 enum TownCouncilAttitudes {
 161         TOWN_COUNCIL_LENIENT    = 0,
 162         TOWN_COUNCIL_TOLERANT   = 1,
 163         TOWN_COUNCIL_HOSTILE    = 2,
 164         TOWN_COUNCIL_PERMISSIVE = 3,
 165 };
 166
 167 /**
 168  * Action types that a company must ask permission for to a town authority.
 169  * @see CheckforTownRating
 170  */
 171 enum TownRatingCheckType {
 172         ROAD_REMOVE         = 0,      ///< Removal of a road owned by the town.
 173         TUNNELBRIDGE_REMOVE = 1,      ///< Removal of a tunnel or bridge owned by the towb.
 174         TOWN_RATING_CHECK_TYPE_COUNT, ///< Number of town checking action types.
 175 };
 176
 177 /** Special values for town list window for the data parameter of #InvalidateWindowData. */
 178 enum TownDirectoryInvalidateWindowData {
 179         TDIWD_FORCE_REBUILD,
 180         TDIWD_POPULATION_CHANGE,
 181         TDIWD_FORCE_RESORT,
 182 };
 183
 184 /**
 185  * This enum is used in conjunction with town->flags.
 186  * IT simply states what bit is used for.
 187  * It is pretty unrealistic (IMHO) to only have one church/stadium
 188  * per town, NO MATTER the population of it.
 189  * And there are 5 more bits available on flags...
 190  */
 191 enum TownFlags {
 192         TOWN_IS_GROWING     = 0,   ///< Conditions for town growth are met. Grow according to Town::growth_rate.
 193         TOWN_HAS_CHURCH     = 1,   ///< There can be only one church by town.
 194         TOWN_HAS_STADIUM    = 2,   ///< There can be only one stadium by town.
 195         TOWN_CUSTOM_GROWTH  = 3,   ///< Growth rate is controlled by GS.
 196 };
 197
 198 CommandCost CheckforTownRating(DoCommandFlag flags, Town *t, TownRatingCheckType type);
 199
 200
 201 TileIndexDiff GetHouseNorthPart(HouseID &house);
 202
 203 Town *CalcClosestTownFromTile(TileIndex tile, uint threshold = UINT_MAX);
 204
 205 void ResetHouses();
 206
 207 /** Town actions of a company. */
 208 enum TownActions {
 209         TACT_NONE             = 0x00, ///< Empty action set.
 210
 211         TACT_ADVERTISE_SMALL  = 0x01, ///< Small advertising campaign.
 212         TACT_ADVERTISE_MEDIUM = 0x02, ///< Medium advertising campaign.
 213         TACT_ADVERTISE_LARGE  = 0x04, ///< Large advertising campaign.
 214         TACT_ROAD_REBUILD     = 0x08, ///< Rebuild the roads.
 215         TACT_BUILD_STATUE     = 0x10, ///< Build a statue.
 216         TACT_FUND_BUILDINGS   = 0x20, ///< Fund new buildings.
 217         TACT_BUY_RIGHTS       = 0x40, ///< Buy exclusive transport rights.
 218         TACT_BRIBE            = 0x80, ///< Try to bribe the council.
 219
 220         TACT_COUNT            = 8,    ///< Number of available town actions.
 221
 222         TACT_ADVERTISE        = TACT_ADVERTISE_SMALL | TACT_ADVERTISE_MEDIUM | TACT_ADVERTISE_LARGE, ///< All possible advertising actions.
 223         TACT_CONSTRUCTION     = TACT_ROAD_REBUILD | TACT_BUILD_STATUE | TACT_FUND_BUILDINGS,         ///< All possible construction actions.
 224         TACT_FUNDS            = TACT_BUY_RIGHTS | TACT_BRIBE,                                        ///< All possible funding actions.
 225         TACT_ALL              = TACT_ADVERTISE | TACT_CONSTRUCTION | TACT_FUNDS,                     ///< All possible actions.
 226 };
 227 DECLARE_ENUM_AS_BIT_SET(TownActions)
 228
 229 void ClearTownHouse(Town *t, TileIndex tile);
 230 void UpdateTownMaxPass(Town *t);
 231 void UpdateTownRadius(Town *t);
 232 CommandCost CheckIfAuthorityAllowsNewStation(TileIndex tile, DoCommandFlag flags);
 233 Town *ClosestTownFromTile(TileIndex tile, uint threshold);
 234 void ChangeTownRating(Town *t, int add, int max, DoCommandFlag flags);
 235 HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile);
 236 void SetTownRatingTestMode(bool mode);
 237 TownActions GetMaskOfTownActions(CompanyID cid, const Town *t);
 238 bool GenerateTowns(TownLayout layout);
 239 const CargoSpec *FindFirstCargoWithTownAcceptanceEffect(TownAcceptanceEffect effect);
 240
 241 extern const byte _town_action_costs[TACT_COUNT];
 242
 243 /**
 244  * Set the default name for a depot/waypoint
 245  * @tparam T The type/class to make a default name for
 246  * @param obj The object/instance we want to find the name for
 247  */
 248 template <class T>
 249 void MakeDefaultName(T *obj)
 250 {
 251         /* We only want to set names if it hasn't been set before, or when we're calling from afterload. */
 252         assert(obj->name.empty() || obj->town_cn == UINT16_MAX);
 253
 254         obj->town = ClosestTownFromTile(obj->xy, UINT_MAX);
 255
 256         /* Find first unused number belonging to this town. This can never fail,
 257          * as long as there can be at most 65535 waypoints/depots in total.
 258          *
 259          * This does 'n * m' search, but with 32bit 'used' bitmap, it needs at
 260          * most 'n * (1 + ceil(m / 32))' steps (n - number of waypoints in pool,
 261          * m - number of waypoints near this town).
 262          * Usually, it needs only 'n' steps.
 263          *
 264          * If it wasn't using 'used' and 'idx', it would just search for increasing 'next',
 265          * but this way it is faster */
 266
 267         uint32_t used = 0; // bitmap of used waypoint numbers, sliding window with 'next' as base
 268         uint32_t next = 0; // first number in the bitmap
 269         uint32_t idx  = 0; // index where we will stop
 270         uint32_t cid  = 0; // current index, goes to T::GetPoolSize()-1, then wraps to 0
 271
 272         do {
 273                 T *lobj = T::GetIfValid(cid);
 274
 275                 /* check only valid waypoints... */
 276                 if (lobj != nullptr && obj != lobj) {
 277                         /* only objects within the same city and with the same type */
 278                         if (lobj->town == obj->town && lobj->IsOfType(obj)) {
 279                                 /* if lobj->town_cn < next, uint will overflow to '+inf' */
 280                                 uint i = (uint)lobj->town_cn - next;
 281
 282                                 if (i < 32) {
 283                                         SetBit(used, i); // update bitmap
 284                                         if (i == 0) {
 285                                                 /* shift bitmap while the lowest bit is '1';
 286                                                  * increase the base of the bitmap too */
 287                                                 do {
 288                                                         used >>= 1;
 289                                                         next++;
 290                                                 } while (HasBit(used, 0));
 291                                                 /* when we are at 'idx' again at end of the loop and
 292                                                  * 'next' hasn't changed, then no object had town_cn == next,
 293                                                  * so we can safely use it */
 294                                                 idx = cid;
 295                                         }
 296                                 }
 297                         }
 298                 }
 299
 300                 cid++;
 301                 if (cid == T::GetPoolSize()) cid = 0; // wrap to zero...
 302         } while (cid != idx);
 303
 304         obj->town_cn = (uint16_t)next; // set index...
 305 }
 306
 307 /*
 308  * Converts original town ticks counters to plain game ticks. Note that
 309  * tick 0 is a valid tick so actual amount is one more than the counter value.
 310  */
 311 inline uint16_t TownTicksToGameTicks(uint16_t ticks)
 312 {
 313         return (std::min(ticks, MAX_TOWN_GROWTH_TICKS) + 1) * Ticks::TOWN_GROWTH_TICKS - 1;
 314 }
 315
 316
 317 RoadType GetTownRoadType();
 318
 319 #endif /* TOWN_H */