town.h

Go to the documentation of this file.

/* $Id: town.h 14828 2009-01-04 15:32:25Z smatz $ */

#ifndef TOWN_H
#define TOWN_H

#include "oldpool.h"
#include "core/bitmath_func.hpp"
#include "core/random_func.hpp"
#include "cargo_type.h"
#include "tile_type.h"
#include "date_type.h"
#include "town_type.h"
#include "company_type.h"
#include "settings_type.h"
#include "strings_type.h"
#include "viewport_type.h"
#include "economy_type.h"
#include "map_type.h"

enum {
  HOUSE_NO_CLASS   = 0,
  NEW_HOUSE_OFFSET = 110,
  HOUSE_MAX        = 512,
  INVALID_TOWN     = 0xFFFF,
  INVALID_HOUSE_ID = 0xFFFF,

  /* There can only be as many classes as there are new houses, plus one for
   * NO_CLASS, as the original houses don't have classes. */
  HOUSE_CLASS_MAX  = HOUSE_MAX - NEW_HOUSE_OFFSET + 1,
};

enum BuildingFlags {
  TILE_NO_FLAG         =       0,
  TILE_SIZE_1x1        = 1U << 0,
  TILE_NOT_SLOPED      = 1U << 1,
  TILE_SIZE_2x1        = 1U << 2,
  TILE_SIZE_1x2        = 1U << 3,
  TILE_SIZE_2x2        = 1U << 4,
  BUILDING_IS_ANIMATED = 1U << 5,
  BUILDING_IS_CHURCH   = 1U << 6,
  BUILDING_IS_STADIUM  = 1U << 7,
  BUILDING_HAS_1_TILE  = TILE_SIZE_1x1 | TILE_SIZE_2x1 | TILE_SIZE_1x2 | TILE_SIZE_2x2,
  BUILDING_2_TILES_X   = TILE_SIZE_2x1 | TILE_SIZE_2x2,
  BUILDING_2_TILES_Y   = TILE_SIZE_1x2 | TILE_SIZE_2x2,
  BUILDING_HAS_4_TILES = TILE_SIZE_2x2,
};

DECLARE_ENUM_AS_BIT_SET(BuildingFlags)

enum HouseZonesBits {
  HZB_BEGIN     = 0,
  HZB_TOWN_EDGE = 0,
  HZB_TOWN_OUTSKIRT,
  HZB_TOWN_OUTER_SUBURB,
  HZB_TOWN_INNER_SUBURB,
  HZB_TOWN_CENTRE,
  HZB_END,
};
assert_compile(HZB_END == 5);

DECLARE_POSTFIX_INCREMENT(HouseZonesBits)

enum HouseZones {                  
  HZ_NOZNS             = 0x0000,  
  HZ_ZON1              = 1U << HZB_TOWN_EDGE,    
  HZ_ZON2              = 1U << HZB_TOWN_OUTSKIRT,
  HZ_ZON3              = 1U << HZB_TOWN_OUTER_SUBURB,
  HZ_ZON4              = 1U << HZB_TOWN_INNER_SUBURB,
  HZ_ZON5              = 1U << HZB_TOWN_CENTRE,  
  HZ_ZONALL            = 0x001F,  
  HZ_SUBARTC_ABOVE     = 0x0800,  
  HZ_TEMP              = 0x1000,  
  HZ_SUBARTC_BELOW     = 0x2000,  
  HZ_SUBTROPIC         = 0x4000,  
  HZ_TOYLND            = 0x8000   
};

DECLARE_ENUM_AS_BIT_SET(HouseZones)

enum HouseExtraFlags {
  NO_EXTRA_FLAG            =       0,
  BUILDING_IS_HISTORICAL   = 1U << 0,  
  BUILDING_IS_PROTECTED    = 1U << 1,  
  SYNCHRONISED_CALLBACK_1B = 1U << 2,  
  CALLBACK_1A_RANDOM_BITS  = 1U << 3,  
};

DECLARE_ENUM_AS_BIT_SET(HouseExtraFlags)

struct BuildingCounts {
  uint8 id_count[HOUSE_MAX];
  uint8 class_count[HOUSE_CLASS_MAX];
};

DECLARE_OLD_POOL(Town, Town, 3, 8000)

struct Town : PoolItem<Town, TownID, &_Town_pool> {
  TileIndex xy;

  /* Current population of people and amount of houses. */
  uint32 num_houses;
  uint32 population;

  /* Town name */
  uint32 townnamegrfid;
  uint16 townnametype;
  uint32 townnameparts;
  char *name;

  /* NOSAVE: Location of name sign, UpdateTownVirtCoord updates this. */
  ViewportSign sign;

  /* Makes sure we don't build certain house types twice.
   * bit 0 = Building funds received
   * bit 1 = CHURCH
   * bit 2 = STADIUM */
  byte flags12;

  /* level of noise that all the airports are generating */
  uint16 noise_reached;

  /* Which companies have a statue? */
  CompanyMask statues;

  /* Company ratings as well as a mask that determines which companies have a rating. */
  CompanyMask have_ratings;
  uint8 unwanted[MAX_COMPANIES]; 
  CompanyByte exclusivity;       
  uint8 exclusive_counter;       
  int16 ratings[MAX_COMPANIES];

  /* Maximum amount of passengers and mail that can be transported. */
  uint32 max_pass;
  uint32 max_mail;
  uint32 new_max_pass;
  uint32 new_max_mail;
  uint32 act_pass;
  uint32 act_mail;
  uint32 new_act_pass;
  uint32 new_act_mail;

  /* Amount of passengers that were transported. */
  byte pct_pass_transported;
  byte pct_mail_transported;

  /* Amount of food and paper that was transported. Actually a bit mask would be enough. */
  uint16 act_food;
  uint16 act_water;
  uint16 new_act_food;
  uint16 new_act_water;

  /* Time until we rebuild a house. */
  uint16 time_until_rebuild;

  /* When to grow town next time. */
  uint16 grow_counter;
  int16 growth_rate;

  /* Fund buildings program in action? */
  byte fund_buildings_months;

  /* Fund road reconstruction in action? */
  byte road_build_months;

  /* If this is a larger town, and should grow more quickly. */
  bool larger_town;

  /* NOSAVE: UpdateTownRadius updates this given the house count. */
  uint32 squared_town_zone_radius[HZB_END];

  /* NOSAVE: The number of each type of building in the town. */
  BuildingCounts building_counts;

  /* NOSAVE: The town specific road layout */
  TownLayout layout;

  Town(TileIndex tile = INVALID_TILE);

  ~Town();

  inline bool IsValid() const { return this->xy != INVALID_TILE; }

  void InitializeLayout();

  inline TownLayout GetActiveLayout() const;

  inline uint16 MaxTownNoise() const {
    if (this->population == 0) return 0; // no population? no noise

    return ((this->population / _settings_game.economy.town_noise_population[_settings_game.difficulty.town_council_tolerance]) + 3);
  }
};

inline TownLayout Town::GetActiveLayout() const
{
  return (_settings_game.economy.town_layout == TL_RANDOM) ? this->layout : _settings_game.economy.town_layout;
}

struct HouseSpec {
  /* Standard properties */
  Year min_year;                     
  Year max_year;                     
  byte population;                   
  byte removal_cost;                 
  StringID building_name;            
  uint16 remove_rating_decrease;     
  byte mail_generation;              
  byte cargo_acceptance[3];          
  CargoID accepts_cargo[3];          
  BuildingFlags building_flags;      
  HouseZones building_availability;  
  bool enabled;                      

  /* NewHouses properties */
  HouseID substitute_id;             
  struct SpriteGroup *spritegroup;   
  HouseID override;                  
  uint16 callback_mask;              
  byte random_colour[4];             
  byte probability;                  
  HouseExtraFlags extra_flags;       
  HouseClassID class_id;             
  byte animation_frames;             
  byte animation_speed;              
  byte processing_time;              
  byte minimum_life;                 

  /* grf file related properties*/
  uint8 local_id;                    
  const struct GRFFile *grffile;     

  Money GetRemovalCost() const;

};

extern HouseSpec _house_specs[HOUSE_MAX];

uint32 GetWorldPopulation();

void UpdateTownVirtCoord(Town *t);
void UpdateAllTownVirtCoords();
void InitializeTown();
void ShowTownViewWindow(TownID town);
void ExpandTown(Town *t);
Town *CreateRandomTown(uint attempts, TownSizeMode mode, uint size);

enum {
  ROAD_REMOVE = 0,
  UNMOVEABLE_REMOVE = 1,
  TUNNELBRIDGE_REMOVE = 1,
  INDUSTRY_REMOVE = 2
};

static const byte TOWN_GROWTH_FREQUENCY = 70;

static const byte TOWN_HOUSE_COMPLETED = 3;

enum {
  TOWN_IS_FUNDED      = 0,   
  TOWN_HAS_CHURCH     = 1,   
  TOWN_HAS_STADIUM    = 2    
};

bool CheckforTownRating(uint32 flags, Town *t, byte type);

static inline HouseSpec *GetHouseSpecs(HouseID house_id)
{
  assert(house_id < HOUSE_MAX);
  return &_house_specs[house_id];
}

TileIndexDiff GetHouseNorthPart(HouseID &house);

static inline bool IsValidTownID(TownID index)
{
  return index < GetTownPoolSize() && GetTown(index)->IsValid();
}

static inline TownID GetMaxTownIndex()
{
  /* TODO - This isn't the real content of the function, but
   *  with the new pool-system this will be replaced with one that
   *  _really_ returns the highest index. Now it just returns
   *  the next safe value we are sure about everything is below.
   */
  return GetTownPoolSize() - 1;
}

static inline uint GetNumTowns()
{
  extern uint _total_towns;

  return _total_towns;
}

static inline Town *GetRandomTown()
{
  int num = RandomRange(GetNumTowns());
  TownID index = INVALID_TOWN;

  while (num >= 0) {
    num--;

    index++;
    /* Make sure we have a valid town */
    while (!IsValidTownID(index)) {
      index++;
      assert(index <= GetMaxTownIndex());
    }
  }

  return GetTown(index);
}

Town *CalcClosestTownFromTile(TileIndex tile, uint threshold);

#define FOR_ALL_TOWNS_FROM(t, start) for (t = GetTown(start); t != NULL; t = (t->index + 1U < GetTownPoolSize()) ? GetTown(t->index + 1U) : NULL) if (t->IsValid())
#define FOR_ALL_TOWNS(t) FOR_ALL_TOWNS_FROM(t, 0)

extern Town *_cleared_town;
extern int _cleared_town_rating;

void ResetHouses();

void ClearTownHouse(Town *t, TileIndex tile);
void UpdateTownMaxPass(Town *t);
void UpdateTownRadius(Town *t);
bool CheckIfAuthorityAllows(TileIndex tile);
Town *ClosestTownFromTile(TileIndex tile, uint threshold);
void ChangeTownRating(Town *t, int add, int max);
HouseZonesBits GetTownRadiusGroup(const Town* t, TileIndex tile);
void SetTownRatingTestMode(bool mode);

static inline uint TileHash(uint x, uint y)
{
  uint hash = x >> 4;
  hash ^= x >> 6;
  hash ^= y >> 4;
  hash -= y >> 6;
  return hash;
}

static inline uint TileHash2Bit(uint x, uint y)
{
  return GB(TileHash(x, y), 0, 2);
}

#endif /* TOWN_H */