town.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef TOWN_H
#define TOWN_H
 
#include "misc/history_type.hpp"
#include "viewport_type.h"
#include "timer/timer_game_tick.h"
#include "town_map.h"
#include "subsidy_type.h"
#include "newgrf_storage.h"
#include "cargotype.h"
 
template <typename T>
struct BuildingCounts {
  std::vector<T> id_count{};
  std::vector<T> class_count{};
 
  auto operator<=>(const BuildingCounts &) const = default;
};
 
static const uint CUSTOM_TOWN_NUMBER_DIFFICULTY  = 4; 
static const uint CUSTOM_TOWN_MAX_NUMBER = 5000;  
 
static const uint TOWN_GROWTH_WINTER = 0xFFFFFFFE; 
static const uint TOWN_GROWTH_DESERT = 0xFFFFFFFF; 
static const uint16_t TOWN_GROWTH_RATE_NONE = 0xFFFF; 
static const uint16_t MAX_TOWN_GROWTH_TICKS = 930; 
 
typedef Pool<Town, TownID, 64> TownPool;
extern TownPool _town_pool;
 
enum class TownFlag : uint8_t {
  IsGrowing = 0, 
  HasChurch = 1, 
  HasStadium = 2, 
  CustomGrowth = 3, 
};
 
using TownFlags = EnumBitSet<TownFlag, uint8_t>;
 
struct TownCache {
  uint32_t num_houses = 0; 
  uint32_t population = 0; 
  TrackedViewportSign sign{}; 
  PartsOfSubsidy part_of_subsidy{}; 
  std::array<uint32_t, NUM_HOUSE_ZONES> squared_town_zone_radius{}; 
  BuildingCounts<uint16_t> building_counts{}; 
 
  auto operator<=>(const TownCache &) const = default;
};
 
struct Town : TownPool::PoolItem<&_town_pool> {
  TileIndex xy = INVALID_TILE; 
 
  TownCache cache{}; 
 
  /* Town name */
  uint32_t townnamegrfid = 0;
  uint16_t townnametype = 0;
  uint32_t townnameparts = 0;
  std::string name{}; 
  mutable std::string cached_name{}; 
 
  TownFlags flags{}; 
 
  uint16_t noise_reached = 0; 
 
  CompanyMask statues{}; 
 
  /* Company ratings. */
  CompanyMask have_ratings{}; 
  TypedIndexContainer<std::array<uint8_t, MAX_COMPANIES>, CompanyID> unwanted{}; 
  CompanyID exclusivity = CompanyID::Invalid(); 
  uint8_t exclusive_counter = 0; 
  TypedIndexContainer<std::array<int16_t, MAX_COMPANIES>, CompanyID> ratings{};  
 
  struct SuppliedHistory {
    uint32_t production = 0; 
    uint32_t transported = 0; 
 
    uint8_t PctTransported() const
    {
      if (this->production == 0) return 0;
      return ClampTo<uint8_t>(this->transported * 256 / this->production);
    }
  };
 
  struct SuppliedCargo {
    CargoType cargo = INVALID_CARGO;
    HistoryData<SuppliedHistory> history{};
 
    SuppliedCargo() = default;
    SuppliedCargo(CargoType cargo) : cargo(cargo) {}
  };
 
  using SuppliedCargoes = std::vector<SuppliedCargo>;
 
  SuppliedCargoes supplied{}; 
  std::array<TransportedCargoStat<uint16_t>, NUM_TAE> received{}; 
  std::array<uint32_t, NUM_TAE> goal{}; 
  ValidHistoryMask valid_history = 0; 
 
  EncodedString text{}; 
 
  inline SuppliedCargo &GetOrCreateCargoSupplied(CargoType cargo)
  {
    assert(IsValidCargoType(cargo));
    auto it = std::ranges::lower_bound(this->supplied, cargo, std::less{}, &SuppliedCargo::cargo);
    if (it == std::end(this->supplied) || it->cargo != cargo) it = this->supplied.emplace(it, cargo);
    return *it;
  }
 
  inline SuppliedCargoes::const_iterator GetCargoSupplied(CargoType cargo) const
  {
    if (!IsValidCargoType(cargo)) return std::end(this->supplied);
    auto it = std::ranges::lower_bound(this->supplied, cargo, std::less{}, &SuppliedCargo::cargo);
    if (it == std::end(this->supplied) || it->cargo != cargo) return std::end(supplied);
    return it;
  }
 
  inline uint8_t GetPercentTransported(CargoType cargo_type) const
  {
    auto it = this->GetCargoSupplied(cargo_type);
    if (it == std::end(this->supplied)) return 0;
 
    return it->history[LAST_MONTH].PctTransported();
  }
 
  StationList stations_near{}; 
 
  uint16_t time_until_rebuild = 0; 
 
  uint16_t grow_counter = 0; 
  uint16_t growth_rate = 0; 
 
  uint8_t fund_buildings_months = 0; 
  uint8_t road_build_months = 0; 
 
  bool larger_town = false; 
  TownLayout layout{}; 
 
  bool show_zone = false; 
 
  std::vector<PersistentStorage *> psa_list{};
 
  Town(TileIndex tile = INVALID_TILE) : xy(tile) { }
 
  ~Town();
 
  void InitializeLayout(TownLayout layout);
 
  inline uint16_t MaxTownNoise() const
  {
    if (this->cache.population == 0) return 0; // no population? no noise
 
    /* 3 is added (the noise of the lowest airport), so the  user can at least build a small airfield. */
    return ClampTo<uint16_t>((this->cache.population / _settings_game.economy.town_noise_population[_settings_game.difficulty.town_council_tolerance]) + 3);
  }
 
  void UpdateVirtCoord();
 
  inline const std::string &GetCachedName() const
  {
    if (!this->name.empty()) return this->name;
    if (this->cached_name.empty()) this->FillCachedName();
    return this->cached_name;
  }
 
  static inline Town *GetByTile(TileIndex tile)
  {
    return Town::Get(GetTownIndex(tile));
  }
 
  static Town *GetRandom();
  static void PostDestructor(size_t index);
 
private:
  void FillCachedName() const;
};
 
uint32_t GetWorldPopulation();
 
void UpdateAllTownVirtCoords();
void ClearAllTownCachedNames();
void ShowTownViewWindow(TownID town);
void ExpandTown(Town *t);
 
void RebuildTownKdtree();
 
enum TownCouncilAttitudes {
  TOWN_COUNCIL_LENIENT    = 0,
  TOWN_COUNCIL_TOLERANT   = 1,
  TOWN_COUNCIL_HOSTILE    = 2,
  TOWN_COUNCIL_PERMISSIVE = 3,
};
 
enum class TownRatingCheckType : uint8_t {
  RoadRemove, 
  TunnelBridgeRemove, 
  End,
};
 
enum TownDirectoryInvalidateWindowData {
  TDIWD_FORCE_REBUILD,
  TDIWD_POPULATION_CHANGE,
  TDIWD_FORCE_RESORT,
};
 
CommandCost CheckforTownRating(DoCommandFlags flags, Town *t, TownRatingCheckType type);
 
 
TileIndexDiff GetHouseNorthPart(HouseID &house);
 
Town *CalcClosestTownFromTile(TileIndex tile, uint threshold = UINT_MAX);
 
void ResetHouses();
 
enum class TownAction : uint8_t {
  AdvertiseSmall, 
  AdvertiseMedium, 
  AdvertiseLarge, 
  RoadRebuild, 
  BuildStatue, 
  FundBuildings, 
  BuyRights, 
  Bribe, 
  End,
};
using TownActions = EnumBitSet<TownAction, uint8_t>;
 
DECLARE_INCREMENT_DECREMENT_OPERATORS(TownAction);
 
void ClearTownHouse(Town *t, TileIndex tile);
void UpdateTownMaxPass(Town *t);
void UpdateTownRadius(Town *t);
CommandCost CheckIfAuthorityAllowsNewStation(TileIndex tile, DoCommandFlags flags);
Town *ClosestTownFromTile(TileIndex tile, uint threshold);
void ChangeTownRating(Town *t, int add, int max, DoCommandFlags flags);
HouseZone GetTownRadiusGroup(const Town *t, TileIndex tile);
void SetTownRatingTestMode(bool mode);
TownActions GetMaskOfTownActions(CompanyID cid, const Town *t);
uint GetDefaultTownsForMapSize();
bool GenerateTowns(TownLayout layout, std::optional<uint> number = std::nullopt);
const CargoSpec *FindFirstCargoWithTownAcceptanceEffect(TownAcceptanceEffect effect);
CargoArray GetAcceptedCargoOfHouse(const HouseSpec *hs);
 
uint8_t GetTownActionCost(TownAction action);
 
template <class T>
void MakeDefaultName(T *obj)
{
  /* We only want to set names if it hasn't been set before, or when we're calling from afterload. */
  assert(obj->name.empty() || obj->town_cn == UINT16_MAX);
 
  obj->town = ClosestTownFromTile(obj->xy, UINT_MAX);
 
  /* Find first unused number belonging to this town. This can never fail,
   * as long as there can be at most 65535 waypoints/depots in total.
   *
   * This does 'n * m' search, but with 32bit 'used' bitmap, it needs at
   * most 'n * (1 + ceil(m / 32))' steps (n - number of waypoints in pool,
   * m - number of waypoints near this town).
   * Usually, it needs only 'n' steps.
   *
   * If it wasn't using 'used' and 'idx', it would just search for increasing 'next',
   * but this way it is faster */
 
  uint32_t used = 0; // bitmap of used waypoint numbers, sliding window with 'next' as base
  uint32_t next = 0; // first number in the bitmap
  uint32_t idx  = 0; // index where we will stop
  uint32_t cid  = 0; // current index, goes to T::GetPoolSize()-1, then wraps to 0
 
  do {
    T *lobj = T::GetIfValid(cid);
 
    /* check only valid waypoints... */
    if (lobj != nullptr && obj != lobj) {
      /* only objects within the same city and with the same type */
      if (lobj->town == obj->town && lobj->IsOfType(obj)) {
        /* if lobj->town_cn < next, uint will overflow to '+inf' */
        uint i = (uint)lobj->town_cn - next;
 
        if (i < 32) {
          SetBit(used, i); // update bitmap
          if (i == 0) {
            /* shift bitmap while the lowest bit is '1';
             * increase the base of the bitmap too */
            do {
              used >>= 1;
              next++;
            } while (HasBit(used, 0));
            /* when we are at 'idx' again at end of the loop and
             * 'next' hasn't changed, then no object had town_cn == next,
             * so we can safely use it */
            idx = cid;
          }
        }
      }
    }
 
    cid++;
    if (cid == T::GetPoolSize()) cid = 0; // wrap to zero...
  } while (cid != idx);
 
  obj->town_cn = (uint16_t)next; // set index...
}
 
/*
 * Converts original town ticks counters to plain game ticks. Note that
 * tick 0 is a valid tick so actual amount is one more than the counter value.
 */
inline uint16_t TownTicksToGameTicks(uint16_t ticks)
{
  return (std::min(ticks, MAX_TOWN_GROWTH_TICKS) + 1) * Ticks::TOWN_GROWTH_TICKS - 1;
}
 
 
RoadType GetTownRoadType();
bool CheckTownRoadTypes();
std::span<const DrawBuildingsTileStruct> GetTownDrawTileData();
 
#endif /* TOWN_H */