1

/* $Id$ */

     2

     3

/** @file town.h Base of the town class. */

     4

     5

#ifndef TOWN_H

     6

#define TOWN_H

     7

     8

#include "oldpool.h"

     9

#include "core/bitmath_func.hpp"

    10

#include "core/random_func.hpp"

    11

#include "cargo_type.h"

    12

#include "tile_type.h"

    13

#include "date_type.h"

    14

#include "town_type.h"

    15

#include "company_type.h"

    16

#include "settings_type.h"

    17

#include "strings_type.h"

    18

#include "viewport_type.h"

    19

#include "economy_type.h"

    20

#include "map_type.h"

    21

    22

enum {

    23

	HOUSE_NO_CLASS   = 0,

    24

	NEW_HOUSE_OFFSET = 110,

    25

	HOUSE_MAX        = 512,

    26

	INVALID_TOWN     = 0xFFFF,

    27

	INVALID_HOUSE_ID = 0xFFFF,

    28

    29

	/* There can only be as many classes as there are new houses, plus one for

    30

	 * NO_CLASS, as the original houses don't have classes. */

    31

	HOUSE_CLASS_MAX  = HOUSE_MAX - NEW_HOUSE_OFFSET + 1,

    32

};

    33

    34

enum BuildingFlags {

    35

	TILE_NO_FLAG         =       0,

    36

	TILE_SIZE_1x1        = 1U << 0,

    37

	TILE_NOT_SLOPED      = 1U << 1,

    38

	TILE_SIZE_2x1        = 1U << 2,

    39

	TILE_SIZE_1x2        = 1U << 3,

    40

	TILE_SIZE_2x2        = 1U << 4,

    41

	BUILDING_IS_ANIMATED = 1U << 5,

    42

	BUILDING_IS_CHURCH   = 1U << 6,

    43

	BUILDING_IS_STADIUM  = 1U << 7,

    44

	BUILDING_HAS_1_TILE  = TILE_SIZE_1x1 | TILE_SIZE_2x1 | TILE_SIZE_1x2 | TILE_SIZE_2x2,

    45

	BUILDING_2_TILES_X   = TILE_SIZE_2x1 | TILE_SIZE_2x2,

    46

	BUILDING_2_TILES_Y   = TILE_SIZE_1x2 | TILE_SIZE_2x2,

    47

	BUILDING_HAS_4_TILES = TILE_SIZE_2x2,

    48

};

    49

    50

DECLARE_ENUM_AS_BIT_SET(BuildingFlags)

    51

    52

enum HouseZonesBits {

    53

	HZB_BEGIN     = 0,

    54

	HZB_TOWN_EDGE = 0,

    55

	HZB_TOWN_OUTSKIRT,

    56

	HZB_TOWN_OUTER_SUBURB,

    57

	HZB_TOWN_INNER_SUBURB,

    58

	HZB_TOWN_CENTRE,

    59

	HZB_END,

    60

};

    61

assert_compile(HZB_END == 5);

    62

    63

DECLARE_POSTFIX_INCREMENT(HouseZonesBits)

    64

    65

enum HouseZones {                  ///< Bit  Value       Meaning

    66

	HZ_NOZNS             = 0x0000,  ///<       0          This is just to get rid of zeros, meaning none

    67

	HZ_ZON1              = 1U << HZB_TOWN_EDGE,    ///< 0..4 1,2,4,8,10  which town zones the building can be built in, Zone1 been the further suburb

    68

	HZ_ZON2              = 1U << HZB_TOWN_OUTSKIRT,

    69

	HZ_ZON3              = 1U << HZB_TOWN_OUTER_SUBURB,

    70

	HZ_ZON4              = 1U << HZB_TOWN_INNER_SUBURB,

    71

	HZ_ZON5              = 1U << HZB_TOWN_CENTRE,  ///<  center of town

    72

	HZ_ZONALL            = 0x001F,  ///<       1F         This is just to englobe all above types at once

    73

	HZ_SUBARTC_ABOVE     = 0x0800,  ///< 11    800        can appear in sub-arctic climate above the snow line

    74

	HZ_TEMP              = 0x1000,  ///< 12   1000        can appear in temperate climate

    75

	HZ_SUBARTC_BELOW     = 0x2000,  ///< 13   2000        can appear in sub-arctic climate below the snow line

    76

	HZ_SUBTROPIC         = 0x4000,  ///< 14   4000        can appear in subtropical climate

    77

	HZ_TOYLND            = 0x8000   ///< 15   8000        can appear in toyland climate

    78

};

    79

    80

DECLARE_ENUM_AS_BIT_SET(HouseZones)

    81

    82

enum HouseExtraFlags {

    83

	NO_EXTRA_FLAG            =       0,

    84

	BUILDING_IS_HISTORICAL   = 1U << 0,  ///< this house will only appear during town generation in random games, thus the historical

    85

	BUILDING_IS_PROTECTED    = 1U << 1,  ///< towns and AI will not remove this house, while human players will be able to

    86

	SYNCHRONISED_CALLBACK_1B = 1U << 2,  ///< synchronized callback 1B will be performed, on multi tile houses

    87

	CALLBACK_1A_RANDOM_BITS  = 1U << 3,  ///< callback 1A needs random bits

    88

};

    89

    90

DECLARE_ENUM_AS_BIT_SET(HouseExtraFlags)

    91

    92

struct BuildingCounts {

    93

	uint8 id_count[HOUSE_MAX];

    94

	uint8 class_count[HOUSE_CLASS_MAX];

    95

};

    96

    97

DECLARE_OLD_POOL(Town, Town, 3, 8000)

    98

    99

struct Town : PoolItem<Town, TownID, &_Town_pool> {

   100

	TileIndex xy;

   101

   102

	/* Current population of people and amount of houses. */

   103

	uint32 num_houses;

   104

	uint32 population;

   105

   106

	/* Town name */

   107

	uint32 townnamegrfid;

   108

	uint16 townnametype;

   109

	uint32 townnameparts;

   110

	char *name;

   111

   112

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

   113

	ViewportSign sign;

   114

   115

	/* Makes sure we don't build certain house types twice.

   116

	 * bit 0 = Building funds received

   117

	 * bit 1 = CHURCH

   118

	 * bit 2 = STADIUM */

   119

	byte flags12;

   120

   121

	/* level of noise that all the airports are generating */

   122

	uint16 noise_reached;

   123

   124

	/* Which companies have a statue? */

   125

	byte statues;

   126

   127

	/* Company ratings as well as a mask that determines which companies have a rating. */

   128

	CompanyMask have_ratings;

   129

	uint8 unwanted[MAX_COMPANIES]; ///< how many months companies aren't wanted by towns (bribe)

   130

	CompanyByte exclusivity;       ///< which company has exclusivity

   131

	uint8 exclusive_counter;       ///< months till the exclusivity expires

   132

	int16 ratings[MAX_COMPANIES];

   133

   134

	/* Maximum amount of passengers and mail that can be transported. */

   135

	uint32 max_pass;

   136

	uint32 max_mail;

   137

	uint32 new_max_pass;

   138

	uint32 new_max_mail;

   139

	uint32 act_pass;

   140

	uint32 act_mail;

   141

	uint32 new_act_pass;

   142

	uint32 new_act_mail;

   143

   144

	/* Amount of passengers that were transported. */

   145

	byte pct_pass_transported;

   146

	byte pct_mail_transported;

   147

   148

	/* Amount of food and paper that was transported. Actually a bit mask would be enough. */

   149

	uint16 act_food;

   150

	uint16 act_water;

   151

	uint16 new_act_food;

   152

	uint16 new_act_water;

   153

   154

	/* Time until we rebuild a house. */

   155

	uint16 time_until_rebuild;

   156

   157

	/* When to grow town next time. */

   158

	uint16 grow_counter;

   159

	int16 growth_rate;

   160

   161

	/* Fund buildings program in action? */

   162

	byte fund_buildings_months;

   163

   164

	/* Fund road reconstruction in action? */

   165

	byte road_build_months;

   166

   167

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

   168

	bool larger_town;

   169

   170

	/* NOSAVE: UpdateTownRadius updates this given the house count. */

   171

	uint32 squared_town_zone_radius[HZB_END];

   172

   173

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

   174

	BuildingCounts building_counts;

   175

   176

	/* NOSAVE: The town specific road layout */

   177

	TownLayout layout;

   178

   179

	/**

   180

	 * Creates a new town

   181

	 */

   182

	Town(TileIndex tile = 0);

   183

   184

	/** Destroy the town */

   185

	~Town();

   186

   187

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

   188

   189

	void InitializeLayout();

   190

   191

	inline TownLayout GetActiveLayout() const;

   192

   193

	/** Calculate the max town noise

   194

	 * The value is counted using the population divided by the content of the

   195

	 * entry in town_noise_population corespondig to the town's tolerance.

   196

	 * To this result, we add 3, which is the noise of the lowest airport.

   197

	 * So user can at least buld that airport

   198

	 * @return the maximum noise level the town will tolerate */

   199

	inline uint16 MaxTownNoise() const {

   200

		if (this->population == 0) return 0; // no population? no noise

   201

   202

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

   203

	}

   204

};

   205

   206

/**

   207

 * Get the current valid layout for the town

   208

 * @return the active layout for this town

   209

 */

   210

inline TownLayout Town::GetActiveLayout() const

   211

{

   212

	return (_settings_game.economy.town_layout == TL_RANDOM) ? this->layout : _settings_game.economy.town_layout;

   213

}

   214

   215

struct HouseSpec {

   216

	/* Standard properties */

   217

	Year min_year;                     ///< introduction year of the house

   218

	Year max_year;                     ///< last year it can be built

   219

	byte population;                   ///< population (Zero on other tiles in multi tile house.)

   220

	byte removal_cost;                 ///< cost multiplier for removing it

   221

	StringID building_name;            ///< building name

   222

	uint16 remove_rating_decrease;     ///< rating decrease if removed

   223

	byte mail_generation;              ///< mail generation multiplier (tile based, as the acceptances below)

   224

	byte cargo_acceptance[3];          ///< acceptance level for the cargo slots

   225

	CargoID accepts_cargo[3];          ///< 3 input cargo slots

   226

	BuildingFlags building_flags;      ///< some flags that describe the house (size, stadium etc...)

   227

	HouseZones building_availability;  ///< where can it be built (climates, zones)

   228

	bool enabled;                      ///< the house is available to build (true by default, but can be disabled by newgrf)

   229

   230

	/* NewHouses properties */

   231

	HouseID substitute_id;             ///< which original house this one is based on

   232

	struct SpriteGroup *spritegroup;   ///< pointer to the different sprites of the house

   233

	HouseID override;                  ///< which house this one replaces

   234

	uint16 callback_mask;              ///< House callback flags

   235

	byte random_colour[4];             ///< 4 "random" colours

   236

	byte probability;                  ///< Relative probability of appearing (16 is the standard value)

   237

	HouseExtraFlags extra_flags;       ///< some more flags

   238

	HouseClassID class_id;             ///< defines the class this house has (grf file based) @See HouseGetVariable, prop 0x44

   239

	byte animation_frames;             ///< number of animation frames

   240

	byte animation_speed;              ///< amount of time between each of those frames

   241

	byte processing_time;              ///< Periodic refresh multiplier

   242

	byte minimum_life;                 ///< The minimum number of years this house will survive before the town rebuilds it

   243

   244

	/* grf file related properties*/

   245

	uint8 local_id;                    ///< id defined by the grf file for this house

   246

	const struct GRFFile *grffile;     ///< grf file that introduced this house

   247

   248

	/**

   249

	 * Get the cost for removing this house

   250

	 * @return the cost (inflation corrected etc)

   251

	 */

   252

	Money GetRemovalCost() const;

   253

   254

};

   255

   256

extern HouseSpec _house_specs[HOUSE_MAX];

   257

   258

uint32 GetWorldPopulation();

   259

   260

void UpdateTownVirtCoord(Town *t);

   261

void UpdateAllTownVirtCoords();

   262

void InitializeTown();

   263

void ShowTownViewWindow(TownID town);

   264

void ExpandTown(Town *t);

   265

Town *CreateRandomTown(uint attempts, TownSizeMode mode, uint size);

   266

   267

enum {

   268

	ROAD_REMOVE = 0,

   269

	UNMOVEABLE_REMOVE = 1,

   270

	TUNNELBRIDGE_REMOVE = 1,

   271

	INDUSTRY_REMOVE = 2

   272

};

   273

   274

/** This is the number of ticks between towns being processed for building new

   275

 * houses or roads. This value originally came from the size of the town array

   276

 * in TTD. */

   277

static const byte TOWN_GROWTH_FREQUENCY = 70;

   278

   279

/** Simple value that indicates the house has reached the final stage of

   280

 * construction. */

   281

static const byte TOWN_HOUSE_COMPLETED = 3;

   282

   283

/** This enum is used in conjonction with town->flags12.

   284

 * IT simply states what bit is used for.

   285

 * It is pretty unrealistic (IMHO) to only have one church/stadium

   286

 * per town, NO MATTER the population of it.

   287

 * And there are 5 more bits available on flags12...

   288

 */

   289

enum {

   290

	TOWN_IS_FUNDED      = 0,   ///< Town has received some funds for

   291

	TOWN_HAS_CHURCH     = 1,   ///< There can be only one church by town.

   292

	TOWN_HAS_STADIUM    = 2    ///< There can be only one stadium by town.

   293

};

   294

   295

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

   296

   297

static inline HouseSpec *GetHouseSpecs(HouseID house_id)

   298

{

   299

	assert(house_id < HOUSE_MAX);

   300

	return &_house_specs[house_id];

   301

}

   302

   303

TileIndexDiff GetHouseNorthPart(HouseID &house);

   304

   305

/**

   306

 * Check if a TownID is valid.

   307

 * @param index to inquiry in the pool of town

   308

 * @return true if it exists

   309

 */

   310

static inline bool IsValidTownID(TownID index)

   311

{

   312

	return index < GetTownPoolSize() && GetTown(index)->IsValid();

   313

}

   314

   315

static inline TownID GetMaxTownIndex()

   316

{

   317

	/* TODO - This isn't the real content of the function, but

   318

	 *  with the new pool-system this will be replaced with one that

   319

	 *  _really_ returns the highest index. Now it just returns

   320

	 *  the next safe value we are sure about everything is below.

   321

	 */

   322

	return GetTownPoolSize() - 1;

   323

}

   324

   325

static inline uint GetNumTowns()

   326

{

   327

	extern uint _total_towns;

   328

   329

	return _total_towns;

   330

}

   331

   332

/**

   333

 * Return a random valid town.

   334

 */

   335

static inline Town *GetRandomTown()

   336

{

   337

	int num = RandomRange(GetNumTowns());

   338

	TownID index = INVALID_TOWN;

   339

   340

	while (num >= 0) {

   341

		num--;

   342

   343

		index++;

   344

		/* Make sure we have a valid town */

   345

		while (!IsValidTownID(index)) {

   346

			index++;

   347

			assert(index <= GetMaxTownIndex());

   348

		}

   349

	}

   350

   351

	return GetTown(index);

   352

}

   353

   354

Town *CalcClosestTownFromTile(TileIndex tile, uint threshold);

   355

   356

#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())

   357

#define FOR_ALL_TOWNS(t) FOR_ALL_TOWNS_FROM(t, 0)

   358

   359

extern Town *_cleared_town;

   360

extern int _cleared_town_rating;

   361

   362

void ResetHouses();

   363

   364

void ClearTownHouse(Town *t, TileIndex tile);

   365

void AfterLoadTown();

   366

void UpdateTownMaxPass(Town *t);

   367

void UpdateTownRadius(Town *t);

   368

bool CheckIfAuthorityAllows(TileIndex tile);

   369

Town *ClosestTownFromTile(TileIndex tile, uint threshold);

   370

void ChangeTownRating(Town *t, int add, int max);

   371

HouseZonesBits GetTownRadiusGroup(const Town* t, TileIndex tile);

   372

void SetTownRatingTestMode(bool mode);

   373

   374

/**

   375

 * Calculate a hash value from a tile position

   376

 *

   377

 * @param x The X coordinate

   378

 * @param y The Y coordinate

   379

 * @return The hash of the tile

   380

 */

   381

static inline uint TileHash(uint x, uint y)

   382

{

   383

	uint hash = x >> 4;

   384

	hash ^= x >> 6;

   385

	hash ^= y >> 4;

   386

	hash -= y >> 6;

   387

	return hash;

   388

}

   389

   390

/**

   391

 * Get the last two bits of the TileHash

   392

 *  from a tile position.

   393

 *

   394

 * @see TileHash()

   395

 * @param x The X coordinate

   396

 * @param y The Y coordinate

   397

 * @return The last two bits from hash of the tile

   398

 */

   399

static inline uint TileHash2Bit(uint x, uint y)

   400

{

   401

	return GB(TileHash(x, y), 0, 2);

   402

}

   403

   404

#endif /* TOWN_H */