1

/* $Id$ */

     2

     3

/** @file town.h */

     4

     5

#ifndef TOWN_H

     6

#define TOWN_H

     7

     8

#include "oldpool.h"

     9

#include "core/random_func.hpp"

    10

#include "cargo_type.h"

    11

#include "tile_type.h"

    12

#include "date_type.h"

    13

    14

enum {

    15

	HOUSE_NO_CLASS   = 0,

    16

	NEW_HOUSE_OFFSET = 110,

    17

	HOUSE_MAX        = 512,

    18

	INVALID_TOWN     = 0xFFFF,

    19

	INVALID_HOUSE_ID = 0xFFFF,

    20

    21

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

    22

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

    23

	HOUSE_CLASS_MAX  = HOUSE_MAX - NEW_HOUSE_OFFSET + 1,

    24

};

    25

    26

enum BuildingFlags {

    27

	TILE_NO_FLAG         =       0,

    28

	TILE_SIZE_1x1        = 1U << 0,

    29

	TILE_NOT_SLOPED      = 1U << 1,

    30

	TILE_SIZE_2x1        = 1U << 2,

    31

	TILE_SIZE_1x2        = 1U << 3,

    32

	TILE_SIZE_2x2        = 1U << 4,

    33

	BUILDING_IS_ANIMATED = 1U << 5,

    34

	BUILDING_IS_CHURCH   = 1U << 6,

    35

	BUILDING_IS_STADIUM  = 1U << 7,

    36

	BUILDING_HAS_1_TILE  = TILE_SIZE_1x1 | TILE_SIZE_2x1 | TILE_SIZE_1x2 | TILE_SIZE_2x2,

    37

	BUILDING_2_TILES_X   = TILE_SIZE_2x1 | TILE_SIZE_2x2,

    38

	BUILDING_2_TILES_Y   = TILE_SIZE_1x2 | TILE_SIZE_2x2,

    39

	BUILDING_HAS_4_TILES = TILE_SIZE_2x2,

    40

};

    41

    42

DECLARE_ENUM_AS_BIT_SET(BuildingFlags)

    43

    44

enum HouseZones {                  ///< Bit  Value       Meaning

    45

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

    46

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

    47

	HZ_ZON2              = 0x0002,

    48

	HZ_ZON3              = 0x0004,

    49

	HZ_ZON4              = 0x0008,

    50

	HZ_ZON5              = 0x0010,  ///<                  center of town

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

};

    58

    59

DECLARE_ENUM_AS_BIT_SET(HouseZones)

    60

    61

enum HouseExtraFlags {

    62

	NO_EXTRA_FLAG            =       0,

    63

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

    64

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

    65

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

    66

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

    67

};

    68

    69

DECLARE_ENUM_AS_BIT_SET(HouseExtraFlags)

    70

    71

typedef uint16 HouseID;

    72

typedef uint16 HouseClassID;

    73

    74

struct BuildingCounts {

    75

	uint8 id_count[HOUSE_MAX];

    76

	uint8 class_count[HOUSE_CLASS_MAX];

    77

};

    78

    79

struct Town;

    80

DECLARE_OLD_POOL(Town, Town, 3, 8000)

    81

    82

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

    83

	TileIndex xy;

    84

    85

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

    86

	uint16 num_houses;

    87

	uint32 population;

    88

    89

	/* Town name */

    90

	uint32 townnamegrfid;

    91

	uint16 townnametype;

    92

	uint32 townnameparts;

    93

    94

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

    95

	ViewportSign sign;

    96

    97

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

    98

	 * bit 0 = Building funds received

    99

	 * bit 1 = CHURCH

   100

	 * bit 2 = STADIUM */

   101

	byte flags12;

   102

   103

	/* Which players have a statue? */

   104

	byte statues;

   105

   106

	/* Player ratings as well as a mask that determines which players have a rating. */

   107

	byte have_ratings;

   108

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

   109

	PlayerByte exclusivity;      ///< which player has exslusivity

   110

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

   111

	int16 ratings[MAX_PLAYERS];

   112

   113

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

   114

	uint32 max_pass;

   115

	uint32 max_mail;

   116

	uint32 new_max_pass;

   117

	uint32 new_max_mail;

   118

	uint32 act_pass;

   119

	uint32 act_mail;

   120

	uint32 new_act_pass;

   121

	uint32 new_act_mail;

   122

   123

	/* Amount of passengers that were transported. */

   124

	byte pct_pass_transported;

   125

	byte pct_mail_transported;

   126

   127

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

   128

	uint16 act_food;

   129

	uint16 act_water;

   130

	uint16 new_act_food;

   131

	uint16 new_act_water;

   132

   133

	/* Time until we rebuild a house. */

   134

	uint16 time_until_rebuild;

   135

   136

	/* When to grow town next time. */

   137

	uint16 grow_counter;

   138

	int16 growth_rate;

   139

   140

	/* Fund buildings program in action? */

   141

	byte fund_buildings_months;

   142

   143

	/* Fund road reconstruction in action? */

   144

	byte road_build_months;

   145

   146

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

   147

	bool larger_town;

   148

   149

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

   150

	uint16 radius[5];

   151

   152

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

   153

	BuildingCounts building_counts;

   154

   155

	/**

   156

	 * Creates a new town

   157

	 */

   158

	Town(TileIndex tile = 0);

   159

   160

	/** Destroy the town */

   161

	~Town();

   162

   163

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

   164

};

   165

   166

struct HouseSpec {

   167

	/* Standard properties */

   168

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

   169

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

   170

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

   171

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

   172

	StringID building_name;            ///< building name

   173

	uint16 remove_rating_decrease;     ///< rating decrease if removed

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

   181

	/* NewHouses properties */

   182

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

   183

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

   184

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

   185

	uint16 callback_mask;              ///< House callback flags

   186

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

   187

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

   188

	HouseExtraFlags extra_flags;       ///< some more flags

   189

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

   190

	byte animation_frames;             ///< number of animation frames

   191

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

   192

	byte processing_time;              ///< Periodic refresh multiplier

   193

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

   194

   195

	/* grf file related properties*/

   196

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

   197

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

   198

};

   199

   200

enum TownSizeMode {

   201

	TSM_RANDOM,

   202

	TSM_FIXED,

   203

	TSM_CITY

   204

};

   205

   206

VARDEF HouseSpec _house_specs[HOUSE_MAX];

   207

   208

uint32 GetWorldPopulation();

   209

   210

void UpdateTownVirtCoord(Town *t);

   211

void UpdateAllTownVirtCoords();

   212

void InitializeTown();

   213

void ShowTownViewWindow(TownID town);

   214

void ExpandTown(Town *t);

   215

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

   216

   217

enum {

   218

	ROAD_REMOVE = 0,

   219

	UNMOVEABLE_REMOVE = 1,

   220

	TUNNELBRIDGE_REMOVE = 1,

   221

	INDUSTRY_REMOVE = 2

   222

};

   223

   224

enum {

   225

	/* These refer to the maximums, so Appalling is -1000 to -400

   226

	 * MAXIMUM RATINGS BOUNDARIES */

   227

	RATING_MINIMUM     = -1000,

   228

	RATING_APPALLING   =  -400,

   229

	RATING_VERYPOOR    =  -200,

   230

	RATING_POOR        =     0,

   231

	RATING_MEDIOCRE    =   200,

   232

	RATING_GOOD        =   400,

   233

	RATING_VERYGOOD    =   600,

   234

	RATING_EXCELLENT   =   800,

   235

	RATING_OUTSTANDING =  1000,         ///< OUTSTANDING

   236

   237

	RATING_MAXIMUM = RATING_OUTSTANDING,

   238

   239

	/* RATINGS AFFECTING NUMBERS */

   240

	RATING_TREE_DOWN_STEP = -35,

   241

	RATING_TREE_MINIMUM   = RATING_MINIMUM,

   242

	RATING_TREE_UP_STEP   = 7,

   243

	RATING_TREE_MAXIMUM   = 220,

   244

   245

	RATING_TUNNEL_BRIDGE_DOWN_STEP = -250,

   246

	RATING_TUNNEL_BRIDGE_MINIMUM   = 0,

   247

   248

	RATING_INDUSTRY_DOWN_STEP = -1500,

   249

	RATING_INDUSTRY_MINIMUM   = RATING_MINIMUM,

   250

   251

	RATING_ROAD_DOWN_STEP = -50,

   252

	RATING_ROAD_MINIMUM   = -100,

   253

	RATING_HOUSE_MINIMUM  = RATING_MINIMUM,

   254

   255

	RATING_BRIBE_UP_STEP = 200,

   256

	RATING_BRIBE_MAXIMUM = 800,

   257

	RATING_BRIBE_DOWN_TO = -50        // XXX SHOULD BE SOMETHING LOWER?

   258

};

   259

   260

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

   261

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

   262

 * in TTD. */

   263

static const byte TOWN_GROWTH_FREQUENCY = 70;

   264

   265

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

   266

 * construction. */

   267

static const byte TOWN_HOUSE_COMPLETED = 3;

   268

   269

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

   270

 * IT simply states what bit is used for.

   271

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

   272

 * per town, NO MATTER the population of it.

   273

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

   274

 */

   275

enum {

   276

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

   277

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

   278

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

   279

};

   280

   281

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

   282

   283

VARDEF const Town** _town_sort;

   284

   285

static inline HouseSpec *GetHouseSpecs(HouseID house_id)

   286

{

   287

	assert(house_id < HOUSE_MAX);

   288

	return &_house_specs[house_id];

   289

}

   290

   291

/**

   292

 * Check if a TownID is valid.

   293

 * @param index to inquiry in the pool of town

   294

 * @return true if it exists

   295

 */

   296

static inline bool IsValidTownID(TownID index)

   297

{

   298

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

   299

}

   300

   301

VARDEF uint _total_towns;

   302

   303

static inline TownID GetMaxTownIndex()

   304

{

   305

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

   306

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

   307

	 *  _really_ returns the highest index. Now it just returns

   308

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

   309

	 */

   310

	return GetTownPoolSize() - 1;

   311

}

   312

   313

static inline uint GetNumTowns()

   314

{

   315

	return _total_towns;

   316

}

   317

   318

/**

   319

 * Return a random valid town.

   320

 */

   321

static inline Town *GetRandomTown()

   322

{

   323

	int num = RandomRange(GetNumTowns());

   324

	TownID index = INVALID_TOWN;

   325

   326

	while (num >= 0) {

   327

		num--;

   328

   329

		index++;

   330

		/* Make sure we have a valid town */

   331

		while (!IsValidTownID(index)) {

   332

			index++;

   333

			assert(index <= GetMaxTownIndex());

   334

		}

   335

	}

   336

   337

	return GetTown(index);

   338

}

   339

   340

Town* CalcClosestTownFromTile(TileIndex tile, uint threshold);

   341

   342

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

   343

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

   344

   345

VARDEF bool _town_sort_dirty;

   346

VARDEF byte _town_sort_order;

   347

   348

VARDEF Town *_cleared_town;

   349

VARDEF int _cleared_town_rating;

   350

   351

uint OriginalTileRandomiser(uint x, uint y);

   352

void ResetHouses();

   353

   354

void ClearTownHouse(Town *t, TileIndex tile);

   355

void AfterLoadTown();

   356

void UpdateTownMaxPass(Town *t);

   357

bool CheckIfAuthorityAllows(TileIndex tile);

   358

Town *ClosestTownFromTile(TileIndex tile, uint threshold);

   359

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

   360

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

   361

   362

#endif /* TOWN_H */