src/town.h

   1 /* $Id$ */
   2
   3 /*
   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/>.
   8  */
   9
  10 /** @file town.h Base of the town class. */
  11
  12 #ifndef TOWN_H
  13 #define TOWN_H
  14
  15 #include "viewport_type.h"
  16 #include "house.h"
  17 #include "subsidy_type.h"
  18 #include "newgrf_storage.h"
  19 #include "cargotype.h"
  20 #include "tilematrix_type.hpp"
  21 #include "map/tileset.h"
  22 #include "townname_type.h"
  23 #include <list>
  24
  25 template <typename T>
  26 struct BuildingCounts {
  27         T id_count[NUM_HOUSES];
  28         T class_count[HOUSE_CLASS_MAX];
  29 };
  30
  31 typedef TileMatrix<uint32, 4> AcceptanceMatrix;
  32
  33 static const uint CUSTOM_TOWN_NUMBER_DIFFICULTY  = 4; ///< value for custom town number in difficulty settings
  34 static const uint CUSTOM_TOWN_MAX_NUMBER = 5000;  ///< this is the maximum number of towns a user can specify in customisation
  35
  36 static const uint INVALID_TOWN = 0xFFFF;
  37
  38 static const uint TOWN_GROWTH_WINTER = 0xFFFFFFFE; ///< The town only needs this cargo in the winter (any amount)
  39 static const uint TOWN_GROWTH_DESERT = 0xFFFFFFFF; ///< The town needs the cargo for growth when on desert (any amount)
  40 static const uint16 TOWN_GROW_RATE_CUSTOM      = 0x8000; ///< If this mask is applied to Town::growth_rate, the grow_counter will not be calculated by the system (but assumed to be set by scripts)
  41 static const uint16 TOWN_GROW_RATE_CUSTOM_NONE = 0xFFFF; ///< Special value for Town::growth_rate to disable town growth.
  42
  43 /** Data structure with cached data of towns. */
  44 struct TownCache {
  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
  51 };
  52
  53 /* Forward declaration. */
  54 inline TileIndex get_town_tile (const Town*);
  55
  56 /** Town data structure. */
  57 struct Town : PooledItem <Town, TownID, 64, 64000>, TileSetObject <Town, get_town_tile> {
  58         TileIndex xy;                  ///< town center tile
  59
  60         TownCache cache; ///< Container for all cacheable data.
  61
  62         /* Town name */
  63         TownNameParams townnameparams;
  64         uint32 townnameparts;
  65         char *name;                    ///< Custom town name. If NULL, the town was not renamed and uses the generated name.
  66
  67         byte flags;                    ///< See #TownFlags.
  68
  69         uint16 noise_reached;          ///< level of noise that all the airports are generating
  70
  71         CompanyMask statues;           ///< which companies have a statue?
  72
  73         /* Company ratings. */
  74         CompanyMask have_ratings;      ///< which companies have a rating
  75         uint8 unwanted[MAX_COMPANIES]; ///< how many months companies aren't wanted by towns (bribe)
  76         CompanyByte exclusivity;       ///< which company has exclusivity
  77         uint8 exclusive_counter;       ///< months till the exclusivity expires
  78         int16 ratings[MAX_COMPANIES];  ///< ratings of each company for this town
  79
  80         TransportedCargoStat<uint32> supplied[NUM_CARGO]; ///< Cargo statistics about supplied cargo.
  81         TransportedCargoStat<uint16> received[NUM_TE];    ///< Cargo statistics about received cargotypes.
  82         uint32 goal[NUM_TE];                              ///< Amount of cargo required for the town to grow.
  83
  84         char *text; ///< General text with additional information.
  85
  86         inline byte GetPercentTransported(CargoID cid) const { return this->supplied[cid].old_act * 256 / (this->supplied[cid].old_max + 1); }
  87
  88         /* Cargo production and acceptance stats. */
  89         uint32 cargo_produced;           ///< Bitmap of all cargoes produced by houses in this town.
  90         AcceptanceMatrix cargo_accepted; ///< Bitmap of cargoes accepted by houses for each 4*4 map square of the town.
  91         uint32 cargo_accepted_total;     ///< NOSAVE: Bitmap of all cargoes accepted by houses in this town.
  92
  93         uint16 time_until_rebuild;     ///< time until we rebuild a house
  94
  95         uint16 grow_counter;           ///< counter to count when to grow, value is smaller than or equal to growth_rate
  96         uint16 growth_rate;            ///< town growth rate
  97
  98         byte fund_buildings_months;    ///< fund buildings program in action?
  99         byte road_build_months;        ///< fund road reconstruction in action?
 100
 101         bool larger_town;              ///< if this is a larger town and should grow more quickly
 102         TownLayoutByte layout;         ///< town specific road layout
 103
 104         std::list<PersistentStorage *> psa_list;
 105
 106         Town (TileIndex tile, uint32 townnameparts, bool city, TownLayout layout);
 107
 108         /**
 109          * Creates an unplaced town (during game loading)
 110          */
 111         Town() : xy(INVALID_TILE) { }
 112
 113         /** Destroy the town. */
 114         ~Town();
 115
 116         /**
 117          * Calculate the max town noise.
 118          * The value is counted using the population divided by the content of the
 119          * entry in town_noise_population corresponding to the town's tolerance.
 120          * @return the maximum noise level the town will tolerate.
 121          */
 122         inline uint16 MaxTownNoise() const
 123         {
 124                 if (this->cache.population == 0) return 0; // no population? no noise
 125
 126                 /* 3 is added (the noise of the lowest airport), so the  user can at least build a small airfield. */
 127                 return (this->cache.population / _settings_game.economy.town_noise_population[_settings_game.difficulty.town_council_tolerance]) + 3;
 128         }
 129
 130         void UpdateVirtCoord();
 131
 132         static inline Town *GetByTile(TileIndex tile)
 133         {
 134                 return Town::Get(GetTownIndex(tile));
 135         }
 136
 137         static Town *GetRandom();
 138         static void PostDestructor(size_t index);
 139 };
 140
 141 /** Get the tile where a town is located. */
 142 inline TileIndex get_town_tile (const Town *t)
 143 {
 144         return t->xy;
 145 }
 146
 147 uint32 GetWorldPopulation();
 148
 149 void UpdateAllTownVirtCoords();
 150 void ShowTownViewWindow(TownID town);
 151 void ExpandTown(Town *t);
 152
 153 /**
 154  * Action types that a company must ask permission for to a town authority.
 155  * @see CheckforTownRating
 156  */
 157 enum TownRatingCheckType {
 158         ROAD_REMOVE         = 0,      ///< Removal of a road owned by the town.
 159         TUNNELBRIDGE_REMOVE = 1,      ///< Removal of a tunnel or bridge owned by the towb.
 160         TOWN_RATING_CHECK_TYPE_COUNT, ///< Number of town checking action types.
 161 };
 162
 163 /**
 164  * This enum is used in conjunction with town->flags.
 165  * IT simply states what bit is used for.
 166  * It is pretty unrealistic (IMHO) to only have one church/stadium
 167  * per town, NO MATTER the population of it.
 168  * And there are 5 more bits available on flags...
 169  */
 170 enum TownFlags {
 171         TOWN_IS_GROWING     = 0,   ///< Conditions for town growth are met. Grow according to Town::growth_rate.
 172         TOWN_HAS_CHURCH     = 1,   ///< There can be only one church by town.
 173         TOWN_HAS_STADIUM    = 2,   ///< There can be only one stadium by town.
 174 };
 175
 176 CommandCost CheckforTownRating(DoCommandFlag flags, Town *t, TownRatingCheckType type);
 177
 178
 179 TileIndexDiff GetHouseNorthPart(HouseID &house);
 180
 181 Town *CalcClosestTownFromTile(TileIndex tile);
 182
 183 static inline TownID CalcClosestTownIDFromTile(TileIndex tile)
 184 {
 185         const Town *town = CalcClosestTownFromTile(tile);
 186         return (town != NULL) ? town->index : (TownID)INVALID_TOWN;
 187 }
 188
 189 #define FOR_ALL_TOWNS_FROM(var, start) FOR_ALL_ITEMS_FROM(Town, town_index, var, start)
 190 #define FOR_ALL_TOWNS(var) FOR_ALL_TOWNS_FROM(var, 0)
 191
 192 void ResetHouses();
 193
 194 void ClearTownHouse(Town *t, TileIndex tile);
 195 void UpdateTownMaxPass(Town *t);
 196 void UpdateTownRadius(Town *t);
 197 void UpdateTownCargoes(Town *t);
 198 void UpdateTownCargoTotal(Town *t);
 199 void UpdateTownCargoBitmap();
 200 CommandCost CheckIfAuthorityAllowsNewStation(TileIndex tile, DoCommandFlag flags);
 201 Town *ClosestTownFromTile(TileIndex tile, uint threshold = UINT_MAX);
 202
 203 static inline Town *LocalAuthorityTownFromTile (TileIndex tile)
 204 {
 205         return ClosestTownFromTile (tile, _settings_game.economy.dist_local_authority);
 206 }
 207
 208 void ChangeTownRating(Town *t, int add, int max, DoCommandFlag flags);
 209 HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile);
 210 void SetTownRatingTestMode(bool mode);
 211 uint GetMaskOfTownActions(int *nump, CompanyID cid, const Town *t);
 212 bool GenerateTowns(TownLayout layout);
 213 const CargoSpec *FindFirstCargoWithTownEffect(TownEffect effect);
 214
 215 StringID IsNewTownHouseAllowed (const Town *t, HouseID house);
 216 void DoBuildHouse (Town *t, TileIndex tile, HouseID house, byte random_bits);
 217 void ShowBuildHousePicker (void);
 218
 219
 220 /** Town actions of a company. */
 221 enum TownActions {
 222         TACT_NONE             = 0x00, ///< Empty action set.
 223
 224         TACT_ADVERTISE_SMALL  = 0x01, ///< Small advertising campaign.
 225         TACT_ADVERTISE_MEDIUM = 0x02, ///< Medium advertising campaign.
 226         TACT_ADVERTISE_LARGE  = 0x04, ///< Large advertising campaign.
 227         TACT_ROAD_REBUILD     = 0x08, ///< Rebuild the roads.
 228         TACT_BUILD_STATUE     = 0x10, ///< Build a statue.
 229         TACT_FUND_BUILDINGS   = 0x20, ///< Fund new buildings.
 230         TACT_BUY_RIGHTS       = 0x40, ///< Buy exclusive transport rights.
 231         TACT_BRIBE            = 0x80, ///< Try to bribe the council.
 232
 233         TACT_COUNT            = 8,    ///< Number of available town actions.
 234
 235         TACT_ADVERTISE        = TACT_ADVERTISE_SMALL | TACT_ADVERTISE_MEDIUM | TACT_ADVERTISE_LARGE, ///< All possible advertising actions.
 236         TACT_CONSTRUCTION     = TACT_ROAD_REBUILD | TACT_BUILD_STATUE | TACT_FUND_BUILDINGS,         ///< All possible construction actions.
 237         TACT_FUNDS            = TACT_BUY_RIGHTS | TACT_BRIBE,                                        ///< All possible funding actions.
 238         TACT_ALL              = TACT_ADVERTISE | TACT_CONSTRUCTION | TACT_FUNDS,                     ///< All possible actions.
 239 };
 240 DECLARE_ENUM_AS_BIT_SET(TownActions)
 241
 242 extern const byte _town_action_costs[TACT_COUNT];
 243 extern TownID _new_town_id;
 244
 245 /**
 246  * Set the default name for a depot/waypoint
 247  * @tparam T The type/class to make a default name for
 248  * @param obj The object/instance we want to find the name for
 249  */
 250 template <class T>
 251 void MakeDefaultName(T *obj)
 252 {
 253         /* We only want to set names if it hasn't been set before, or when we're calling from afterload. */
 254         assert(obj->name == NULL || obj->town_cn == UINT16_MAX);
 255
 256         obj->town = ClosestTownFromTile(obj->xy);
 257
 258         /* Find first unused number belonging to this town. This can never fail,
 259          * as long as there can be at most 65535 waypoints/depots in total.
 260          *
 261          * This does 'n * m' search, but with 32bit 'used' bitmap, it needs at
 262          * most 'n * (1 + ceil(m / 32))' steps (n - number of waypoints in pool,
 263          * m - number of waypoints near this town).
 264          * Usually, it needs only 'n' steps.
 265          *
 266          * If it wasn't using 'used' and 'idx', it would just search for increasing 'next',
 267          * but this way it is faster */
 268
 269         uint32 used = 0; // bitmap of used waypoint numbers, sliding window with 'next' as base
 270         uint32 next = 0; // first number in the bitmap
 271         uint32 idx  = 0; // index where we will stop
 272         uint32 cid  = 0; // current index, goes to T::GetPoolSize()-1, then wraps to 0
 273
 274         do {
 275                 T *lobj = T::GetIfValid(cid);
 276
 277                 /* check only valid objects, within the same city and of the same type */
 278                 if (lobj != NULL && lobj->town == obj->town && lobj->IsOfType(obj) && obj != lobj) {
 279                         /* if lobj->town_cn < next, uint will overflow to '+inf' */
 280                         uint i = (uint)lobj->town_cn - next;
 281
 282                         if (i == 0) {
 283                                 /* shift bitmap while the lowest bit is '1';
 284                                  * increase the base of the bitmap too */
 285                                 do {
 286                                         used >>= 1;
 287                                         next++;
 288                                 } while (HasBit(used, 0));
 289                                 /* when we are at 'idx' again at end of the loop and
 290                                  * 'next' hasn't changed, then no object had town_cn == next,
 291                                  * so we can safely use it */
 292                                 idx = cid;
 293                         } else if (i < 32) {
 294                                 SetBit(used, i); // update bitmap
 295                         }
 296                 }
 297
 298                 cid++;
 299                 if (cid == T::GetPoolSize()) cid = 0; // wrap to zero...
 300         } while (cid != idx);
 301
 302         obj->town_cn = (uint16)next; // set index...
 303 }
 304
 305 extern uint32 _town_cargoes_accepted;
 306
 307 #endif /* TOWN_H */